G4UIcommandTree Class Reference

#include <G4UIcommandTree.hh>

Public Member Functions
	G4UIcommandTree ()
	G4UIcommandTree (const char *thePathName)
	~G4UIcommandTree ()
G4int	operator== (const G4UIcommandTree &right) const
G4int	operator!= (const G4UIcommandTree &right) const
void	AddNewCommand (G4UIcommand *newCommand, G4bool workerThreadOnly=false)
void	RemoveCommand (G4UIcommand *aCommand, G4bool workerThreadOnly=false)
G4UIcommand *	FindPath (const char *commandPath) const
G4UIcommandTree *	FindCommandTree (const char *commandPath)
G4String	CompleteCommandPath (const G4String &commandPath)
void	List () const
void	ListCurrent () const
void	ListCurrentWithNum () const
void	CreateHTML ()
const G4UIcommand *	GetGuidance () const
const G4String	GetPathName () const
G4int	GetTreeEntry () const
G4int	GetCommandEntry () const
G4UIcommandTree *	GetTree (G4int i)
G4UIcommandTree *	GetTree (const char *comNameC)
G4UIcommand *	GetCommand (G4int i)
const G4String	GetTitle () const

Detailed Description

Definition at line 44 of file G4UIcommandTree.hh.

Constructor & Destructor Documentation

G4UIcommandTree::G4UIcommandTree

(

)

Definition at line 35 of file G4UIcommandTree.cc.

Referenced by AddNewCommand().

:guidance(NULL),broadcastCommands(true)
{ }

G4UIcommandTree::G4UIcommandTree

(

const char *

thePathName

)

Definition at line 39 of file G4UIcommandTree.cc.

:guidance(NULL),broadcastCommands(true)
{
  pathName = thePathName;
}

G4UIcommandTree::~G4UIcommandTree

(

)

Definition at line 45 of file G4UIcommandTree.cc.

{
  G4int i;
  G4int n_treeEntry = tree.size();
  for( i=0; i < n_treeEntry; i++ )
  { delete tree[i]; }
}

Member Function Documentation

void G4UIcommandTree::AddNewCommand	(	G4UIcommand *	newCommand,
		G4bool	workerThreadOnly = false
	)

Definition at line 63 of file G4UIcommandTree.cc.

References AddNewCommand(), G4String::append(), G4String::first(), G4UIcommandTree(), G4UIcommand::GetCommandPath(), GetPathName(), G4String::isNull(), G4String::remove(), G4UIcommand::SetToBeBroadcasted(), G4UIcommand::SetWorkerThreadOnly(), and G4UIcommand::ToBeBroadcasted().

Referenced by AddNewCommand(), and G4UImanager::AddNewCommand().

{
  G4String commandPath = newCommand->GetCommandPath();
  G4String remainingPath = commandPath;
  remainingPath.remove(0,pathName.length());
  if( remainingPath.isNull() )
  {
    if(!guidance)
    {
      guidance = newCommand;
      if(!(newCommand->ToBeBroadcasted())) broadcastCommands = false;
      if(workerThreadOnly) newCommand->SetWorkerThreadOnly();
    }
    return;
  }
  G4int i = remainingPath.first('/');
  if( i == G4int(std::string::npos) )
  {
    // Find command
    G4int n_commandEntry = command.size();
    for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
    {
      if( remainingPath == command[i_thCommand]->GetCommandName() )
      { return; }
    }
    if(!broadcastCommands) newCommand->SetToBeBroadcasted(false);
    if(workerThreadOnly) newCommand->SetWorkerThreadOnly();
    command.push_back( newCommand );
    return;
  }
  else
  {
    // Find path
    G4String nextPath = pathName;
    nextPath.append(remainingPath(0,i+1));
    G4int n_treeEntry = tree.size();
    for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
    {
      if( nextPath == tree[i_thTree]->GetPathName() )
      { 
        if(!broadcastCommands) newCommand->SetToBeBroadcasted(false);
    tree[i_thTree]->AddNewCommand( newCommand, workerThreadOnly );
    return; 
      }
    }
    G4UIcommandTree * newTree = new G4UIcommandTree( nextPath );
    tree.push_back( newTree );
    if(!broadcastCommands) newCommand->SetToBeBroadcasted(false);
    newTree->AddNewCommand( newCommand, workerThreadOnly );
    return;
  }
}

G4String G4UIcommandTree::CompleteCommandPath

(

const G4String &

commandPath

)

Definition at line 237 of file G4UIcommandTree.cc.

References FindCommandTree(), G4cout, G4endl, GetCommand(), GetCommandEntry(), GetPathName(), GetTree(), GetTreeEntry(), G4String::index(), G4String::last(), and G4String::remove().

{
  G4String pName = aCommandPath;
  G4String remainingPath = aCommandPath;
  G4String empty = "";
  G4String matchingPath = empty;

  // find the tree
  G4int jpre= pName.last('/');
  if(jpre != G4int(G4String::npos)) pName.remove(jpre+1);
  G4UIcommandTree* aTree = FindCommandTree(pName);

  if (!aTree) {
    return empty;
  }
  
  if( pName.index( pName ) == std::string::npos ) return empty;

  std::vector<G4String> paths;

  // list matched directories/commands
  G4String strtmp;
  G4int nMatch= 0;

  int Ndir= aTree-> GetTreeEntry();
  int Ncmd= aTree-> GetCommandEntry();
  
  // directory ...
  for(G4int idir=1; idir<=Ndir; idir++) {
    G4String fpdir= aTree-> GetTree(idir)-> GetPathName();
    // matching test
    if( fpdir.index(remainingPath, 0) == 0) {
      if(nMatch==0) {
        matchingPath = fpdir;
      } else {
        matchingPath = GetFirstMatchedString(fpdir,matchingPath);
      }
      nMatch++;
      paths.push_back(fpdir);
    }
  }
  
  if (paths.size()>=2) {
    G4cout << "Matching directories :" << G4endl; 
    for( unsigned int i_thCommand = 0; i_thCommand < paths.size(); i_thCommand++ ) {
      G4cout << paths[i_thCommand] << G4endl; 
    }
  }
  
  // command ...
  std::vector<G4String> commands;

  for(G4int icmd=1; icmd<=Ncmd; icmd++){
    G4String fpcmd= aTree-> GetPathName() +
                    aTree-> GetCommand(icmd) -> GetCommandName();
    // matching test
    if( fpcmd.index(remainingPath, 0) ==0) {
      if(nMatch==0) {
        matchingPath= fpcmd + " ";
      } else {
        strtmp= fpcmd + " ";
        matchingPath= GetFirstMatchedString(matchingPath, strtmp);
      }
      nMatch++;
      commands.push_back(fpcmd+" ");
    }
  }

  if (commands.size()>=2) {
    G4cout << "Matching commands :" << G4endl; 
    for( unsigned int i_thCommand = 0; i_thCommand < commands.size(); i_thCommand++ ) {
      G4cout << commands[i_thCommand] << G4endl; 
    }
  }

  return matchingPath;
}

void G4UIcommandTree::CreateHTML

(

)

Definition at line 437 of file G4UIcommandTree.cc.

References cmd, G4endl, G4UIcommand::GetCommandName(), G4UIparameter::GetCurrentAsDefault(), G4UIparameter::GetDefaultValue(), G4UIcommand::GetGuidanceEntries(), G4UIcommand::GetGuidanceLine(), G4UIcommand::GetParameter(), G4UIparameter::GetParameterCandidates(), G4UIcommand::GetParameterEntries(), G4UIparameter::GetParameterName(), G4UIparameter::GetParameterRange(), G4UIparameter::GetParameterType(), GetPathName(), G4UIcommand::GetRange(), G4UIcommand::GetStateList(), G4StateManager::GetStateManager(), G4StateManager::GetStateString(), GetTitle(), and G4UIparameter::IsOmittable().

Referenced by G4UImanager::CreateHTML(), and export_G4UIcommandTree().

{
  G4String ofileName = CreateFileName(pathName);
  std::ofstream oF(ofileName, std::ios::out);

  oF << "<html><head><title>Commands in " << ModStr(pathName) << "</title></head>" << G4endl;
  oF << "<body bgcolor=\"#ffffff\"><h2>" << ModStr(pathName) << "</h2><p>" << G4endl;

  if( guidance != NULL ) 
  {
    for(G4int i=0;i<guidance->GetGuidanceEntries();i++)
    { oF << ModStr(guidance->GetGuidanceLine(i)) << "<br>" << G4endl; }
  }

  oF << "<p><hr><p>" << G4endl;
  
  oF << "<h2>Sub-directories : </h2><dl>" << G4endl;
  for( G4int i_thTree = 0; i_thTree < G4int(tree.size()); i_thTree++ )
  {
    oF << "<p><br><p><dt><a href=\"" << CreateFileName(tree[i_thTree]->GetPathName())
       << "\">" << ModStr(tree[i_thTree]->GetPathName()) << "</a>" << G4endl;
    oF << "<p><dd>" << ModStr(tree[i_thTree]->GetTitle()) << G4endl;
    tree[i_thTree]->CreateHTML();
  }

  oF << "</dl><p><hr><p>" << G4endl;
  
  oF << "<h2>Commands : </h2><dl>" << G4endl;
  for( G4int i_thCommand = 0; i_thCommand < G4int(command.size()); i_thCommand++ )
  {
    G4UIcommand* cmd = command[i_thCommand];
    oF << "<p><br><p><dt><b>" << ModStr(cmd->GetCommandName());
    if(cmd->GetParameterEntries()>0)
    {
      for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++)
      { oF << " [<i>" << ModStr(cmd->GetParameter(i_thParam)->GetParameterName()) << "</i>]"; }
    }
    oF << "</b>" << G4endl;
    oF << "<p><dd>" << G4endl;
    for(G4int i=0;i<cmd->GetGuidanceEntries();i++)
    { oF << ModStr(cmd->GetGuidanceLine(i)) << "<br>" << G4endl; }
    if(!(cmd->GetRange()).isNull())
    { oF << "<p><dd>Range : " << ModStr(cmd->GetRange()) << G4endl; }
    std::vector<G4ApplicationState>* availabelStateList = cmd->GetStateList();
    if(availabelStateList->size()==6)
    { oF << "<p><dd>Available at all Geant4 states." << G4endl; }
    else
    {
      oF << "<p><dd>Available Geant4 state(s) : ";
      for(G4int ias=0;ias<G4int(availabelStateList->size());ias++)
      { oF << G4StateManager::GetStateManager()->GetStateString((*availabelStateList)[ias]) << " " << G4endl; }
    }
    if(cmd->GetParameterEntries()>0)
    {
      oF << "<p><dd>Parameters<table border=1>" << G4endl;
      for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++)
      {
        G4UIparameter* prm = cmd->GetParameter(i_thParam);
        oF << "<tr><td>" << ModStr(prm->GetParameterName()) << G4endl;
        oF << "<td>type " << prm->GetParameterType() << G4endl;
        oF << "<td>";
        if(prm->IsOmittable())
        { 
          oF << "Omittable : ";
          if(prm->GetCurrentAsDefault())
          { oF << "current value is used as the default value." << G4endl; }
          else
          { oF << "default value = " << prm->GetDefaultValue() << G4endl; }
        }
        oF << "<td>";
        if(!(prm->GetParameterRange()).isNull())
        { oF << "Parameter range : " << ModStr(prm->GetParameterRange()) << G4endl; }
        else if(!(prm->GetParameterCandidates()).isNull())
        { oF << "Parameter candidates : " << ModStr(prm->GetParameterCandidates()) << G4endl; }
      }
      oF << "</table>" << G4endl;
    }

  }
  
  oF << "</dl></body></html>" << G4endl;
  oF.close();
}

G4UIcommandTree * G4UIcommandTree::FindCommandTree

(

const char *

commandPath

)

Try to match a command or a path with the one given. : command or path to match

Returns

the commandTree found or NULL if not

Definition at line 209 of file G4UIcommandTree.cc.

References G4String::append(), G4String::first(), GetPathName(), G4String::index(), and G4String::remove().

Referenced by CompleteCommandPath().

{
  G4String remainingPath = commandPath;
  if( remainingPath.index( pathName ) == std::string::npos )
  { return NULL; }
  remainingPath.remove(0,pathName.length());
  G4int i = remainingPath.first('/');
  if( i != G4int(std::string::npos) )
  {
    // Find path
    G4String nextPath = pathName;
    nextPath.append(remainingPath(0,i+1));
    G4int n_treeEntry = tree.size();
    for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
    {
      if (tree[i_thTree]->GetPathName() == commandPath) {
        return tree[i_thTree];
      }
      else if( nextPath == tree[i_thTree]->GetPathName() ) {
        return tree[i_thTree]->FindCommandTree( commandPath );
      }
    }
  } else {
    return this;
  }
  return NULL;
}

G4UIcommand * G4UIcommandTree::FindPath

(

const char *

commandPath

)

const

Definition at line 171 of file G4UIcommandTree.cc.

References G4String::append(), G4String::first(), GetPathName(), G4String::index(), and G4String::remove().

Referenced by G4UImanager::ApplyCommand(), G4CascadeParamMessenger::CreateDirectory(), export_G4UIcommandTree(), G4VBasicShell::FindCommand(), G4UImanager::GetCurrentValues(), and G4VBasicShell::TerminalHelp().

{
  G4String remainingPath = commandPath;
  if( remainingPath.index( pathName ) == std::string::npos )
  { return NULL; }
  remainingPath.remove(0,pathName.length());
  G4int i = remainingPath.first('/');
  if( i == G4int(std::string::npos) )
  {
    // Find command
    G4int n_commandEntry = command.size();
    for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
    {
      if( remainingPath == command[i_thCommand]->GetCommandName() )
      { return command[i_thCommand]; }
    }
  }
  else
  {
    // Find path
    G4String nextPath = pathName;
    nextPath.append(remainingPath(0,i+1));
    G4int n_treeEntry = tree.size();
    for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
    {
      if( nextPath == tree[i_thTree]->GetPathName() )
      { return tree[i_thTree]->FindPath( commandPath ); }
    }
  }
  return NULL;
}

G4UIcommand* G4UIcommandTree::GetCommand ( G4int  i )

inline

Definition at line 99 of file G4UIcommandTree.hh.

Referenced by CompleteCommandPath(), export_G4UIcommandTree(), and G4VBasicShell::TerminalHelp().

      { return command[i-1]; };

G4int G4UIcommandTree::GetCommandEntry ( ) const

inline

Definition at line 85 of file G4UIcommandTree.hh.

Referenced by CompleteCommandPath(), and export_G4UIcommandTree().

      { return command.size(); };

const G4UIcommand* G4UIcommandTree::GetGuidance ( ) const

inline

Definition at line 79 of file G4UIcommandTree.hh.

Referenced by export_G4UIcommandTree(), and ListCurrent().

      { return guidance; };

const G4String G4UIcommandTree::GetPathName ( ) const

inline

Definition at line 81 of file G4UIcommandTree.hh.

Referenced by AddNewCommand(), CompleteCommandPath(), CreateHTML(), export_G4UIcommandTree(), FindCommandTree(), FindPath(), GetTree(), operator!=(), operator==(), and RemoveCommand().

      { return pathName; };

const G4String G4UIcommandTree::GetTitle ( ) const

inline

Definition at line 101 of file G4UIcommandTree.hh.

References G4UIcommand::GetTitle().

Referenced by CreateHTML(), and export_G4UIcommandTree().

      { 
        if(guidance==NULL)
        { return G4String("...Title not available..."); }
        else
        { return guidance->GetTitle(); }
      };

G4UIcommandTree* G4UIcommandTree::GetTree ( G4int  i )

inline

Definition at line 87 of file G4UIcommandTree.hh.

Referenced by CompleteCommandPath(), G4VBasicShell::FindDirectory(), and G4VBasicShell::TerminalHelp().

      { return tree[i-1]; };

G4UIcommandTree* G4UIcommandTree::GetTree ( const char *  comNameC )

inline

Definition at line 89 of file G4UIcommandTree.hh.

References GetPathName().

      { 
        G4String comName = comNameC;
        for( size_t i=0; i < tree.size(); i++)
        {
          if( comName == tree[i]->GetPathName() )
          { return tree[i]; }
        }
        return NULL;
      };

G4int G4UIcommandTree::GetTreeEntry ( ) const

inline

Definition at line 83 of file G4UIcommandTree.hh.

Referenced by CompleteCommandPath(), export_G4UIcommandTree(), RemoveCommand(), and G4VBasicShell::TerminalHelp().

      { return tree.size(); };

void G4UIcommandTree::List

(

)

const

Definition at line 390 of file G4UIcommandTree.cc.

References ListCurrent().

Referenced by export_G4UIcommandTree(), and G4UImanager::ListCommands().

{
  ListCurrent();
  G4int n_commandEntry = command.size();
  for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
  {
    command[i_thCommand]->List();
  }
  G4int n_treeEntry = tree.size();
  for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
  {
    tree[i_thTree]->List();
  }
}

void G4UIcommandTree::ListCurrent

(

)

const

Definition at line 338 of file G4UIcommandTree.cc.

References G4cout, G4endl, GetGuidance(), and G4UIcommand::List().

Referenced by export_G4UIcommandTree(), List(), and G4VBasicShell::ListDirectory().

{
  G4cout << "Command directory path : " << pathName << G4endl;
  if( guidance != NULL ) guidance->List();
  G4cout << " Sub-directories : " << G4endl;
  G4int n_treeEntry = tree.size();
  for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
  { 
    G4cout << "   " << tree[i_thTree]->GetPathName();
    if(tree[i_thTree]->GetGuidance() &&
       tree[i_thTree]->GetGuidance()->IsWorkerThreadOnly())
    { G4cout << " @ "; }
    else
    { G4cout << "   "; }
    G4cout << tree[i_thTree]->GetTitle() << G4endl;
  }
  G4cout << " Commands : " << G4endl;
  G4int n_commandEntry = command.size();
  for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
  {
    G4cout << "   " << command[i_thCommand]->GetCommandName();
    if(command[i_thCommand]->IsWorkerThreadOnly())
    { G4cout << " @ "; }
    else
    { G4cout << " * "; }
    G4cout << command[i_thCommand]->GetTitle() << G4endl;
  }
}

void G4UIcommandTree::ListCurrentWithNum

(

)

const

Definition at line 367 of file G4UIcommandTree.cc.

References G4cout, G4endl, and G4UIcommand::List().

Referenced by export_G4UIcommandTree(), and G4VBasicShell::TerminalHelp().

{
  G4cout << "Command directory path : " << pathName << G4endl;
  if( guidance != NULL ) guidance->List();
  G4int i = 0;
  G4cout << " Sub-directories : " << G4endl;
  G4int n_treeEntry = tree.size();
  for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
  {
    i++;
    G4cout << " " << i << ") " << tree[i_thTree]->GetPathName() 
     << "   " << tree[i_thTree]->GetTitle() << G4endl;
  }
  G4cout << " Commands : " << G4endl;
  G4int n_commandEntry = command.size();
  for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
  {
    i++;
    G4cout << " " << i << ") " << command[i_thCommand]->GetCommandName() 
     << " * " << command[i_thCommand]->GetTitle() << G4endl;
  }
}

G4int G4UIcommandTree::operator!=

(

const G4UIcommandTree &

right

)

const

Definition at line 58 of file G4UIcommandTree.cc.

References GetPathName().

{
  return ( pathName != right.GetPathName() );
}

G4int G4UIcommandTree::operator==

(

const G4UIcommandTree &

right

)

const

Definition at line 53 of file G4UIcommandTree.cc.

References GetPathName().

{
  return ( pathName == right.GetPathName() );
}

void G4UIcommandTree::RemoveCommand	(	G4UIcommand *	aCommand,
		G4bool	workerThreadOnly = false
	)

Definition at line 116 of file G4UIcommandTree.cc.

References G4String::append(), G4String::first(), G4UIcommand::GetCommandPath(), GetPathName(), GetTreeEntry(), G4String::isNull(), G4UIcommand::IsWorkerThreadOnly(), and G4String::remove().

Referenced by G4UImanager::RemoveCommand().

{
  if(workerThreadOnly && !(aCommand->IsWorkerThreadOnly())) return;
  G4String commandPath = aCommand->GetCommandPath();
  G4String remainingPath = commandPath;
  remainingPath.remove(0,pathName.length());
  if( remainingPath.isNull() )
  {
    guidance = NULL;
  }
  else
  {
    G4int i = remainingPath.first('/');
    if( i == G4int(std::string::npos) )
    {
      // Find command
      G4int n_commandEntry = command.size();
      for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
      {
        if( remainingPath == command[i_thCommand]->GetCommandName() )
        { 
          command.erase(command.begin()+i_thCommand);
          break;
        }
      }
    }
    else
    {
      // Find path
      G4String nextPath = pathName;
      nextPath.append(remainingPath(0,i+1));
      G4int n_treeEntry = tree.size();
      for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
      {
        if( nextPath == tree[i_thTree]->GetPathName() )
        { 
          tree[i_thTree]->RemoveCommand( aCommand );
          G4int n_commandRemain = tree[i_thTree]->GetCommandEntry();
        G4int n_treeRemain = tree[i_thTree]-> GetTreeEntry();
          if(n_commandRemain == 0 && n_treeRemain == 0)
          {
            G4UIcommandTree * emptyTree = tree[i_thTree];
            tree.erase(tree.begin()+i_thTree);
            delete emptyTree;
          }
          break;
        }
      }
    }
  }
}

---

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

• G4UIcommandTree.hh
• G4UIcommandTree.cc