G4MTcoutDestination Class Reference

#include <G4MTcoutDestination.hh>

Inheritance diagram for G4MTcoutDestination:

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

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

Additional Inherited Members
Public Types inherited from G4coutDestination
using	Transformer = std::function<G4bool(G4String&)>
Protected Attributes inherited from G4coutDestination
std::vector< Transformer >	transformersDebug
std::vector< Transformer >	transformersCout
std::vector< Transformer >	transformersCerr
Static Protected Attributes inherited from G4coutDestination
static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Detailed Description

Definition at line 45 of file G4MTcoutDestination.hh.

Constructor & Destructor Documentation

G4MTcoutDestination()

G4MTcoutDestination::G4MTcoutDestination ( const G4int & threadId )

explicit

Definition at line 48 of file G4MTcoutDestination.cc.

  : id(threadId)
{
  // TODO: Move this out of here and in the caller
  G4iosSetDestination(this);
 
  stateMgr = G4StateManager::GetStateManager();
  SetDefaultOutput(masterDestinationFlag, masterDestinationFmtFlag);
}

~G4MTcoutDestination()

G4MTcoutDestination::~G4MTcoutDestination ( )

override

Definition at line 133 of file G4MTcoutDestination.cc.

{
  if(useBuffer)
  {
    DumpBuffer();
  }
}

Member Function Documentation

AddCerrFileName()

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

Definition at line 262 of file G4MTcoutDestination.cc.

{
  HandleFileCerr(fileN, ifAppend, false);
}

AddCoutFileName()

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

Definition at line 241 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);
}

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 {
    return !(
      this->ignoreCout ||
      (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Idle));
  };
  forwarder->AddDebugTransformer(filter_out);
  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->AddDebugTransformer(f);
    forwarder->AddCoutTransformer(f);
    forwarder->AddCerrTransformer(f);
  }
  push_back(std::move(forwarder));
}

Referenced by SetDefaultOutput().

EnableBuffering()

void G4MTcoutDestination::EnableBuffering

(

G4bool

flag = true

)

Definition at line 210 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;
}

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();
  }

GetPrefixString()

G4String G4MTcoutDestination::GetPrefixString ( ) const

inline

Definition at line 72 of file G4MTcoutDestination.hh.

{ return prefix; }

HandleFileCerr()

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

protected

Definition at line 176 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->AddDebugTransformer([](G4String&) { return false; });
  output->AddCoutTransformer([](G4String&) { return false; });
  push_back(std::move(output));
  if(suppressDefault)
  {
    ref_defaultOut->AddCerrTransformer([](G4String&) { return false; });
    if(ref_masterOut != nullptr)
    {
      ref_masterOut->AddCerrTransformer([](G4String&) { return false; });
    }
  }
}

Referenced by AddCerrFileName(), and SetCerrFileName().

HandleFileCout()

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

protected

Definition at line 149 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 ignores all other streams
  output->AddDebugTransformer([](G4String&) { return false; });
  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 != nullptr)
    {
      ref_masterOut->AddCoutTransformer([](G4String&) { return false; });
    }
  }
}

Referenced by AddCoutFileName(), and SetCoutFileName().

Reset()

void G4MTcoutDestination::Reset ( )

virtual

Definition at line 142 of file G4MTcoutDestination.cc.

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

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

SetCerrFileName()

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

Definition at line 250 of file G4MTcoutDestination.cc.

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

Referenced by G4UImanager::SetCerrFileName().

SetCoutFileName()

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

Definition at line 198 of file G4MTcoutDestination.cc.

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

Referenced by G4UImanager::SetCoutFileName().

SetDefaultOutput()

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

Definition at line 59 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 {
    return !(
      this->ignoreCout ||
      (this->ignoreInit && this->stateMgr->GetCurrentState() == G4State_Init));
  };
 
  // Default behavior, add a destination that uses cout and uses a mutex
  auto output    = G4coutDestinationUPtr(new G4LockcoutDestination);
  ref_defaultOut = output.get();
  output->AddDebugTransformer(filter_out);
  output->AddDebugTransformer(f);
  output->AddCoutTransformer(filter_out);
  output->AddCoutTransformer(f);
  output->AddCerrTransformer(f);
  push_back(std::move(output));
  if(addmasterDestination)
  {
    AddMasterOutput(formatAlsoMaster);
  }
}

Referenced by G4MTcoutDestination(), and Reset().

SetIgnoreCout()

void G4MTcoutDestination::SetIgnoreCout

(

G4int

tid = 0

)

Definition at line 269 of file G4MTcoutDestination.cc.

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

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; }

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().

---

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

• G4MTcoutDestination.hh
• G4MTcoutDestination.cc