G4VBasicShell Class Reference

#include <G4VBasicShell.hh>

Inheritance diagram for G4VBasicShell:

Public Member Functions
	G4VBasicShell ()
virtual	~G4VBasicShell ()
virtual G4UIsession *	SessionStart ()=0
virtual void	PauseSessionStart (const G4String &Prompt)=0
Public Member Functions inherited from G4UIsession
	G4UIsession ()
virtual	~G4UIsession ()
virtual G4UIsession *	SessionStart ()
virtual void	PauseSessionStart (const G4String &Prompt)
virtual G4int	ReceiveG4cout (const G4String &coutString)
virtual G4int	ReceiveG4cerr (const G4String &cerrString)
Public Member Functions inherited from G4coutDestination
	G4coutDestination ()
virtual	~G4coutDestination ()
virtual G4int	ReceiveG4cout (const G4String &)
virtual G4int	ReceiveG4cerr (const G4String &)

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 &)

Detailed Description

Definition at line 52 of file G4VBasicShell.hh.

Constructor & Destructor Documentation

G4VBasicShell()

G4VBasicShell::G4VBasicShell

(

)

Definition at line 39 of file G4VBasicShell.cc.

:currentDirectory("/")
{
}

~G4VBasicShell()

G4VBasicShell::~G4VBasicShell ( )

virtual

Definition at line 44 of file G4VBasicShell.cc.

{
}

Member Function Documentation

ApplyShellCommand()

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

protected

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

Definition at line 227 of file G4VBasicShell.cc.

{
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
 
  G4String command = a_string;
  command.strip(G4String::leading);
 
  if( command(0) == '#' ) {
 
    G4cout << command << G4endl;
 
  } else if( command == "ls" || command(0,3) == "ls " ) {
 
    ListDirectory( command );
 
  } else if( command == "pwd" ) {
 
    G4cout << "Current Working Directory : "
       << GetCurrentWorkingDirectory() << G4endl;
 
  } else if( command == "cd" || command(0,3) == "cd ") {
 
    ChangeDirectoryCommand ( command );
 
  } else if( command == "help" || command(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(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));
 
  }
}

ChangeDirectory()

G4bool G4VBasicShell::ChangeDirectory ( const char *  newDir )

protected

Definition at line 75 of file G4VBasicShell.cc.

{
  G4String aNewPrefix = newDir;
  G4String newPrefix = aNewPrefix.strip(G4String::both);
  G4String newDirectory = ModifyPath( newPrefix );
  if( newDirectory( newDirectory.length() - 1 ) != '/' )
  { newDirectory += "/"; }
  if( FindDirectory( newDirectory.c_str() ) == NULL )
  { return false; }
  currentDirectory = newDirectory;
  return true;
}

Referenced by ChangeDirectoryCommand().

ChangeDirectoryCommand()

void G4VBasicShell::ChangeDirectoryCommand ( const G4String &  newCommand )

protected

Definition at line 321 of file G4VBasicShell.cc.

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

Referenced by ApplyShellCommand().

Complete()

G4String G4VBasicShell::Complete ( const G4String &  commandName )

protected

Definition at line 176 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = commandName;
  G4String commandLine = rawCommandLine.strip(G4String::both);
  size_t i = commandLine.index(" ");
  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;
}

ExecuteCommand()

void G4VBasicShell::ExecuteCommand ( const G4String &  aCommand )

protectedvirtual

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

Definition at line 201 of file G4VBasicShell.cc.

{
  if(aCommand.length()<2) return;
  G4UImanager* UI = G4UImanager::GetUIpointer();
  if(UI==NULL) return;
  G4int commandStatus = UI->ApplyCommand(aCommand);
  switch(commandStatus) {
  case fCommandSucceeded:
    break;
  case fCommandNotFound:
    G4cerr << "command not found" << G4endl;
    break;
  case fIllegalApplicationState:
    G4cerr << "illegal application state -- command refused" << G4endl;
    break;
  case fParameterOutOfRange:
  case fParameterUnreadable:
  case fParameterOutOfCandidates:
  default:
    G4cerr << "command refused (" << commandStatus << ")" << 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 110 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = commandName;
  G4String commandLine = rawCommandLine.strip(G4String::both);
  G4String commandString;
  size_t i = commandLine.index(" ");
  if( i != std::string::npos )
  { commandString = commandLine(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 88 of file G4VBasicShell.cc.

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

Referenced by ChangeDirectory(), and ListDirectory().

FindMatchingPath()

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

protected

Definition at line 191 of file G4VBasicShell.cc.

{
  return aTree-> CompleteCommandPath(aCommandPath);
}

Referenced by Complete().

GetCurrentWorkingDirectory()

G4String G4VBasicShell::GetCurrentWorkingDirectory ( ) const

protected

Definition at line 70 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 335 of file G4VBasicShell.cc.

{
  G4String targetDir;
  if( newCommand.length() <= 3 ) {
    targetDir = GetCurrentWorkingDirectory();
  } else {
    G4String newPrefix = newCommand.substr(3, newCommand.length()-3);
    targetDir = newPrefix.strip(G4String::both);
  }
  G4UIcommandTree* commandTree = FindDirectory( targetDir );
  if( commandTree == NULL ) {
    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 48 of file G4VBasicShell.cc.

{
  G4String rawCommandLine = aCommandLine;
  if(rawCommandLine.isNull()||rawCommandLine(0)=='\0') return rawCommandLine;
  G4String commandLine = rawCommandLine.strip(G4String::both);
  G4String commandString;
  G4String parameterString;
  size_t i = commandLine.index(" ");
  if( i != std::string::npos )
  {
    commandString = commandLine(0,i);
    parameterString = " ";
    parameterString += commandLine(i+1,commandLine.length()-(i+1));
  }
  else
  { commandString = commandLine; }
 
  G4String fullPathCommandLine
    = ModifyPath( commandString )+parameterString;
  return fullPathCommandLine;
}

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

PauseSessionStart()

virtual void G4VBasicShell::PauseSessionStart ( const G4String &  Prompt )

pure virtual

Reimplemented from G4UIsession.

Implemented in G4UIterminal, and G4UIGainServer.

SessionStart()

virtual G4UIsession * G4VBasicShell::SessionStart ( )

pure virtual

Reimplemented from G4UIsession.

Implemented in G4UIterminal, and G4UIGainServer.

ShowCurrent()

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

protected

Definition at line 309 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.isNull() ) {
    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==NULL) return;
  G4UIcommandTree * treeTop = UI->GetTree();
  size_t i = newCommand.index(" ");
  if( i != std::string::npos )
  {
    G4String newValue = newCommand.substr(i+1, newCommand.length()-(i+1));
    newValue.strip(G4String::both);
    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.index("/",prefixIndex);
    floor[iFloor+1] =
      floor[iFloor]->GetTree(G4String(prefix(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();
}

Referenced by ApplyShellCommand().

---

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

• G4VBasicShell.hh
• G4VBasicShell.cc