#include <G4UIterminal.hh>

Inheritance diagram for G4UIterminal:

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

Public Member Functions
void	AddCerrTransformer (const Transformer &t)

void	AddCerrTransformer (Transformer &&t)

void	AddCoutTransformer (const Transformer &t)

void	AddCoutTransformer (Transformer &&t)

	G4UIterminal (G4VUIshell *aShell=0, G4bool qsig=true)

G4int	GetLastReturnCode () const

virtual void	PauseSessionStart (const G4String &msg)

virtual G4int	ReceiveG4cerr (const G4String &cerrString)

G4int	ReceiveG4cerr_ (const G4String &msg)

virtual G4int	ReceiveG4cout (const G4String &coutString)

G4int	ReceiveG4cout_ (const G4String &msg)

virtual void	ResetTransformers ()

virtual G4UIsession *	SessionStart ()

void	SetPrompt (const G4String &prompt)

	~G4UIterminal ()

Static Public Member Functions
static G4int	InSession ()

Protected Member Functions
void	ApplyShellCommand (const G4String &, G4bool &, G4bool &)

G4bool	ChangeDirectory (const char *newDir)

void	ChangeDirectoryCommand (const G4String &)

G4String	Complete (const G4String &)

G4UIcommand *	FindCommand (const char *commandName) const

G4UIcommandTree *	FindDirectory (const char *dirName) const

G4String	FindMatchingPath (G4UIcommandTree *, const G4String &)

G4String	GetCurrentWorkingDirectory () const

void	ListDirectory (const G4String &) const

G4String	ModifyToFullPathCommand (const char *aCommandLine) const

void	ShowCurrent (const G4String &) const

void	TerminalHelp (const G4String &)

Protected Attributes
G4int	ifBatch = 0

G4int	lastRC = 0

std::vector< Transformer >	transformersCerr

std::vector< Transformer >	transformersCout

Static Protected Attributes
static G4ICOMS_DLL G4int	inSession = 0

static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Private Member Functions
virtual void	ExecuteCommand (const G4String &aCommand)

virtual void	ExitHelp () const

G4String	GetCommand (const char *msg=0)

virtual G4bool	GetHelpChoice (G4int &aInt)

G4String	ModifyPath (const G4String &tempPath) const

Private Attributes
G4String	currentDirectory

G4bool	iCont

G4bool	iExit

G4VUIshell *	shell

G4UImanager *	UI

Detailed Description

Definition at line 70 of file G4UIterminal.hh.

Member Typedef Documentation

◆ Transformer

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

inherited

Definition at line 61 of file G4coutDestination.hh.

Constructor & Destructor Documentation

◆ G4UIterminal()

G4UIterminal::G4UIterminal	(	G4VUIshell *	aShell = `0`,
		G4bool	qsig = `true`
	)

Definition at line 90 of file G4UIterminal.cc.

{
  UI= G4UImanager::GetUIpointer();
  UI-> SetSession(this);
  UI-> SetCoutDestination(this);
 
  iExit= FALSE;
  iCont= FALSE;
 
  if(aShell) shell= aShell;
  else shell= new G4UIcsh;
  theshell= shell; // locally stored for the signal handler
 
  // add signal handler
  if(qsig) {
#ifndef WIN32
  signal(SIGINT, SignalHandler);
#endif
  }
}

References FALSE, G4UImanager::GetUIpointer(), iCont, iExit, shell, SignalHandler(), theshell, and UI.

◆ ~G4UIterminal()

G4UIterminal::~G4UIterminal ( )

Definition at line 113 of file G4UIterminal.cc.

{ 
  if(shell) delete shell;
 
  if(G4UImanager::GetUIpointer()) {
    UI-> SetSession(NULL);
    UI-> SetCoutDestination(NULL);
  }
}

References G4UImanager::GetUIpointer(), shell, and UI.

Member Function Documentation

◆ 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 G4MTcoutDestination::HandleFileCerr().

◆ AddCerrTransformer() [2/2]

void G4coutDestination::AddCerrTransformer ( Transformer && t )

inlineinherited

Definition at line 71 of file G4coutDestination.hh.

71{ transformersCerr.push_back(t); }

References G4coutDestination::transformersCerr.

◆ 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 G4MTcoutDestination::AddMasterOutput(), G4MTcoutDestination::HandleFileCout(), and G4MTcoutDestination::SetDefaultOutput().

◆ AddCoutTransformer() [2/2]

void G4coutDestination::AddCoutTransformer ( Transformer && t )

inlineinherited

Definition at line 66 of file G4coutDestination.hh.

66{ transformersCout.push_back(t); }

References G4coutDestination::transformersCout.

◆ ApplyShellCommand()

void G4VBasicShell::ApplyShellCommand	(	const G4String &	a_string,
		G4bool &	exitSession,
		G4bool &	exitPause
	)

protectedinherited

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Definition at line 232 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
 
  G4String command = G4StrUtil::lstrip_copy(a_string);
 
  if( command[0] == '#' ) {
 
    G4cout << command << G4endl;
 
  } else if( command == "ls" || command.substr(0,3) == "ls " ) {
 
    ListDirectory( command );
 
  } else if( command == "pwd" ) {
 
    G4cout << "Current Working Directory : "
       << GetCurrentWorkingDirectory() << G4endl;
 
  } else if( command == "cd" || command.substr(0,3) == "cd ") {
 
    ChangeDirectoryCommand ( command );
 
  } else if( command == "help" || command.substr(0,5) == "help ") {
 
    TerminalHelp( command );
 
  } else if( command[0] == '?' ) {
 
    ShowCurrent( command );
 
  } else if( command == "hist" || command == "history") {
 
    G4int nh = UI->GetNumberOfHistory();
    for(G4int i=0;i<nh;i++) {
      G4cout << i << ": " << UI->GetPreviousCommand(i) << G4endl;
    }
 
  } else if( command[0] == '!' ) {
 
    G4String ss = command.substr(1,command.length()-1);
    G4int vl;
    const char* tt = ss;
    std::istringstream is(tt);
    is >> vl;
    G4int nh = UI->GetNumberOfHistory();
    if(vl>=0 && vl<nh) {
      G4String prev = UI->GetPreviousCommand(vl);
      G4cout << prev << G4endl;
      ExecuteCommand (ModifyToFullPathCommand(prev));
    } else {
      G4cerr << "history " << vl << " is not found." << G4endl;
    }
 
  } else if( command == "exit" ) {
 
    if( exitPause == false) { //In a secondary loop.
      G4cout << "You are now processing RUN." << G4endl;
      G4cout << "Please abort it using \"/run/abort\" command first" << G4endl;
      G4cout << " and use \"continue\" command until the application" << G4endl;
      G4cout << " becomes to Idle." << G4endl;
    } else {
      exitSession = true;
    }
 
  } else if( command == "cont" || command == "continue"){
 
    exitPause = true;
 
  } else {
 
    ExecuteCommand(ModifyToFullPathCommand(a_string));
 
  }
}

References G4VBasicShell::ChangeDirectoryCommand(), G4VBasicShell::ExecuteCommand(), exitPause, exitSession, G4cerr, G4cout, G4endl, G4VBasicShell::GetCurrentWorkingDirectory(), G4UImanager::GetNumberOfHistory(), G4UImanager::GetPreviousCommand(), G4UImanager::GetUIpointer(), G4VBasicShell::ListDirectory(), G4StrUtil::lstrip_copy(), G4VBasicShell::ModifyToFullPathCommand(), G4VBasicShell::ShowCurrent(), and G4VBasicShell::TerminalHelp().

Referenced by G4UIQt::ButtonCallback(), G4UIXm::ButtonCallback(), G4UIQt::CommandEnteredCallback(), G4UIXm::CommandEnteredCallback(), G4UIWin32::DoOpenMacro(), G4UIWin32::DoSaveViewer(), G4UIWin32::ProcessDefaultCommands(), and G4UIWin32::ProcessEnterKey().

◆ ChangeDirectory()

G4bool G4VBasicShell::ChangeDirectory ( const char * newDir )

protectedinherited

Definition at line 74 of file G4VBasicShell.cc.

{
  G4String newPrefix = G4StrUtil::strip_copy(newDir);
 
  G4String newDirectory = ModifyPath( newPrefix );
  if( newDirectory.back() != '/' )
  { newDirectory += "/"; }
  if( FindDirectory( newDirectory.c_str() ) == NULL )
  { return false; }
  currentDirectory = newDirectory;
  return true;
}

References G4VBasicShell::currentDirectory, G4VBasicShell::FindDirectory(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ChangeDirectoryCommand().

◆ ChangeDirectoryCommand()

void G4VBasicShell::ChangeDirectoryCommand ( const G4String & newCommand )

protectedinherited

Definition at line 325 of file G4VBasicShell.cc.

{
  G4String prefix;
  if( newCommand.length() <= 3 ) {
    prefix = "/";
  } else {
    G4String aNewPrefix = newCommand.substr(3, newCommand.length()-3);
    prefix = G4StrUtil::strip_copy(aNewPrefix);
  }
  if(!ChangeDirectory(prefix)) {
    G4cout << "directory <" << prefix << "> not found." << G4endl;
  }
}

References G4VBasicShell::ChangeDirectory(), G4cout, G4endl, and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ApplyShellCommand(), GetCommand(), and G4ZMQServer::GetCommand().

◆ Complete()

G4String G4VBasicShell::Complete ( const G4String & commandName )

protectedinherited

Definition at line 180 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = commandName;
  G4String commandLine = G4StrUtil::strip_copy(rawCommandLine);
  
  size_t i = commandLine.find(" ");
  if( i != std::string::npos ) return rawCommandLine; // Already entering parameters,
                                            // assume command path is correct.
  G4String commandString = commandLine;
  G4String targetCom = ModifyPath(commandString);
  G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
  G4String value = FindMatchingPath(tree,targetCom);
  if(value=="") return rawCommandLine;
  return value;
}

References G4VBasicShell::FindMatchingPath(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4UIQt::eventFilter(), G4UIXm::keyHandler(), and G4UIWin32::ProcessTabKey().

◆ ExecuteCommand()

void G4UIterminal::ExecuteCommand ( const G4String & aCommand )

privatevirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Reimplemented from G4VBasicShell.

Definition at line 160 of file G4UIterminal.cc.

{
  if(aCommand.length()<2) return;
 
  G4int returnVal = UI-> ApplyCommand(aCommand);
 
  G4int paramIndex = returnVal % 100;
  // 0 - 98 : paramIndex-th parameter is invalid
  // 99     : convination of parameters is invalid
  G4int commandStatus = returnVal - paramIndex;
 
  G4UIcommand* cmd = 0;
  if(commandStatus!=fCommandSucceeded)
  { cmd = FindCommand(aCommand); }
 
  switch(commandStatus) {
  case fCommandSucceeded:
    break;
  case fCommandNotFound:
    G4cerr << "command <" << UI->SolveAlias(aCommand) << "> not found" << G4endl;
    if( aCommand.find("@@") != G4String::npos) {
      G4cout << "@@G4UIterminal" << G4endl;
    }
    break;
  case fIllegalApplicationState:
    G4cerr << "illegal application state -- command refused" << G4endl;
    break;
  case fParameterOutOfRange:
    // if(paramIndex<99) {
    //   G4cerr << "Parameter is out of range (index " << paramIndex << ")" << G4endl;
    //   G4cerr << "Allowed range : " << cmd->GetParameter(paramIndex)->GetParameterRange() << G4endl;
    // } else {
    //   G4cerr << "Parameter is out of range" << G4endl;
    //   G4cerr << "Allowed range : " << cmd->GetRange() << G4endl;
    // }
    break;
  case fParameterOutOfCandidates:
    G4cerr << "Parameter is out of candidate list (index " << paramIndex << ")" << G4endl;
    G4cerr << "Candidates : " << cmd->GetParameter(paramIndex)->GetParameterCandidates() << G4endl;
    break;
  case fParameterUnreadable:
    G4cerr << "Parameter is wrong type and/or is not omittable (index " << paramIndex << ")" << G4endl;
    break;
  case fAliasNotFound:
  default:
    G4cerr << "command refused (" << commandStatus << ")" << G4endl;
  }
}

References fAliasNotFound, fCommandNotFound, fCommandSucceeded, fIllegalApplicationState, G4VBasicShell::FindCommand(), fParameterOutOfCandidates, fParameterOutOfRange, fParameterUnreadable, G4cerr, G4cout, G4endl, G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UImanager::SolveAlias(), and UI.

Referenced by PauseSessionStart(), and SessionStart().

◆ ExitHelp()

void G4UIterminal::ExitHelp ( ) const

privatevirtual

Implements G4VBasicShell.

Definition at line 334 of file G4UIterminal.cc.

{
  char temp[100];
  G4cin.getline(temp, 100);
}

References G4cin.

◆ FindCommand()

G4UIcommand * G4VBasicShell::FindCommand ( const char * commandName ) const

protectedinherited

Definition at line 109 of file G4VBasicShell.cc.

{
  G4String commandLine = G4StrUtil::strip_copy(commandName);
 
  G4String commandString;
  size_t i = commandLine.find(" ");
  if( i != std::string::npos )
  { commandString = commandLine.substr(0,i); }
  else
  { commandString = commandLine; }
 
  G4String targetCom = ModifyPath(commandString);
  return G4UImanager::GetUIpointer()->GetTree()->FindPath(targetCom);
}

References G4UIcommandTree::FindPath(), G4UImanager::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by ExecuteCommand(), and G4ZMQServer::ExecuteCommand().

◆ FindDirectory()

G4UIcommandTree * G4VBasicShell::FindDirectory ( const char * dirName ) const

protectedinherited

Definition at line 87 of file G4VBasicShell.cc.

{
  G4String theDir = G4StrUtil::strip_copy(dirName);
 
  G4String targetDir = ModifyPath( theDir );
  if( targetDir.back() != '/' )
  { targetDir += "/"; }
  G4UIcommandTree* comTree = G4UImanager::GetUIpointer()->GetTree();
  if( targetDir == "/" )
  { return comTree; }
  size_t idx = 1;
  while( idx < targetDir.length()-1 )
  {
    size_t i = targetDir.find("/",idx);
    comTree = comTree->GetTree(targetDir.substr(0,i+1).c_str());
    if( comTree == NULL )
    { return NULL; }
    idx = i+1;
  }
  return comTree;
}

References G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UImanager::GetUIpointer(), G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::ListDirectory(), and G4ZMQServer::SessionStart().

◆ FindMatchingPath()

G4String G4VBasicShell::FindMatchingPath	(	G4UIcommandTree *	aTree,
		const G4String &	aCommandPath
	)

protectedinherited

Definition at line 196 of file G4VBasicShell.cc.

{
  return aTree-> CompleteCommandPath(aCommandPath);
}

Referenced by G4VBasicShell::Complete().

◆ GetCommand()

G4String G4UIterminal::GetCommand ( const char * msg = 0 )

private

Definition at line 211 of file G4UIterminal.cc.

{
  G4String newCommand = shell->GetCommandLineString(msg);
  G4String nullString = "";
 
  G4String nC = G4StrUtil::lstrip_copy(newCommand);
  
  if( nC.length() == 0 ) {
    newCommand= nullString;
 
  } else if( nC[0] == '#' ) {  
    G4cout << nC << G4endl;
    newCommand= nullString;
 
  } else if(nC=="ls" || nC.substr(0,3)=="ls " ) {  // list commands
    ListDirectory(nC); 
    newCommand= nullString;
 
  } else if(nC=="lc" || nC.substr(0,3)=="lc " ) {  // ... by shell
    shell-> ListCommand(nC.erase(0,2)); 
    newCommand= nullString;
 
  } else if(nC == "pwd") { // show current directory
    G4cout << "Current Command Directory : " 
       << GetCurrentWorkingDirectory() << G4endl; 
    newCommand= nullString;
 
  } else if(nC == "cwd") { // ... by shell
    shell-> ShowCurrentDirectory();
    newCommand= nullString;
 
  } else if(nC == "cd" || nC.substr(0,3) == "cd ") {  // "cd"
    ChangeDirectoryCommand(nC); 
    shell-> SetCurrentDirectory(GetCurrentWorkingDirectory());
    newCommand= nullString;
 
  } else if(nC == "help" || nC.substr(0,5) == "help ") {  // "help"
    TerminalHelp(nC);
    newCommand= nullString;
 
  } else if(nC[0] == '?') {   // "show current value of a parameter"
    ShowCurrent(nC);
    newCommand= nullString;
 
  } else if(nC == "hist" || nC == "history") {     // "hist/history"
    G4int nh= UI-> GetNumberOfHistory();
    for (G4int i=0; i<nh; i++) { 
      G4cout << i << ": " << UI->GetPreviousCommand(i) << G4endl; 
    }
    newCommand= nullString;
 
  } else if(nC[0] == '!') {   // "!"
    G4String ss= nC.substr(1, nC.length()-1);
    G4int vl;
    const char* tt= ss;
    std::istringstream is(tt);
    is >> vl;
    G4int nh= UI-> GetNumberOfHistory();
    if(vl>=0 && vl<nh) { 
      newCommand= UI-> GetPreviousCommand(vl); 
      G4cout << newCommand << G4endl;
    } else { 
      G4cerr << "history " << vl << " is not found." << G4endl; 
      newCommand= nullString;
    }
 
  } else if(nC == "exit") {   // "exit"
    if(iCont) { 
      G4cout << "You are now processing RUN." << G4endl;
      G4cout << "Please abort it using \"/run/abort\" command first" << G4endl;
      G4cout << " and use \"continue\" command until the application" 
         << G4endl;
      G4cout << " becomes to Idle." << G4endl;
    } else {
      iExit= FALSE;
      newCommand= nullString;
    }
 
  } else if( nC == "cont" || nC == "continue"){     // "cont/continu"
    iCont= FALSE;
    newCommand= nullString;
 
  } else if( nC.empty() ){ // NULL command
    newCommand= nullString;
    
  } else {
  }
 
  return ModifyToFullPathCommand(newCommand);
}

References G4VBasicShell::ChangeDirectoryCommand(), FALSE, G4cerr, G4cout, G4endl, G4VUIshell::GetCommandLineString(), G4VBasicShell::GetCurrentWorkingDirectory(), G4UImanager::GetPreviousCommand(), iCont, iExit, G4VBasicShell::ListDirectory(), G4StrUtil::lstrip_copy(), G4VBasicShell::ModifyToFullPathCommand(), shell, G4VBasicShell::ShowCurrent(), G4VBasicShell::TerminalHelp(), and UI.

Referenced by PauseSessionStart(), and SessionStart().

◆ GetCurrentWorkingDirectory()

G4String G4VBasicShell::GetCurrentWorkingDirectory ( ) const

protectedinherited

Definition at line 69 of file G4VBasicShell.cc.

{
  return currentDirectory;
}

References G4VBasicShell::currentDirectory.

Referenced by G4VBasicShell::ApplyShellCommand(), GetCommand(), G4ZMQServer::GetCommand(), G4VBasicShell::ListDirectory(), G4ZMQServer::SessionStart(), and G4VBasicShell::TerminalHelp().

◆ GetHelpChoice()

G4bool G4UIterminal::GetHelpChoice ( G4int & aInt )

privatevirtual

Implements G4VBasicShell.

Definition at line 321 of file G4UIterminal.cc.

{
  G4cin >> aInt;
  if(!G4cin.good()){
    G4cin.clear();
    G4cin.ignore(30,'\n');
    return FALSE;
  }
  return TRUE;
}

References FALSE, G4cin, and TRUE.

◆ GetLastReturnCode()

G4int G4UIsession::GetLastReturnCode ( ) const

inlineinherited

Definition at line 63 of file G4UIsession.hh.

63{ return lastRC; }

G4UIsession::lastRC

G4int lastRC

Definition: G4UIsession.hh:69

References G4UIsession::lastRC.

◆ InSession()

G4int G4UIsession::InSession ( )

staticinherited

Definition at line 68 of file G4UIsession.cc.

{
  return inSession;
}

References G4UIsession::inSession.

Referenced by G4UIcontrolMessenger::SetNewValue().

◆ ListDirectory()

void G4VBasicShell::ListDirectory ( const G4String & newCommand ) const

protectedinherited

Definition at line 339 of file G4VBasicShell.cc.

{
  G4String targetDir;
  if( newCommand.length() <= 3 ) {
    targetDir = GetCurrentWorkingDirectory();
  } else {
    G4String newPrefix = newCommand.substr(3, newCommand.length()-3);
    targetDir = G4StrUtil::strip_copy(newPrefix);
  }
  G4UIcommandTree* commandTree = FindDirectory( targetDir );
  if( commandTree == NULL ) {
    G4cout << "Directory <" << targetDir << "> is not found." << G4endl;
  } else {
    commandTree->ListCurrent();
  }
}

References G4VBasicShell::FindDirectory(), G4cout, G4endl, G4VBasicShell::GetCurrentWorkingDirectory(), G4UIcommandTree::ListCurrent(), and G4StrUtil::strip_copy().

Referenced by G4VBasicShell::ApplyShellCommand(), GetCommand(), and G4ZMQServer::GetCommand().

◆ ModifyPath()

G4String G4VBasicShell::ModifyPath ( const G4String & tempPath ) const

privateinherited

Definition at line 124 of file G4VBasicShell.cc.

{
  if( tempPath.length() == 0 ) return tempPath;
 
  G4String newPath = "";
 
  // temporal full path
  if( tempPath[0] == '/') newPath = tempPath;
  else newPath = currentDirectory + tempPath;
 
  // body of path...
  while(1){
    size_t idx = newPath.find("/./");
    if( idx == G4String::npos) break;
    newPath.erase(idx,2);
  }
 
  while(1) {
    size_t idx = newPath.find("/../");
    if( idx == G4String::npos) break;
    if( idx == 0) {
      newPath.erase(1,3);
      continue;
    }
    size_t idx2 = newPath.find_last_of('/', idx-1);
    if(idx2 != G4String::npos) newPath.erase(idx2, idx-idx2+3);
  }
 
  // end of path...
  if ( newPath.size() >= 3 ) {
    if(newPath.substr(newPath.size()-3,3) == "/..") {
      if( newPath.size() == 3) {
        newPath = "/";
      } else {
        size_t idx = newPath.find_last_of('/', newPath.size()-4);
        if(idx != G4String::npos) newPath.erase(idx+1);
      }
    }
  }
 
  if ( newPath.size() >= 2 ) {
    if(newPath.substr(newPath.size()-2,2) == "/.") newPath.erase(newPath.size()-1,1);
  }
 
  // truncate "/////" to "/"
  while(1) {
    size_t idx = newPath.find("//");
    if( idx == G4String::npos) break;
    newPath.erase(idx,1);
  }
 
  return newPath;
}

References G4VBasicShell::currentDirectory.

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::Complete(), G4VBasicShell::FindCommand(), G4VBasicShell::FindDirectory(), and G4VBasicShell::ModifyToFullPathCommand().

◆ ModifyToFullPathCommand()

G4String G4VBasicShell::ModifyToFullPathCommand ( const char * aCommandLine ) const

protectedinherited

Definition at line 47 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = aCommandLine;
  if(rawCommandLine.empty()||rawCommandLine[0]=='\0') return rawCommandLine;
  G4String commandLine = G4StrUtil::strip_copy(rawCommandLine);
  G4String commandString;
  G4String parameterString;
  size_t i = commandLine.find(" ");
  if( i != std::string::npos )
  {
    commandString = commandLine.substr(0,i);
    parameterString = " ";
    parameterString += commandLine.substr(i+1,commandLine.length()-(i+1));
  }
  else
  { commandString = commandLine; }
 
  G4String fullPathCommandLine
    = ModifyPath( commandString )+parameterString;
  return fullPathCommandLine;
}

References G4VBasicShell::ModifyPath(), and G4StrUtil::strip_copy().

Referenced by G4UIQt::ActivateCommand(), G4VBasicShell::ApplyShellCommand(), GetCommand(), G4ZMQServer::GetCommand(), G4VBasicShell::ShowCurrent(), and G4VBasicShell::TerminalHelp().

◆ PauseSessionStart()

void G4UIterminal::PauseSessionStart ( const G4String & msg )

virtual

Implements G4VBasicShell.

Definition at line 147 of file G4UIterminal.cc.

{
  iCont= TRUE;
 
  G4String newCommand= GetCommand(msg);
  while(iCont){
    ExecuteCommand(newCommand);
    newCommand= GetCommand(msg);
  }
}

References ExecuteCommand(), GetCommand(), iCont, and TRUE.

◆ ReceiveG4cerr()

G4int G4UIterminal::ReceiveG4cerr ( const G4String & cerrString )

virtual

Reimplemented from G4UIsession.

Definition at line 313 of file G4UIterminal.cc.

{
  std::cerr << cerrString << std::flush;
  return 0;
}

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

G4int G4UIterminal::ReceiveG4cout ( const G4String & coutString )

virtual

Reimplemented from G4UIsession.

Definition at line 305 of file G4UIterminal.cc.

{
  std::cout << coutString << std::flush;
  return 0;
}

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

◆ ResetTransformers()

void G4coutDestination::ResetTransformers ( )

virtualinherited

Definition at line 41 of file G4coutDestination.cc.

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

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

◆ SessionStart()

G4UIsession * G4UIterminal::SessionStart ( )

virtual

Implements G4VBasicShell.

Definition at line 133 of file G4UIterminal.cc.

{
  iExit= TRUE;
 
  G4String newCommand= GetCommand();
  while(iExit){
    ExecuteCommand(newCommand);
    newCommand= GetCommand();
  }
  return NULL;
}

References ExecuteCommand(), GetCommand(), iExit, and TRUE.

◆ SetPrompt()

void G4UIterminal::SetPrompt ( const G4String & prompt )

Definition at line 126 of file G4UIterminal.cc.

{
  shell-> SetPrompt(prompt);
}

References SetPrompt(), and shell.

Referenced by SetPrompt().

◆ ShowCurrent()

void G4VBasicShell::ShowCurrent ( const G4String & newCommand ) const

protectedinherited

Definition at line 313 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4String comString = newCommand.substr(1,newCommand.length()-1);
  G4String theCommand = ModifyToFullPathCommand(comString);
  G4String curV = UI->GetCurrentValues(theCommand);
  if( ! curV.empty() ) {
    G4cout << "Current value(s) of the parameter(s) : " << curV << G4endl;
  }
}

References G4cout, G4endl, G4UImanager::GetCurrentValues(), G4UImanager::GetUIpointer(), and G4VBasicShell::ModifyToFullPathCommand().

Referenced by G4VBasicShell::ApplyShellCommand(), GetCommand(), and G4ZMQServer::GetCommand().

◆ TerminalHelp()

void G4VBasicShell::TerminalHelp ( const G4String & newCommand )

protectedinherited

Definition at line 355 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
  size_t i = newCommand.find(" ");
  if( i != std::string::npos )
  {
    G4String newValue = newCommand.substr(i+1, newCommand.length()-(i+1));
    G4StrUtil::strip(newValue);
    G4String targetCom = ModifyToFullPathCommand(newValue);
    G4UIcommand* theCommand = treeTop->FindPath(targetCom);
    if( theCommand != NULL )
    {
      theCommand->List();
      return;
    }
    else
    {
      G4cout << "Command <" << newValue << " is not found." << G4endl;
      return;
    }
  }
 
  G4UIcommandTree * floor[10];
  floor[0] = treeTop;
  size_t iFloor = 0;
  size_t prefixIndex = 1;
  G4String prefix = GetCurrentWorkingDirectory();
  while( prefixIndex < prefix.length()-1 )
  {
    size_t ii = prefix.find("/",prefixIndex);
    floor[iFloor+1] =
      floor[iFloor]->GetTree(G4String(prefix.substr(0,ii+1)));
    prefixIndex = ii+1;
    iFloor++;
  }
  floor[iFloor]->ListCurrentWithNum();
  // 1998 Oct 2 non-number input
  while(1){
   //G4cout << G4endl << "Type the number ( 0:end, -n:n level back ) : "<<std::flush;
    G4cout << G4endl << "Type the number ( 0:end, -n:n level back ) : "<<G4endl;
    G4int j;
    if(!GetHelpChoice(j)){
      G4cout << G4endl << "Not a number, once more" << G4endl;
      continue;
    } else if( j < 0 ){
      if( iFloor < (size_t)-j ) iFloor = 0;
      else iFloor += j;
      //iFloor += j;
      //if( iFloor < 0 ) iFloor = 0;
      floor[iFloor]->ListCurrentWithNum();
      continue;
    } else if(j == 0) {
      break;
    } else if( j > 0 ) {
      G4int n_tree = floor[iFloor]->GetTreeEntry();
      if( j > n_tree )
      {
        if( j <= n_tree + floor[iFloor]->GetCommandEntry() )
        {
          floor[iFloor]->GetCommand(j-n_tree)->List();
        }
      }
      else
      {
        floor[iFloor+1] = floor[iFloor]->GetTree(j);
        iFloor++;
        floor[iFloor]->ListCurrentWithNum();
      }
    }
  }
  G4cout << "Exit from HELP." << G4endl << G4endl;
  //G4cout << G4endl;
  ExitHelp();
}

References G4VBasicShell::ExitHelp(), G4UIcommandTree::FindPath(), G4cout, G4endl, G4UIcommandTree::GetCommand(), G4VBasicShell::GetCurrentWorkingDirectory(), G4VBasicShell::GetHelpChoice(), G4UImanager::GetTree(), G4UIcommandTree::GetTree(), G4UIcommandTree::GetTreeEntry(), G4UImanager::GetUIpointer(), G4UIcommand::List(), G4UIcommandTree::ListCurrentWithNum(), G4VBasicShell::ModifyToFullPathCommand(), and G4StrUtil::strip().

Referenced by G4VBasicShell::ApplyShellCommand(), GetCommand(), G4ZMQServer::GetCommand(), and G4UIQt::ShowHelpCallback().

Field Documentation

◆ currentDirectory

G4String G4VBasicShell::currentDirectory

privateinherited

Definition at line 101 of file G4VBasicShell.hh.

Referenced by G4VBasicShell::ChangeDirectory(), G4VBasicShell::GetCurrentWorkingDirectory(), and G4VBasicShell::ModifyPath().

◆ iCont

G4bool G4UIterminal::iCont

private

Definition at line 78 of file G4UIterminal.hh.

Referenced by G4UIterminal(), GetCommand(), and PauseSessionStart().

◆ iExit

G4bool G4UIterminal::iExit

private

Definition at line 77 of file G4UIterminal.hh.

Referenced by G4UIterminal(), GetCommand(), and SessionStart().

◆ ifBatch

G4int G4UIsession::ifBatch = 0

protectedinherited

Definition at line 68 of file G4UIsession.hh.

Referenced by G4UIsession::~G4UIsession().

◆ inSession

G4int G4UIsession::inSession = 0

staticprotectedinherited

Definition at line 67 of file G4UIsession.hh.

Referenced by G4UIsession::G4UIsession(), G4UIsession::InSession(), and G4UIsession::~G4UIsession().

◆ lastRC

G4int G4UIsession::lastRC = 0

protectedinherited

Definition at line 69 of file G4UIsession.hh.

Referenced by G4UIbatch::G4UIbatch(), G4UIsession::GetLastReturnCode(), and G4UIbatch::SessionStart().

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

◆ shell

G4VUIshell* G4UIterminal::shell

private

Definition at line 74 of file G4UIterminal.hh.

Referenced by G4UIterminal(), GetCommand(), SetPrompt(), and ~G4UIterminal().

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

◆ UI

G4UImanager* G4UIterminal::UI

private

Definition at line 72 of file G4UIterminal.hh.

Referenced by ExecuteCommand(), G4UIterminal(), GetCommand(), and ~G4UIterminal().

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

source/interfaces/basic/include/G4UIterminal.hh
source/interfaces/basic/src/G4UIterminal.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Transformer

Constructor & Destructor Documentation

◆ G4UIterminal()

◆ ~G4UIterminal()

Member Function Documentation

◆ AddCerrTransformer() [1/2]

◆ AddCerrTransformer() [2/2]

◆ AddCoutTransformer() [1/2]

◆ AddCoutTransformer() [2/2]

◆ ApplyShellCommand()

◆ ChangeDirectory()

◆ ChangeDirectoryCommand()

◆ Complete()

◆ ExecuteCommand()

◆ ExitHelp()

◆ FindCommand()

◆ FindDirectory()

◆ FindMatchingPath()

◆ GetCommand()

◆ GetCurrentWorkingDirectory()

◆ GetHelpChoice()

◆ GetLastReturnCode()

◆ InSession()

◆ ListDirectory()

◆ ModifyPath()

◆ ModifyToFullPathCommand()

◆ PauseSessionStart()

◆ ReceiveG4cerr()

◆ ReceiveG4cerr_()

◆ ReceiveG4cout()

◆ ReceiveG4cout_()

◆ ResetTransformers()

◆ SessionStart()

◆ SetPrompt()

◆ ShowCurrent()

◆ TerminalHelp()

Field Documentation

◆ currentDirectory

◆ iCont

◆ iExit

◆ ifBatch

◆ inSession

◆ lastRC

◆ masterG4coutDestination

◆ shell

◆ transformersCerr

◆ transformersCout

◆ UI