GGSSmartLog.cpp

/*
 * SmartLog.cpp
 *
 *  Created on: 24 Nov 2014
 *      Author: Nicola Mori
 */

#include "utils/GGSSmartLog.h"

#ifdef GGS_USE_G4
#include "G4strstreambuf.hh"
#endif

#include <fstream>

namespace GGSSmartLog {

const char *levelNames[6] = {"", "ERROR", "WARNING", "INFO", "DEBUG", "DEEPDEB"};
int verboseLevel = INFO;
int maxRoutineNameLength = 30;

const std::string &Format(const std::string &str, unsigned int maxLength) {
  static std::string returnStr;
  returnStr = str;
  if (returnStr.length() > maxLength) {
    returnStr = returnStr.substr(0, maxLength - 3).append("...");
  }
  return returnStr;
}

// Mute-unmute routines.
// From: https://bbs.archlinux.org/viewtopic.php?id=79378
// Modified to mute also C-style output and G4 thread-safe output.

namespace {

// Backup buffers for regular console output
FILE *stdoutSave = nullptr;
FILE *stderrSave = nullptr;

std::streambuf *cout_sbuf = nullptr;
std::streambuf *cerr_sbuf = nullptr;

bool isMuted = false;

// Backup buffers for G4 console output
#ifdef GGS_USE_G4
G4ThreadLocal G4coutDestination *g4cout_dest = nullptr;
G4ThreadLocal G4coutDestination *g4cerr_dest = nullptr;
class MutecoutDestination : public G4coutDestination {
public:
  G4int ReceiveG4cout(const G4String &) override { return 0; }
  G4int ReceiveG4cerr(const G4String &) override { return 0; }
};

MutecoutDestination g4MuteDest;
G4ThreadLocal bool isThreadMuted = false;
#endif

class FilesProxy {
public:
  FilesProxy() : fout("/dev/null"), muteOut(fopen("/dev/null", "w")) {}
  ~FilesProxy() {
    fout.close();
    fclose(muteOut);
  }
  std::ofstream fout;
  FILE *muteOut;
#ifdef GGS_USE_G4
  MutecoutDestination g4MuteDest;
#endif
};

FilesProxy muteFiles;

} // namespace

void MuteOutput() {

  if (!isMuted) {
    stdoutSave = stdout;
    stdout = muteFiles.muteOut;
    stderrSave = stderr;
    stderr = muteFiles.muteOut;

    cout_sbuf = std::cout.rdbuf();
    cerr_sbuf = std::cerr.rdbuf();
    std::cout.rdbuf(muteFiles.fout.rdbuf());
    std::cerr.rdbuf(muteFiles.fout.rdbuf());

    isMuted = true;
  }
}

void UnmuteOutput() {
  if (stdoutSave) {
    stdout = stdoutSave;
    stdoutSave = nullptr;
  }
  if (stderrSave) {
    stderr = stderrSave;
    stderrSave = nullptr;
  }

  if (cout_sbuf) {
    std::cout.rdbuf(cout_sbuf);
    cout_sbuf = nullptr;
  }
  if (cerr_sbuf) {
    std::cerr.rdbuf(cerr_sbuf);
    cerr_sbuf = nullptr;
  }

  isMuted = false;
}

#ifdef GGS_USE_G4
void MuteG4Output() {

  if (!isThreadMuted) {
    g4cout_dest = G4coutbuf.GetDestination();
    G4coutbuf.SetDestination(&muteFiles.g4MuteDest);
    g4cerr_dest = G4cerrbuf.GetDestination();
    G4cerrbuf.SetDestination(&muteFiles.g4MuteDest);

    isThreadMuted = true;
  }
}

void UnmuteG4Output() {
  if (g4cout_dest) {
    G4coutbuf.SetDestination(g4cout_dest);
    g4cout_dest = nullptr;
  }
  if (g4cerr_dest) {
    G4cerrbuf.SetDestination(g4cerr_dest);
    g4cout_dest = nullptr;
  }

  isThreadMuted = false;
}

#endif

} // namespace GGSSmartLog