G4MTcoutDestination Class Reference

#include <G4MTcoutDestination.hh>

Inheritance diagram for G4MTcoutDestination:

Public Types
using	Transformer = std::function< G4bool(G4String &)>

Public Member Functions
void	AddCerrFileName (const G4String &fileN="G4cerr.txt", G4bool ifAppend=true)
void	AddCerrTransformer (const Transformer &t)
void	AddCerrTransformer (Transformer &&t)
void	AddCoutFileName (const G4String &fileN="G4cout.txt", G4bool ifAppend=true)
void	AddCoutTransformer (const Transformer &t)
void	AddCoutTransformer (Transformer &&t)
void	EnableBuffering (G4bool flag=true)
	G4MTcoutDestination (const G4int &threadId)
G4String	GetFullPrefixString () const
G4String	GetPrefixString () const
virtual G4int	ReceiveG4cerr (const G4String &msg) override
G4int	ReceiveG4cerr_ (const G4String &msg)
virtual G4int	ReceiveG4cout (const G4String &msg) override
G4int	ReceiveG4cout_ (const G4String &msg)
virtual void	Reset ()
virtual void	ResetTransformers ()
void	SetCerrFileName (const G4String &fileN="G4cerr.txt", G4bool ifAppend=true)
void	SetCoutFileName (const G4String &fileN="G4cout.txt", G4bool ifAppend=true)
void	SetDefaultOutput (G4bool addMasterDestination=true, G4bool formatAlsoMaster=true)
void	SetIgnoreCout (G4int tid=0)
void	SetIgnoreInit (G4bool val=true)
void	SetPrefixString (const G4String &wd="G4WT")
virtual	~G4MTcoutDestination ()

Protected Member Functions
void	AddMasterOutput (G4bool formatAlsoMaster)
void	HandleFileCerr (G4String fileN, G4bool appendFlag, G4bool suppressDefault)
void	HandleFileCout (G4String fileN, G4bool appendFlag, G4bool suppressDefault)

Protected Attributes
std::vector< Transformer >	transformersCerr
std::vector< Transformer >	transformersCout

Static Protected Attributes
static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Private Member Functions
void	DumpBuffer ()

Private Attributes
const G4int	id
G4bool	ignoreCout = false
G4bool	ignoreInit = true
G4bool	masterDestinationFlag = true
G4bool	masterDestinationFmtFlag = true
G4String	prefix = "G4WT"
G4coutDestination *	ref_defaultOut = nullptr
G4coutDestination *	ref_masterOut = nullptr
G4StateManager *	stateMgr = nullptr
G4bool	useBuffer = false

Detailed Description

Definition at line 45 of file G4MTcoutDestination.hh.

Member Typedef Documentation

Transformer

using G4coutDestination::Transformer = std::function<G4bool(G4String&)>

inherited

Definition at line 61 of file G4coutDestination.hh.

Constructor & Destructor Documentation

G4MTcoutDestination()

G4MTcoutDestination::G4MTcoutDestination ( const G4int &  threadId )

explicit

Definition at line 48 of file G4MTcoutDestination.cc.

  : id(threadId)
{
  // TODO: Move these two out of here and in the caller
  G4coutbuf.SetDestination(this);
  G4cerrbuf.SetDestination(this);
 
  stateMgr = G4StateManager::GetStateManager();
  SetDefaultOutput(masterDestinationFlag, masterDestinationFmtFlag);
}

References G4cerrbuf, G4coutbuf, G4StateManager::GetStateManager(), masterDestinationFlag, masterDestinationFmtFlag, SetDefaultOutput(), G4strstreambuf::SetDestination(), and stateMgr.

~G4MTcoutDestination()

G4MTcoutDestination::~G4MTcoutDestination ( )

virtual

Definition at line 132 of file G4MTcoutDestination.cc.

{
  if(useBuffer)
    DumpBuffer();
}

References DumpBuffer(), and useBuffer.

Member Function Documentation

AddCerrFileName()

void G4MTcoutDestination::AddCerrFileName	(	const G4String &	fileN = "G4cerr.txt",
		G4bool	ifAppend = true
	)

Definition at line 254 of file G4MTcoutDestination.cc.

{
  HandleFileCerr(fileN, ifAppend, false);
}

References HandleFileCerr().

AddCerrTransformer() [1/2]

void G4coutDestination::AddCerrTransformer ( const Transformer &  t )

inlineinherited

Definition at line 67 of file G4coutDestination.hh.

  {
    transformersCerr.push_back(t);
  }

References G4coutDestination::transformersCerr.

Referenced by HandleFileCerr().

AddCerrTransformer() [2/2]

void G4coutDestination::AddCerrTransformer ( Transformer &&  t )

inlineinherited

Definition at line 71 of file G4coutDestination.hh.

{ transformersCerr.push_back(t); }

References G4coutDestination::transformersCerr.

AddCoutFileName()

void G4MTcoutDestination::AddCoutFileName	(	const G4String &	fileN = "G4cout.txt",
		G4bool	ifAppend = true
	)

Definition at line 233 of file G4MTcoutDestination.cc.

{
  // This is like the equivalent SetCoutFileName, but in this case we do not
  // remove or silence what is already exisiting
  HandleFileCout(fileN, ifAppend, false);
}

References HandleFileCout().

AddCoutTransformer() [1/2]

void G4coutDestination::AddCoutTransformer ( const Transformer &  t )

inlineinherited

Definition at line 62 of file G4coutDestination.hh.

  {
    transformersCout.push_back(t);
  }

References G4coutDestination::transformersCout.

Referenced by AddMasterOutput(), HandleFileCout(), and SetDefaultOutput().

AddCoutTransformer() [2/2]

void G4coutDestination::AddCoutTransformer ( Transformer &&  t )

inlineinherited

Definition at line 66 of file G4coutDestination.hh.

{ transformersCout.push_back(t); }

References G4coutDestination::transformersCout.

AddMasterOutput()

void G4MTcoutDestination::AddMasterOutput ( G4bool  formatAlsoMaster )

protected

Definition at line 99 of file G4MTcoutDestination.cc.

{
  // Add a destination, that forwards the message to the master thread
  auto forwarder = G4coutDestinationUPtr(new G4MasterForwardcoutDestination);
  ref_masterOut  = forwarder.get();
  const auto filter_out = [this](G4String&) -> G4bool {
    if(this->ignoreCout ||
       (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Idle))
    {
      return false;
    }
    return true;
  };
  forwarder->AddCoutTransformer(filter_out);
  if(formatAlsoMaster)
  {
    // Formatter: add prefix to each thread
    const auto f = [this](G4String& msg) -> G4bool {
      std::ostringstream str;
      str << prefix;
      if(id != G4Threading::GENERICTHREAD_ID)
        str << id;
      str << " > " << msg;
      msg = str.str();
      return true;
    };
    forwarder->AddCoutTransformer(f);
    forwarder->AddCerrTransformer(f);
  }
  push_back(std::move(forwarder));
}

References G4coutDestination::AddCoutTransformer(), G4State_Idle, G4Threading::GENERICTHREAD_ID, G4StateManager::GetCurrentState(), id, ignoreCout, ignoreInit, prefix, ref_masterOut, and stateMgr.

Referenced by SetDefaultOutput().

DumpBuffer()

void G4MTcoutDestination::DumpBuffer ( )

private

Definition at line 279 of file G4MTcoutDestination.cc.

{
  G4AutoLock l(&coutm);
  std::ostringstream msg;
  msg << "=======================\n";
  msg << "cout buffer(s) for worker with ID:" << id << std::endl;
  G4coutDestination::ReceiveG4cout(msg.str());
  G4bool sep = false;
  std::for_each(begin(), end(), [this, &sep](G4coutDestinationUPtr& el) {
    auto cout = dynamic_cast<G4BuffercoutDestination*>(el.get());
    if(cout != nullptr)
    {
      cout->FlushG4cout();
      if(sep)
      {
        G4coutDestination::ReceiveG4cout("==========\n");
      }
      else
      {
        sep = true;
      }
    }
  });
  sep = false;
  msg.str("");
  msg.clear();
  msg << "=======================\n";
  msg << "cerr buffer(s) for worker with ID:" << id << " (goes to std error)"
      << std::endl;
  G4coutDestination::ReceiveG4cout(msg.str());
  std::for_each(begin(), end(), [this, &sep](G4coutDestinationUPtr& el) {
    auto cout = dynamic_cast<G4BuffercoutDestination*>(el.get());
    if(cout != nullptr)
    {
      cout->FlushG4cerr();
      if(sep)
      {
        G4coutDestination::ReceiveG4cout("==========\n");
      }
      else
      {
        sep = true;
      }
    }
  });
  G4coutDestination::ReceiveG4cout("=======================\n");
}

References anonymous_namespace{G4MTcoutDestination.cc}::coutm, G4BuffercoutDestination::FlushG4cerr(), G4BuffercoutDestination::FlushG4cout(), and G4coutDestination::ReceiveG4cout().

Referenced by EnableBuffering(), and ~G4MTcoutDestination().

EnableBuffering()

void G4MTcoutDestination::EnableBuffering

(

G4bool

flag = true

)

Definition at line 202 of file G4MTcoutDestination.cc.

{
  // I was using buffered output and now I want to turn it off, dump current
  // buffer content and reset output
  if(useBuffer && !flag)
  {
    DumpBuffer();
    Reset();
  }
  else if(useBuffer && flag)
  { /* do nothing: already using */
  }
  else if(!useBuffer && !flag)
  { /* do nothing: not using */
  }
  else if(!useBuffer && flag)
  {
    // Remove everything, in this case also removing the forward to the master
    // thread, we want everything to be dumpled to a file
    clear();
    const size_t infiniteSize = 0;
    push_back(G4coutDestinationUPtr(new G4BuffercoutDestination(infiniteSize)));
  }
  else  // Should never happen
  {
    assert(false);
  }
  useBuffer = flag;
}

References DumpBuffer(), Reset(), and useBuffer.

Referenced by G4UImanager::SetThreadUseBuffer().

GetFullPrefixString()

G4String G4MTcoutDestination::GetFullPrefixString ( ) const

inline

Definition at line 73 of file G4MTcoutDestination.hh.

  {
    std::stringstream os;
    os << prefix << id;
    return os.str();
  }

References id.

Referenced by G4UIQt::GetThreadPrefix().

GetPrefixString()

G4String G4MTcoutDestination::GetPrefixString ( ) const

inline

Definition at line 72 of file G4MTcoutDestination.hh.

{ return prefix; }

References prefix.

Referenced by G4UIQt::GetThreadPrefix().

HandleFileCerr()

void G4MTcoutDestination::HandleFileCerr ( G4String  fileN, G4bool  appendFlag, G4bool  suppressDefault  )

protected

Definition at line 171 of file G4MTcoutDestination.cc.

{
  // See HandleFileCout for explanation, switching cout with cerr
 
  std::ios_base::openmode mode =
    (ifAppend ? std::ios_base::app : std::ios_base::trunc);
  auto output = G4coutDestinationUPtr(new G4FilecoutDestination(fileN, mode));
  output->AddCoutTransformer([](G4String&) { return false; });
  push_back(std::move(output));
  if(suppressDefault)
  {
    ref_defaultOut->AddCerrTransformer([](G4String&) { return false; });
    if(ref_masterOut)
      ref_masterOut->AddCerrTransformer([](G4String&) { return false; });
  }
}

References G4coutDestination::AddCerrTransformer(), demo::app, ref_defaultOut, and ref_masterOut.

Referenced by AddCerrFileName(), and SetCerrFileName().

HandleFileCout()

void G4MTcoutDestination::HandleFileCout ( G4String  fileN, G4bool  appendFlag, G4bool  suppressDefault  )

protected

Definition at line 146 of file G4MTcoutDestination.cc.

{
  // Logic: we create a file destination. We want this to get only the G4cout
  // stream and should discard everything in G4cerr.
  // First we create the destination with the appropriate open mode
 
  std::ios_base::openmode mode =
    (ifAppend ? std::ios_base::app : std::ios_base::trunc);
  auto output = G4coutDestinationUPtr(new G4FilecoutDestination(fileN, mode));
 
  // This reacts only to G4cout, so let's make a filter that removes everything
  // from G4cerr
  output->AddCerrTransformer([](G4String&) { return false; });
  push_back(std::move(output));
  // Silence G4cout from default formatter
  if(suppressDefault)
  {
    ref_defaultOut->AddCoutTransformer([](G4String&) { return false; });
    if(ref_masterOut)
      ref_masterOut->AddCoutTransformer([](G4String&) { return false; });
  }
}

References G4coutDestination::AddCoutTransformer(), demo::app, ref_defaultOut, and ref_masterOut.

Referenced by AddCoutFileName(), and SetCoutFileName().

ReceiveG4cerr()

virtual G4int G4MulticoutDestination::ReceiveG4cerr ( const G4String &  msg )

inlineoverridevirtualinherited

Reimplemented from G4coutDestination.

Definition at line 79 of file G4MulticoutDestination.hh.

  {
    G4bool result = true;
    std::for_each(begin(), end(), [&](G4coutDestinationUPtr& e) {
      result &= (e->ReceiveG4cerr_(msg) == 0);
    });
    return (result ? 0 : -1);
  }

ReceiveG4cerr_()

G4int G4coutDestination::ReceiveG4cerr_ ( const G4String &  msg )

inherited

Definition at line 84 of file G4coutDestination.cc.

{
  if(transformersCout.size() > 0)
  {
    G4String m = msg;
    std::for_each(transformersCerr.begin(), transformersCerr.end(),
                  [&m](const Transformer& t) { t(m); }
                  // Call transforming function on message
    );
    return ReceiveG4cerr(m);
  }
  else
  {
    return ReceiveG4cerr(msg);
  }
}

References m, G4coutDestination::ReceiveG4cerr(), G4coutDestination::transformersCerr, and G4coutDestination::transformersCout.

Referenced by G4MasterForwardcoutDestination::ReceiveG4cerr().

ReceiveG4cout()

virtual G4int G4MulticoutDestination::ReceiveG4cout ( const G4String &  msg )

inlineoverridevirtualinherited

Reimplemented from G4coutDestination.

Definition at line 70 of file G4MulticoutDestination.hh.

  {
    G4bool result = true;
    std::for_each(begin(), end(), [&](G4coutDestinationUPtr& e) {
      result &= (e->ReceiveG4cout_(msg) == 0);
    });
    return (result ? 0 : -1);
  }

ReceiveG4cout_()

G4int G4coutDestination::ReceiveG4cout_ ( const G4String &  msg )

inherited

Definition at line 62 of file G4coutDestination.cc.

{
  // Avoid copy of string if not necessary
  if(transformersCout.size() > 0)
  {
    G4String m    = msg;
    G4bool result = true;
    for(const auto& el : transformersCout)
    {
      result &= el(m);
      if(!result)
        break;
    }
    return (result ? ReceiveG4cout(m) : 0);
  }
  else
  {
    return ReceiveG4cout(msg);
  }
}

References m, G4coutDestination::ReceiveG4cout(), and G4coutDestination::transformersCout.

Referenced by G4MasterForwardcoutDestination::ReceiveG4cout().

Reset()

void G4MTcoutDestination::Reset ( )

virtual

Definition at line 139 of file G4MTcoutDestination.cc.

{
  clear();
  SetDefaultOutput(masterDestinationFlag, masterDestinationFmtFlag);
}

References masterDestinationFlag, masterDestinationFmtFlag, and SetDefaultOutput().

Referenced by EnableBuffering(), SetCerrFileName(), and SetCoutFileName().

ResetTransformers()

void G4coutDestination::ResetTransformers ( )

virtualinherited

Definition at line 41 of file G4coutDestination.cc.

{
  transformersCout.clear();
  transformersCerr.clear();
}

References G4coutDestination::transformersCerr, and G4coutDestination::transformersCout.

SetCerrFileName()

void G4MTcoutDestination::SetCerrFileName	(	const G4String &	fileN = "G4cerr.txt",
		G4bool	ifAppend = true
	)

Definition at line 242 of file G4MTcoutDestination.cc.

{
  // See SetCoutFileName for explanation
  Reset();
  if(fileN != "**Screen**")
  {
    HandleFileCerr(fileN, ifAppend, true);
  }
}

References HandleFileCerr(), and Reset().

Referenced by G4UImanager::SetCerrFileName().

SetCoutFileName()

void G4MTcoutDestination::SetCoutFileName	(	const G4String &	fileN = "G4cout.txt",
		G4bool	ifAppend = true
	)

Definition at line 190 of file G4MTcoutDestination.cc.

{
  // First let's go back to the default
  Reset();
  if(fileN != "**Screen**")
  {
    HandleFileCout(fileN, ifAppend, true);
  }
}

References HandleFileCout(), and Reset().

Referenced by G4UImanager::SetCoutFileName().

SetDefaultOutput()

void G4MTcoutDestination::SetDefaultOutput	(	G4bool	addMasterDestination = true,
		G4bool	formatAlsoMaster = true
	)

Definition at line 60 of file G4MTcoutDestination.cc.

{
  masterDestinationFlag    = addmasterDestination;
  masterDestinationFmtFlag = formatAlsoMaster;
  // Formatter: add prefix to each thread
  const auto f = [this](G4String& msg) -> G4bool {
    std::ostringstream str;
    str << prefix;
    if(id != G4Threading::GENERICTHREAD_ID)
      str << id;
    str << " > " << msg;
    msg = str.str();
    return true;
  };
  // Block cout if not in correct state
  const auto filter_out = [this](G4String&) -> G4bool {
    if(this->ignoreCout ||
       (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Init))
    {
      return false;
    }
    return true;
  };
 
  // Default behavior, add a destination that uses cout and uses a mutex
  auto output    = G4coutDestinationUPtr(new G4LockcoutDestination);
  ref_defaultOut = output.get();
  output->AddCoutTransformer(filter_out);
  output->AddCoutTransformer(f);
  output->AddCerrTransformer(f);
  push_back(std::move(output));
  if(addmasterDestination)
  {
    AddMasterOutput(formatAlsoMaster);
  }
}

References G4coutDestination::AddCoutTransformer(), AddMasterOutput(), G4State_Init, G4Threading::GENERICTHREAD_ID, G4StateManager::GetCurrentState(), id, ignoreCout, ignoreInit, masterDestinationFlag, masterDestinationFmtFlag, prefix, ref_defaultOut, and stateMgr.

Referenced by G4MTcoutDestination(), and Reset().

SetIgnoreCout()

void G4MTcoutDestination::SetIgnoreCout

(

G4int

tid = 0

)

Definition at line 261 of file G4MTcoutDestination.cc.

{
  if(tid < 0)
  {
    ignoreCout = false;
  }
  else
  {
    ignoreCout = (tid != id);
  }
}

References id, and ignoreCout.

Referenced by G4UImanager::SetThreadIgnore(), G4UImanager::SetUpForAThread(), and G4UImanager::SetUpForSpecialThread().

SetIgnoreInit()

void G4MTcoutDestination::SetIgnoreInit ( G4bool  val = true )

inline

Definition at line 70 of file G4MTcoutDestination.hh.

{ ignoreInit = val; }

References ignoreInit.

Referenced by G4UImanager::SetThreadIgnoreInit().

SetPrefixString()

void G4MTcoutDestination::SetPrefixString ( const G4String &  wd = "G4WT" )

inline

Definition at line 67 of file G4MTcoutDestination.hh.

{ prefix = wd; }

Referenced by G4UImanager::SetThreadPrefixString(), and G4UImanager::SetUpForSpecialThread().

Field Documentation

id

const G4int G4MTcoutDestination::id

private

Definition at line 99 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), GetFullPrefixString(), SetDefaultOutput(), and SetIgnoreCout().

ignoreCout

G4bool G4MTcoutDestination::ignoreCout = false

private

Definition at line 101 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), SetDefaultOutput(), and SetIgnoreCout().

ignoreInit

G4bool G4MTcoutDestination::ignoreInit = true

private

Definition at line 102 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), SetDefaultOutput(), and SetIgnoreInit().

masterDestinationFlag

G4bool G4MTcoutDestination::masterDestinationFlag = true

private

Definition at line 96 of file G4MTcoutDestination.hh.

Referenced by G4MTcoutDestination(), Reset(), and SetDefaultOutput().

masterDestinationFmtFlag

G4bool G4MTcoutDestination::masterDestinationFmtFlag = true

private

Definition at line 97 of file G4MTcoutDestination.hh.

Referenced by G4MTcoutDestination(), Reset(), and SetDefaultOutput().

masterG4coutDestination

G4coutDestination * G4coutDestination::masterG4coutDestination = nullptr

staticprotectedinherited

Definition at line 88 of file G4coutDestination.hh.

Referenced by G4UIQt::G4UIQt(), G4MasterForwardcoutDestination::ReceiveG4cerr(), G4MasterForwardcoutDestination::ReceiveG4cout(), and G4UIQt::~G4UIQt().

prefix

G4String G4MTcoutDestination::prefix = "G4WT"

private

Definition at line 104 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), GetPrefixString(), and SetDefaultOutput().

ref_defaultOut

G4coutDestination* G4MTcoutDestination::ref_defaultOut = nullptr

private

Definition at line 92 of file G4MTcoutDestination.hh.

Referenced by HandleFileCerr(), HandleFileCout(), and SetDefaultOutput().

ref_masterOut

G4coutDestination* G4MTcoutDestination::ref_masterOut = nullptr

private

Definition at line 95 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), HandleFileCerr(), and HandleFileCout().

stateMgr

G4StateManager* G4MTcoutDestination::stateMgr = nullptr

private

Definition at line 105 of file G4MTcoutDestination.hh.

Referenced by AddMasterOutput(), G4MTcoutDestination(), and SetDefaultOutput().

transformersCerr

std::vector<Transformer> G4coutDestination::transformersCerr

protectedinherited

Definition at line 94 of file G4coutDestination.hh.

Referenced by G4coutDestination::AddCerrTransformer(), G4coutDestination::ReceiveG4cerr_(), and G4coutDestination::ResetTransformers().

transformersCout

std::vector<Transformer> G4coutDestination::transformersCout

protectedinherited

Definition at line 93 of file G4coutDestination.hh.

Referenced by G4coutDestination::AddCoutTransformer(), G4coutDestination::ReceiveG4cerr_(), G4coutDestination::ReceiveG4cout_(), and G4coutDestination::ResetTransformers().

useBuffer

G4bool G4MTcoutDestination::useBuffer = false

private

Definition at line 100 of file G4MTcoutDestination.hh.

Referenced by EnableBuffering(), and ~G4MTcoutDestination().

---

The documentation for this class was generated from the following files:

• source/global/management/include/G4MTcoutDestination.hh
• source/global/management/src/G4MTcoutDestination.cc