G4VBasicShell Class Reference

#include <G4VBasicShell.hh>

Inheritance diagram for G4VBasicShell:

Public Member Functions
	G4VBasicShell ()
	~G4VBasicShell () override
G4UIsession *	SessionStart () override=0
void	PauseSessionStart (const G4String &Prompt) override=0
Public Member Functions inherited from G4UIsession
	G4UIsession ()
	G4UIsession (G4int iBatch)
	~G4UIsession () override
G4int	ReceiveG4debug (const G4String &debugString) override
G4int	ReceiveG4cout (const G4String &coutString) override
G4int	ReceiveG4cerr (const G4String &cerrString) override
G4int	GetLastReturnCode () const
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
G4String	ModifyToFullPathCommand (const char *aCommandLine) const
G4String	GetCurrentWorkingDirectory () const
G4bool	ChangeDirectory (const char *newDir)
G4UIcommandTree *	FindDirectory (const char *dirName) const
G4UIcommand *	FindCommand (const char *commandName) const
G4String	Complete (const G4String &)
G4String	FindMatchingPath (G4UIcommandTree *, const G4String &)
virtual void	ExecuteCommand (const G4String &)
virtual G4bool	GetHelpChoice (G4int &)=0
virtual void	ExitHelp () const =0
void	ApplyShellCommand (const G4String &, G4bool &, G4bool &)
void	ShowCurrent (const G4String &) const
void	ChangeDirectoryCommand (const G4String &)
void	ListDirectory (const G4String &) const
void	TerminalHelp (const G4String &)

Additional Inherited Members
Public Types inherited from G4coutDestination
using	Transformer = std::function<G4bool(G4String&)>
Static Public Member Functions inherited from G4UIsession
static G4int	InSession ()
Protected Attributes inherited from G4UIsession
G4int	ifBatch = 0
G4int	lastRC = 0
Protected Attributes inherited from G4coutDestination
std::vector< Transformer >	transformersDebug
std::vector< Transformer >	transformersCout
std::vector< Transformer >	transformersCerr
Static Protected Attributes inherited from G4UIsession
static G4ICOMS_DLL G4int	inSession = 0
Static Protected Attributes inherited from G4coutDestination
static G4MTGLOB_DLL G4coutDestination *	masterG4coutDestination = nullptr

Detailed Description

Definition at line 51 of file G4VBasicShell.hh.

Constructor & Destructor Documentation

G4VBasicShell()

G4VBasicShell::G4VBasicShell

(

)

Definition at line 40 of file G4VBasicShell.cc.

: currentDirectory("/") {}

~G4VBasicShell()

G4VBasicShell::~G4VBasicShell ( )

overridedefault

Member Function Documentation

ApplyShellCommand()

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

protected

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

Definition at line 237 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) 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) {  // 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));
  }
}

ChangeDirectory()

G4bool G4VBasicShell::ChangeDirectory ( const char * newDir )

protected

Definition at line 67 of file G4VBasicShell.cc.

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

Referenced by ChangeDirectoryCommand().

ChangeDirectoryCommand()

void G4VBasicShell::ChangeDirectoryCommand ( const G4String & newCommand )

protected

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

Referenced by ApplyShellCommand().

Complete()

G4String G4VBasicShell::Complete ( const G4String & commandName )

protected

Definition at line 182 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.empty()) return rawCommandLine;
  return value;
}

ExecuteCommand()

void G4VBasicShell::ExecuteCommand ( const G4String & aCommand )

protectedvirtual

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

Definition at line 208 of file G4VBasicShell.cc.

{
  if (aCommand.length() < 2) return;
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) return;
  G4int commandStatus = UI->ApplyCommand(aCommand);
  switch (commandStatus) {
    case fCommandSucceeded:
      break;
    case fCommandNotFound:
      G4cerr << "command not found: "
             << "\"" << aCommand << "\"" << G4endl;
      break;
    case fIllegalApplicationState:
      G4cerr << "illegal application state -- command refused:"
             << "\"" << aCommand << "\"" << G4endl;
      break;
    case fParameterOutOfRange:
    case fParameterUnreadable:
    case fParameterOutOfCandidates:
    default:
      G4cerr << "command refused (" << commandStatus << "):"
             << "\"" << aCommand << "\"" << G4endl;
  }
}

Referenced by ApplyShellCommand().

ExitHelp()

virtual void G4VBasicShell::ExitHelp ( ) const

protectedpure virtual

Referenced by TerminalHelp().

FindCommand()

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

protected

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

FindDirectory()

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

protected

Definition at line 82 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 == nullptr) {
      return nullptr;
    }
    idx = i + 1;
  }
  return comTree;
}

Referenced by ChangeDirectory(), and ListDirectory().

FindMatchingPath()

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

protected

Definition at line 199 of file G4VBasicShell.cc.

{
  return aTree->CompleteCommandPath(aCommandPath);
}

Referenced by Complete().

GetCurrentWorkingDirectory()

G4String G4VBasicShell::GetCurrentWorkingDirectory ( ) const

protected

Definition at line 65 of file G4VBasicShell.cc.

{ return currentDirectory; }

Referenced by ApplyShellCommand(), ListDirectory(), and TerminalHelp().

GetHelpChoice()

virtual G4bool G4VBasicShell::GetHelpChoice ( G4int & )

protectedpure virtual

Referenced by TerminalHelp().

ListDirectory()

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

protected

Definition at line 333 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 == nullptr) {
    G4cout << "Directory <" << targetDir << "> is not found." << G4endl;
  }
  else {
    commandTree->ListCurrent();
  }
}

Referenced by ApplyShellCommand().

ModifyToFullPathCommand()

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

protected

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

Referenced by ApplyShellCommand(), ShowCurrent(), and TerminalHelp().

PauseSessionStart()

void G4VBasicShell::PauseSessionStart ( const G4String & Prompt )

overridepure virtual

Reimplemented from G4UIsession.

Implemented in G4UIQt, G4UIterminal, G4UIWin32, and G4UIXm.

SessionStart()

G4UIsession * G4VBasicShell::SessionStart ( )

overridepure virtual

Reimplemented from G4UIsession.

Implemented in G4UIQt, G4UIterminal, G4UIWin32, and G4UIXm.

ShowCurrent()

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

protected

Definition at line 306 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) 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;
  }
}

Referenced by ApplyShellCommand().

TerminalHelp()

void G4VBasicShell::TerminalHelp ( const G4String & newCommand )

protected

Definition at line 351 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if (UI == nullptr) 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 != nullptr) {
      theCommand->List();
      return;
    }
 
    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 (true) {
    // 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;
    }
    if (j < 0) {
      if (iFloor < (size_t)-j)
        iFloor = 0;
      else
        iFloor += j;
      // iFloor += j;
      // if( iFloor < 0 ) iFloor = 0;
      floor[iFloor]->ListCurrentWithNum();
      continue;
    }
    if (j == 0) {
      break;
    }
    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();
}

Referenced by ApplyShellCommand().

---

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

• G4VBasicShell.hh
• G4VBasicShell.cc