Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/intercoms/src/G4UIcommandTree.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /intercoms/src/G4UIcommandTree.cc (Version 11.3.0) and /intercoms/src/G4UIcommandTree.cc (Version 5.1.p1)


                                                   >>   1 //
  1 // *******************************************      2 // ********************************************************************
  2 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  3 // *                                                4 // *                                                                  *
  4 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  5 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  6 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  7 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  8 // * include a list of copyright holders.      << 
  9 // *                                                9 // *                                                                  *
 10 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 11 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 12 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 13 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 14 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 15 // * for the full disclaimer and the limitatio << 
 16 // *                                               15 // *                                                                  *
 17 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 18 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 19 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 20 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 21 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 22 // * acceptance of all terms of the Geant4 Sof << 
 23 // *******************************************     21 // ********************************************************************
 24 //                                                 22 //
 25 // G4UIcommandTree                             << 
 26 //                                                 23 //
 27 // Author: Makoto Asai (SLAC), 1998            <<  24 // $Id: G4UIcommandTree.cc,v 1.11 2002/04/26 22:03:35 asaim Exp $
 28 // Midified: Makoto Asai (SLAC), 2021          <<  25 // GEANT4 tag $Name: geant4-05-01-patch-01 $
 29 //   Improve output HTML file layout and add o <<  26 //
 30 //   command/directory names in alphabetic ord << 
 31 // ------------------------------------------- << 
 32                                                    27 
 33 #include "G4UIcommandTree.hh"                      28 #include "G4UIcommandTree.hh"
 34                                                << 
 35 #include "G4StateManager.hh"                       29 #include "G4StateManager.hh"
 36 #include "G4UIdirectory.hh"                    <<  30 #include "g4std/fstream"
 37 #include "G4UImanager.hh"                      << 
 38 #include "G4ios.hh"                                31 #include "G4ios.hh"
 39                                                    32 
 40 #include <fstream>                             <<  33 G4UIcommandTree::G4UIcommandTree()
                                                   >>  34 :guidance(NULL)
                                                   >>  35 { }
 41                                                    36 
 42 // ------------------------------------------- <<  37 G4UIcommandTree::G4UIcommandTree(const char * thePathName)
 43 G4UIcommandTree::G4UIcommandTree(const char* t <<  38 :guidance(NULL)
 44 {                                                  39 {
 45   pathName = thePathName;                          40   pathName = thePathName;
 46 }                                                  41 }
 47                                                    42 
 48 // ------------------------------------------- << 
 49 G4UIcommandTree::~G4UIcommandTree()                43 G4UIcommandTree::~G4UIcommandTree()
 50 {                                                  44 {
 51   for (auto& i : tree) {                       <<  45   G4int i;
 52     delete i;                                  <<  46   G4int n_treeEntry = tree.size();
 53   }                                            <<  47   for( i=0; i < n_treeEntry; i++ )
                                                   >>  48   { delete tree[i]; }
 54 }                                                  49 }
 55                                                    50 
 56 // ------------------------------------------- <<  51 G4int G4UIcommandTree::operator==(const G4UIcommandTree &right) const
 57 G4bool G4UIcommandTree::operator==(const G4UIc << 
 58 {                                                  52 {
 59   return (pathName == right.GetPathName());    <<  53   return ( pathName == right.GetPathName() );
 60 }                                                  54 }
 61                                                    55 
 62 // ------------------------------------------- <<  56 G4int G4UIcommandTree::operator!=(const G4UIcommandTree &right) const
 63 G4bool G4UIcommandTree::operator!=(const G4UIc << 
 64 {                                                  57 {
 65   return (pathName != right.GetPathName());    <<  58   return ( pathName != right.GetPathName() );
 66 }                                                  59 }
 67                                                    60 
 68 // ------------------------------------------- <<  61 void G4UIcommandTree::AddNewCommand(G4UIcommand *newCommand)
 69 void G4UIcommandTree::AddNewCommand(G4UIcomman << 
 70 {                                                  62 {
 71   G4String commandPath = newCommand->GetComman     63   G4String commandPath = newCommand->GetCommandPath();
 72   G4String remainingPath = commandPath;            64   G4String remainingPath = commandPath;
 73   remainingPath.erase(0, pathName.length());   <<  65   remainingPath.remove(0,pathName.length());
 74   if (remainingPath.empty()) {                 <<  66   if( remainingPath.isNull() )
 75     if (guidance == nullptr) {                 <<  67   {
 76       guidance = newCommand;                   <<  68     guidance = newCommand;
 77       if (!(newCommand->ToBeBroadcasted())) {  << 
 78         broadcastCommands = false;             << 
 79       }                                        << 
 80       if (workerThreadOnly) {                  << 
 81         newCommand->SetWorkerThreadOnly();     << 
 82       }                                        << 
 83     }                                          << 
 84     return;                                        69     return;
 85   }                                                70   }
 86                                                <<  71   G4int i = remainingPath.first('/');
 87   if (guidance != nullptr) {                   <<  72   if( i == G4int(G4std::string::npos) )
 88     auto* dir = static_cast<G4UIdirectory*>(gu <<  73   {
 89     ifSort = dir->IfSort();                    <<  74     // Find command
 90   }                                            <<  75     G4int n_commandEntry = command.size();
 91   std::size_t i = remainingPath.find('/');     <<  76     for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
 92   if (i == std::string::npos) {                <<  77     {
 93     // Adding a new command to this directory  <<  78       if( remainingPath == command[i_thCommand]->GetCommandName() )
 94     std::size_t n_commandEntry = command.size( <<  79       { return; }
 95     for (std::size_t i_thCommand = 0; i_thComm << 
 96       if (remainingPath == command[i_thCommand << 
 97         // a command of same name has already  << 
 98         if (G4UImanager::GetUIpointer()->GetVe << 
 99           G4ExceptionDescription ed;           << 
100           ed << "Command <" << commandPath <<  << 
101           G4Exception("G4UIcommandTree::AddNew << 
102                       // FatalException,       << 
103                       JustWarning, ed);        << 
104         }                                      << 
105         return;                                << 
106       }                                        << 
107     }                                          << 
108     if (!broadcastCommands) {                  << 
109       newCommand->SetToBeBroadcasted(false);   << 
110     }                                          << 
111     if (workerThreadOnly) {                    << 
112       newCommand->SetWorkerThreadOnly();       << 
113     }                                          << 
114     if (ifSort) {                              << 
115       auto j = command.cbegin();               << 
116       for (; j != command.cend(); ++j) {       << 
117         if (newCommand->GetCommandPath() < (*j << 
118           break;                               << 
119         }                                      << 
120       }                                        << 
121       command.insert(j, newCommand);           << 
122     }                                          << 
123     else {                                     << 
124       command.push_back(newCommand);           << 
125     }                                              80     }
                                                   >>  81     command.push_back( newCommand );
126     return;                                        82     return;
127   }                                                83   }
128                                                <<  84   else
129   // Adding a new command to a sub-directory   <<  85   {
130   G4String nextPath = pathName;                <<  86     // Find path
131   nextPath.append(remainingPath.substr(0, i +  <<  87     G4String nextPath = pathName;
132   std::size_t n_treeEntry = tree.size();       <<  88     nextPath.append(remainingPath(0,i+1));
133   for (std::size_t i_thTree = 0; i_thTree < n_ <<  89     G4int n_treeEntry = tree.size();
134     if (nextPath == tree[i_thTree]->GetPathNam <<  90     for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
135       if (!broadcastCommands) {                <<  91     {
136         newCommand->SetToBeBroadcasted(false); <<  92       if( nextPath == tree[i_thTree]->GetPathName() )
137       }                                        <<  93       { 
138       tree[i_thTree]->AddNewCommand(newCommand <<  94   tree[i_thTree]->AddNewCommand( newCommand );
139       return;                                  <<  95   return; 
140     }                                          << 
141   }                                            << 
142   // Creating a new sub-directory              << 
143   auto* newTree = new G4UIcommandTree(nextPath << 
144   if (ifSort) {                                << 
145     auto j = tree.cbegin();                    << 
146     for (; j != tree.cend(); ++j) {            << 
147       if (newTree->GetPathName() < (*j)->GetPa << 
148         break;                                 << 
149       }                                            96       }
150     }                                              97     }
151     tree.insert(j, newTree);                   <<  98     G4UIcommandTree * newTree = new G4UIcommandTree( nextPath );
152   }                                            <<  99     tree.push_back( newTree );
153   else {                                       << 100     newTree->AddNewCommand( newCommand );
154     tree.push_back(newTree);                   << 101     return;
155   }                                            << 
156   if (!broadcastCommands) {                    << 
157     newCommand->SetToBeBroadcasted(false);     << 
158   }                                               102   }
159   // In case a new sub-directry is created wit << 
160   // (most-likely this is the case), inherit t << 
161   newCommand->SetDefaultSortFlag(ifSort);      << 
162   newTree->AddNewCommand(newCommand, workerThr << 
163   return;                                      << 
164 }                                                 103 }
165                                                   104 
166 // ------------------------------------------- << 105 void G4UIcommandTree::RemoveCommand(G4UIcommand *aCommand)
167 void G4UIcommandTree::RemoveCommand(G4UIcomman << 
168 {                                                 106 {
169   if (workerThreadOnly && !(aCommand->IsWorker << 
170     return;                                    << 
171   }                                            << 
172   G4String commandPath = aCommand->GetCommandP    107   G4String commandPath = aCommand->GetCommandPath();
173   commandPath.erase(0, pathName.length());     << 108   G4String remainingPath = commandPath;
174   if (commandPath.empty()) {                   << 109   remainingPath.remove(0,pathName.length());
175     guidance = nullptr;                        << 110   if( remainingPath.isNull() )
176   }                                            << 111   {
177   else {                                       << 112     guidance = NULL;
178     std::size_t i = commandPath.find('/');     << 113   }
179     if (i == std::string::npos) {              << 114   else
                                                   >> 115   {
                                                   >> 116     G4int i = remainingPath.first('/');
                                                   >> 117     if( i == G4int(G4std::string::npos) )
                                                   >> 118     {
180       // Find command                             119       // Find command
181       std::size_t n_commandEntry = command.siz << 120       G4int n_commandEntry = command.size();
182       for (std::size_t i_thCommand = 0; i_thCo << 121       for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
183         if (commandPath == command[i_thCommand << 122       {
184           command.erase(command.begin() + i_th << 123         if( remainingPath == command[i_thCommand]->GetCommandName() )
                                                   >> 124         { 
                                                   >> 125           command.erase(command.begin()+i_thCommand);
185           break;                                  126           break;
186         }                                         127         }
187       }                                           128       }
188     }                                             129     }
189     else {                                     << 130     else
                                                   >> 131     {
190       // Find path                                132       // Find path
191       G4String nextPath = pathName;               133       G4String nextPath = pathName;
192       nextPath.append(commandPath.substr(0, i  << 134       nextPath.append(remainingPath(0,i+1));
193       std::size_t n_treeEntry = tree.size();   << 135       G4int n_treeEntry = tree.size();
194       for (std::size_t i_thTree = 0; i_thTree  << 136       for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
195         if (nextPath == tree[i_thTree]->GetPat << 137       {
196           tree[i_thTree]->RemoveCommand(aComma << 138         if( nextPath == tree[i_thTree]->GetPathName() )
197           G4int n_commandRemain = tree[i_thTre << 139         { 
198           G4int n_treeRemain = tree[i_thTree]- << 140         tree[i_thTree]->RemoveCommand( aCommand );
199           if (n_commandRemain == 0 && n_treeRe << 141         G4int n_commandRemain = tree[i_thTree]->GetCommandEntry();
200             G4UIcommandTree* emptyTree = tree[ << 142         if(n_commandRemain==0)
201             tree.erase(tree.begin() + i_thTree << 143         {
202             delete emptyTree;                  << 144           G4UIcommandTree * emptyTree = tree[i_thTree];
203           }                                    << 145           tree.erase(tree.begin()+i_thTree);
204           break;                               << 146           delete emptyTree;
                                                   >> 147         }
                                                   >> 148         break;
205         }                                         149         }
206       }                                           150       }
207     }                                             151     }
208   }                                               152   }
209 }                                                 153 }
210                                                   154 
211 // ------------------------------------------- << 155 G4UIcommand * G4UIcommandTree::FindPath(const char* commandPath)
212 G4UIcommand* G4UIcommandTree::FindPath(const c << 
213 {                                                 156 {
214   // This function tries to match a command na << 
215                                                << 
216   G4String remainingPath = commandPath;           157   G4String remainingPath = commandPath;
217   if (remainingPath.find(pathName) == std::str << 158   if( remainingPath.index( pathName ) == G4std::string::npos )
218     return nullptr;                            << 159   { return NULL; }
219   }                                            << 160   remainingPath.remove(0,pathName.length());
220   remainingPath.erase(0, pathName.length());   << 161   G4int i = remainingPath.first('/');
221   std::size_t i = remainingPath.find('/');     << 162   if( i == G4int(G4std::string::npos) )
222   if (i == std::string::npos) {                << 163   {
223     // Find command                               164     // Find command
224     std::size_t n_commandEntry = command.size( << 165     G4int n_commandEntry = command.size();
225     for (std::size_t i_thCommand = 0; i_thComm << 166     for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
226       if (remainingPath == command[i_thCommand << 167     {
227         return command[i_thCommand];           << 168       if( remainingPath == command[i_thCommand]->GetCommandName() )
228       }                                        << 169       { return command[i_thCommand]; }
229     }                                             170     }
230   }                                               171   }
231   else {                                       << 172   else
                                                   >> 173   {
232     // Find path                                  174     // Find path
233     G4String nextPath = pathName;                 175     G4String nextPath = pathName;
234     nextPath.append(remainingPath.substr(0, i  << 176     nextPath.append(remainingPath(0,i+1));
235     std::size_t n_treeEntry = tree.size();     << 177     G4int n_treeEntry = tree.size();
236     for (std::size_t i_thTree = 0; i_thTree <  << 178     for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
237       if (nextPath == tree[i_thTree]->GetPathN << 179     {
238         return tree[i_thTree]->FindPath(comman << 180       if( nextPath == tree[i_thTree]->GetPathName() )
239       }                                        << 181       { return tree[i_thTree]->FindPath( commandPath ); }
240     }                                          << 
241   }                                            << 
242   return nullptr;                              << 
243 }                                              << 
244                                                << 
245 // ------------------------------------------- << 
246 G4UIcommandTree* G4UIcommandTree::FindCommandT << 
247 {                                              << 
248   // Try to match a command or a path with the << 
249   // @commandPath : command or path to match   << 
250   // @return the commandTree found or nullptr  << 
251                                                << 
252   G4String remainingPath = commandPath;        << 
253   if (remainingPath.find(pathName) == std::str << 
254     return nullptr;                            << 
255   }                                            << 
256   remainingPath.erase(0, pathName.length());   << 
257   std::size_t i = remainingPath.find('/');     << 
258   if (i != std::string::npos) {                << 
259     // Find path                               << 
260     G4String nextPath = pathName;              << 
261     nextPath.append(remainingPath.substr(0, i  << 
262     std::size_t n_treeEntry = tree.size();     << 
263     for (std::size_t i_thTree = 0; i_thTree <  << 
264       if (tree[i_thTree]->GetPathName() == com << 
265         return tree[i_thTree];                 << 
266       }                                        << 
267       if (nextPath == tree[i_thTree]->GetPathN << 
268         return tree[i_thTree]->FindCommandTree << 
269       }                                        << 
270     }                                          << 
271   }                                            << 
272   else {                                       << 
273     return this;                               << 
274   }                                            << 
275   return nullptr;                              << 
276 }                                              << 
277                                                << 
278 // ------------------------------------------- << 
279 G4String G4UIcommandTree::CompleteCommandPath( << 
280 {                                              << 
281   G4String pName = aCommandPath;               << 
282   G4String remainingPath = aCommandPath;       << 
283   G4String empty = "";                         << 
284   G4String matchingPath = empty;               << 
285                                                << 
286   // find the tree                             << 
287   auto jpre = pName.rfind('/');                << 
288   if (jpre != G4String::npos) {                << 
289     pName.erase(jpre + 1);                     << 
290   }                                            << 
291   G4UIcommandTree* aTree = FindCommandTree(pNa << 
292                                                << 
293   if (aTree == nullptr) {                      << 
294     return empty;                              << 
295   }                                            << 
296                                                << 
297   if (pName.find(pName) == std::string::npos)  << 
298     return empty;                              << 
299   }                                            << 
300                                                << 
301   std::vector<G4String> paths;                 << 
302                                                << 
303   // list matched directories/commands         << 
304   G4String strtmp;                             << 
305   G4int nMatch = 0;                            << 
306                                                << 
307   G4int Ndir = aTree->GetTreeEntry();          << 
308   G4int Ncmd = aTree->GetCommandEntry();       << 
309                                                << 
310   // directory ...                             << 
311   for (G4int idir = 1; idir <= Ndir; ++idir) { << 
312     const G4String& fpdir = aTree->GetTree(idi << 
313     // matching test                           << 
314     if (fpdir.find(remainingPath, 0) == 0) {   << 
315       if (nMatch == 0) {                       << 
316         matchingPath = fpdir;                  << 
317       }                                        << 
318       else {                                   << 
319         matchingPath = GetFirstMatchedString(f << 
320       }                                        << 
321       ++nMatch;                                << 
322       paths.push_back(fpdir);                  << 
323     }                                          << 
324   }                                            << 
325                                                << 
326   if (paths.size() >= 2) {                     << 
327     G4cout << "Matching directories :" << G4en << 
328     for (const auto& path : paths) {           << 
329       G4cout << path << G4endl;                << 
330     }                                          << 
331   }                                            << 
332                                                << 
333   // command ...                               << 
334   std::vector<G4String> commands;              << 
335                                                << 
336   for (G4int icmd = 1; icmd <= Ncmd; ++icmd) { << 
337     G4String fpcmd = aTree->GetPathName() + aT << 
338     // matching test                           << 
339     if (fpcmd.find(remainingPath, 0) == 0) {   << 
340       if (nMatch == 0) {                       << 
341         matchingPath = fpcmd + " ";            << 
342       }                                        << 
343       else {                                   << 
344         strtmp = fpcmd + " ";                  << 
345         matchingPath = GetFirstMatchedString(m << 
346       }                                        << 
347       nMatch++;                                << 
348       commands.emplace_back(fpcmd + " ");      << 
349     }                                          << 
350   }                                            << 
351                                                << 
352   if (commands.size() >= 2) {                  << 
353     G4cout << "Matching commands :" << G4endl; << 
354     for (const auto& matched : commands) {     << 
355       G4cout << matched << G4endl;             << 
356     }                                          << 
357   }                                            << 
358                                                << 
359   return matchingPath;                         << 
360 }                                              << 
361                                                << 
362 // ------------------------------------------- << 
363 G4String G4UIcommandTree::GetFirstMatchedStrin << 
364 {                                              << 
365   std::size_t nlen1 = str1.length();           << 
366   std::size_t nlen2 = str2.length();           << 
367                                                << 
368   std::size_t nmin = nlen1 < nlen2 ? nlen1 : n << 
369                                                << 
370   G4String strMatched;                         << 
371   for (G4int i = 0; i < (G4int)nmin; ++i) {    << 
372     if (str1[i] == str2[i]) {                  << 
373       strMatched += str1[i];                   << 
374     }                                          << 
375     else {                                     << 
376       break;                                   << 
377     }                                             182     }
378   }                                               183   }
379                                                << 184   return NULL;
380   return strMatched;                           << 
381 }                                                 185 }
382                                                   186 
383 // ------------------------------------------- << 187 void G4UIcommandTree::ListCurrent()
384 void G4UIcommandTree::ListCurrent() const      << 
385 {                                                 188 {
386   G4cout << "Command directory path : " << pat    189   G4cout << "Command directory path : " << pathName << G4endl;
387   if (guidance != nullptr) {                   << 190   if( guidance != NULL ) guidance->List();
388     guidance->List();                          << 
389   }                                            << 
390   G4cout << " Sub-directories : " << G4endl;      191   G4cout << " Sub-directories : " << G4endl;
391   std::size_t n_treeEntry = tree.size();       << 192   G4int n_treeEntry = tree.size();
392   for (std::size_t i_thTree = 0; i_thTree < n_ << 193   for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
393     G4cout << "   " << tree[i_thTree]->GetPath << 194   {
394     if ((tree[i_thTree]->GetGuidance() != null << 195     G4cout << "   " << tree[i_thTree]->GetPathName() 
395         && tree[i_thTree]->GetGuidance()->IsWo << 196    << "   " << tree[i_thTree]->GetTitle() << G4endl;
396     {                                          << 
397       G4cout << " @ ";                         << 
398     }                                          << 
399     else {                                     << 
400       G4cout << "   ";                         << 
401     }                                          << 
402     G4cout << tree[i_thTree]->GetTitle() << G4 << 
403   }                                               197   }
404   G4cout << " Commands : " << G4endl;             198   G4cout << " Commands : " << G4endl;
405   std::size_t n_commandEntry = command.size(); << 199   G4int n_commandEntry = command.size();
406   for (std::size_t i_thCommand = 0; i_thComman << 200   for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
407     G4cout << "   " << command[i_thCommand]->G << 201   {
408     if (command[i_thCommand]->IsWorkerThreadOn << 202     G4cout << "   " << command[i_thCommand]->GetCommandName() 
409       G4cout << " @ ";                         << 203    << " * " << command[i_thCommand]->GetTitle() << G4endl;
410     }                                          << 
411     else {                                     << 
412       G4cout << " * ";                         << 
413     }                                          << 
414     G4cout << command[i_thCommand]->GetTitle() << 
415   }                                               204   }
416 }                                                 205 }
417                                                   206 
418 // ------------------------------------------- << 207 void G4UIcommandTree::ListCurrentWithNum()
419 void G4UIcommandTree::ListCurrentWithNum() con << 
420 {                                                 208 {
421   G4cout << "Command directory path : " << pat    209   G4cout << "Command directory path : " << pathName << G4endl;
422   if (guidance != nullptr) {                   << 210   if( guidance != NULL ) guidance->List();
423     guidance->List();                          << 
424   }                                            << 
425   G4int i = 0;                                    211   G4int i = 0;
426   G4cout << " Sub-directories : " << G4endl;      212   G4cout << " Sub-directories : " << G4endl;
427   std::size_t n_treeEntry = tree.size();       << 213   G4int n_treeEntry = tree.size();
428   for (std::size_t i_thTree = 0; i_thTree < n_ << 214   for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
429     ++i;                                       << 215   {
430     G4cout << " " << i << ") " << tree[i_thTre << 216     i++;
431            << tree[i_thTree]->GetTitle() << G4 << 217     G4cout << " " << i << ") " << tree[i_thTree]->GetPathName() 
                                                   >> 218    << "   " << tree[i_thTree]->GetTitle() << G4endl;
432   }                                               219   }
433   G4cout << " Commands : " << G4endl;             220   G4cout << " Commands : " << G4endl;
434   std::size_t n_commandEntry = command.size(); << 221   G4int n_commandEntry = command.size();
435   for (std::size_t i_thCommand = 0; i_thComman << 222   for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
436     ++i;                                       << 223   {
437     G4cout << " " << i << ") " << command[i_th << 224     i++;
438            << command[i_thCommand]->GetTitle() << 225     G4cout << " " << i << ") " << command[i_thCommand]->GetCommandName() 
                                                   >> 226    << " * " << command[i_thCommand]->GetTitle() << G4endl;
439   }                                               227   }
440 }                                                 228 }
441                                                   229 
442 // ------------------------------------------- << 230 void G4UIcommandTree::List()
443 void G4UIcommandTree::List() const             << 
444 {                                                 231 {
445   ListCurrent();                                  232   ListCurrent();
446   std::size_t n_commandEntry = command.size(); << 233   G4int n_commandEntry = command.size();
447   for (std::size_t i_thCommand = 0; i_thComman << 234   for( G4int i_thCommand = 0; i_thCommand < n_commandEntry; i_thCommand++ )
                                                   >> 235   {
448     command[i_thCommand]->List();                 236     command[i_thCommand]->List();
449   }                                               237   }
450   std::size_t n_treeEntry = tree.size();       << 238   G4int n_treeEntry = tree.size();
451   for (std::size_t i_thTree = 0; i_thTree < n_ << 239   for( G4int i_thTree = 0; i_thTree < n_treeEntry; i_thTree++ )
                                                   >> 240   {
452     tree[i_thTree]->List();                       241     tree[i_thTree]->List();
453   }                                               242   }
454 }                                                 243 }
455                                                   244 
456 // ------------------------------------------- << 
457 G4String G4UIcommandTree::CreateFileName(const    245 G4String G4UIcommandTree::CreateFileName(const char* pName)
458 {                                                 246 {
459   G4String fn = pName;                            247   G4String fn = pName;
460   std::size_t idxs;                            << 248   G4int idxs;
461   while ((idxs = fn.find('/')) != std::string: << 249   while((idxs=fn.index("/"))!=G4int(G4std::string::npos))
462     fn[(G4int)idxs] = '_';                     << 250   { fn(idxs) = '_'; }
463   }                                            << 
464   fn += ".html";                                  251   fn += ".html";
465   return fn;                                      252   return fn;
466 }                                                 253 }
467                                                   254 
468 // ------------------------------------------- << 
469 G4String G4UIcommandTree::ModStr(const char* s    255 G4String G4UIcommandTree::ModStr(const char* strS)
470 {                                                 256 {
471   G4String sx;                                    257   G4String sx;
472   G4String str = strS;                            258   G4String str = strS;
473   for (G4int i = 0; i < G4int(str.length()); + << 259   for(G4int i=0;i<G4int(str.length());i++)
474     char c = str[i];                           << 260   {
475     switch (c) {                               << 261     char c = str(i);
476       case '<':                                << 262     switch(c)
477         sx += "&lt;";                          << 263     {
478         break;                                 << 264     case '<':
479       case '>':                                << 265       sx += "&lt;"; break;
480         sx += "&gt;";                          << 266     case '>':
481         break;                                 << 267       sx += "&gt;"; break;
482       case '&':                                << 268     case '&':
483         sx += "&amp;";                         << 269       sx += "&amp;"; break;
484         break;                                 << 270     default:
485       default:                                 << 271       sx += c;
486         sx += c;                               << 
487     }                                             272     }
488   }                                               273   }
489   return sx;                                      274   return sx;
490 }                                                 275 }
491                                                   276 
492 // ------------------------------------------- << 277 void G4UIcommandTree::CreateHTML()
493 void G4UIcommandTree::CreateHTML(const G4Strin << 
494 {                                                 278 {
495   G4String ofileName = CreateFileName(pathName    279   G4String ofileName = CreateFileName(pathName);
496   std::ofstream oF(ofileName, std::ios::out);  << 280   G4std::ofstream oF(ofileName, G4std::ios::out);
497                                                   281 
498   oF << "<html><head><title>Commands in " << M    282   oF << "<html><head><title>Commands in " << ModStr(pathName) << "</title></head>" << G4endl;
499   oF << "<style> \                             << 283   oF << "<body bgcolor=\"#ffffff\"><h2>" << ModStr(pathName) << "</h2><p>" << G4endl;
500     table,table td,table th { \                << 
501        border:1px solid #eee \                 << 
502     } \                                        << 
503     table td,table th { \                      << 
504       padding:5px 20px; \                      << 
505       line-height:1.3; \                       << 
506       text-align:inherit \                     << 
507     } \                                        << 
508     a { \                                      << 
509       color:#17a81a; \                         << 
510       text-decoration:none; \                  << 
511       transition-duration:0.3s \               << 
512     } \                                        << 
513       a:hover { \                              << 
514       color:#17a81a \                          << 
515     } \                                        << 
516     table { \                                  << 
517       border-collapse:collapse; \              << 
518       border-spacing:0; \                      << 
519       margin-bottom:5px; \                     << 
520     } \                                        << 
521     h1 { \                                     << 
522       font-size:2.25em; \                      << 
523       font-weight:300; \                       << 
524       letter-spacing:-1px; \                   << 
525       line-height:1.15em; \                    << 
526       margin-bottom:0.5em; \                   << 
527       word-wrap:break-word \                   << 
528     } \                                        << 
529     h2 { \                                     << 
530       font-size:1.5em; \                       << 
531       font-weight:300; \                       << 
532       letter-spacing:-1px; \                   << 
533       line-height:1.15em; \                    << 
534       margin-bottom:0.5em; \                   << 
535       word-wrap:break-word \                   << 
536     } \                                        << 
537     h3 { \                                     << 
538       color:#26282a; \                         << 
539       font-weight:300; \                       << 
540       font-size:1.3em; \                       << 
541       padding:15px 0 15px 0; \                 << 
542       border-bottom:2px #eee solid; \          << 
543       word-wrap:break-word \                   << 
544     } \                                        << 
545     .sidebar { \                               << 
546       display:block; \                         << 
547       position:relative; \                     << 
548       position:sticky; \                       << 
549       float:left; \                            << 
550       -webkit-box-sizing:border-box; \         << 
551       -moz-box-sizing:border-box; \            << 
552       -ms-box-sizing:border-box; \             << 
553       box-sizing:border-box; \                 << 
554       width:20%; \                             << 
555       padding-right:20px \                     << 
556     } \                                        << 
557     .context { \                               << 
558     width:80%; \                               << 
559     display:inline-block; \                    << 
560     background-color:#fff; \                   << 
561     padding: 25px 35px 20px 30px; \            << 
562     -webkit-box-sizing:border-box; \           << 
563     -moz-box-sizing:border-box; \              << 
564     -ms-box-sizing:border-box; \               << 
565     box-sizing:border-box \                    << 
566   } \                                          << 
567     </style>"                                  << 
568      << G4endl;                                << 
569   oF << "<body bgcolor=\"#ffffff\">" << G4endl << 
570                                                << 
571   // Left Panel                                << 
572   if (createHTMLTreeLevel == 0) {              << 
573     oF << "<div class=\"sidebar\">" << sideBar << 
574   }                                            << 
575   // Right Panel                               << 
576   oF << "<div class=\"context\">";             << 
577   oF << "<h1>" << ModStr(pathName) << "</h1>"  << 
578                                                << 
579   if (guidance != nullptr) {                   << 
580     for (G4int i = 0; i < (G4int)guidance->Get << 
581       oF << ModStr(guidance->GetGuidanceLine(i << 
582     }                                          << 
583   }                                            << 
584   if (!tree.empty()) {                         << 
585     G4String menu = "";                        << 
586     G4String newSideBar = "";                  << 
587     menu += "<h2>Sub-directories </h2><table>" << 
588     newSideBar += "<h2><a href=\"" + ofileName << 
589     // Build menu short version                << 
590     for (auto& i_thTree : tree) {              << 
591       newSideBar += "<tr><td><a href=\"" + Cre << 
592                     + ModStr(i_thTree->GetPath << 
593     }                                          << 
594     // Build menu                              << 
595     for (auto& i_thTree : tree) {              << 
596       menu += "<tr><td><a href=\"" + CreateFil << 
597               + ModStr(i_thTree->GetPathName() << 
598       menu += "</td><td>" + ModStr(i_thTree->G << 
599     }                                          << 
600     menu += "</table>";                        << 
601     newSideBar += "</table>";                  << 
602     for (auto& i_thTree : tree) {              << 
603       createHTMLTreeLevel++;                   << 
604       i_thTree->CreateHTML(newSideBar);        << 
605       createHTMLTreeLevel--;                   << 
606     }                                          << 
607     oF << menu << G4endl;                      << 
608   }                                            << 
609                                                   284 
610   if (!command.empty()) {                      << 285   if( guidance != NULL ) 
611     oF << "<h2>Commands </h2>" << G4endl;      << 286   {
612                                                << 287     for(G4int i=0;i<guidance->GetGuidanceEntries();i++)
613     // resume                                  << 288     { oF << ModStr(guidance->GetGuidanceLine(i)) << "<br>" << G4endl; }
614     oF << "<table>" << G4endl;                 << 289   }
615     for (std::size_t i_thCommand = 0; i_thComm << 290 
616       G4UIcommand* cmd = command[i_thCommand]; << 291   oF << "<p><hr><p>" << G4endl;
617       oF << "<tr><td><a href=\"#c" << i_thComm << 292   
618       oF << "</a></td></tr>" << G4endl;        << 293   oF << "<h2>Sub-directories : </h2><dl>" << G4endl;
                                                   >> 294   for( G4int i_thTree = 0; i_thTree < G4int(tree.size()); i_thTree++ )
                                                   >> 295   {
                                                   >> 296     oF << "<p><br><p><dt><a href=\"" << CreateFileName(tree[i_thTree]->GetPathName())
                                                   >> 297        << "\">" << ModStr(tree[i_thTree]->GetPathName()) << "</a>" << G4endl;
                                                   >> 298     oF << "<p><dd>" << ModStr(tree[i_thTree]->GetTitle()) << G4endl;
                                                   >> 299     tree[i_thTree]->CreateHTML();
                                                   >> 300   }
                                                   >> 301 
                                                   >> 302   oF << "</dl><p><hr><p>" << G4endl;
                                                   >> 303   
                                                   >> 304   oF << "<h2>Commands : </h2><dl>" << G4endl;
                                                   >> 305   for( G4int i_thCommand = 0; i_thCommand < G4int(command.size()); i_thCommand++ )
                                                   >> 306   {
                                                   >> 307     G4UIcommand* cmd = command[i_thCommand];
                                                   >> 308     oF << "<p><br><p><dt><b>" << ModStr(cmd->GetCommandName());
                                                   >> 309     if(cmd->GetParameterEntries()>0)
                                                   >> 310     {
                                                   >> 311       for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++)
                                                   >> 312       { oF << " [<i>" << ModStr(cmd->GetParameter(i_thParam)->GetParameterName()) << "</i>]"; }
619     }                                             313     }
620     oF << "</table>" << G4endl;                << 314     oF << "</b>" << G4endl;
621     for (std::size_t i_thCommand = 0; i_thComm << 315     oF << "<p><dd>" << G4endl;
622       G4UIcommand* cmd = command[i_thCommand]; << 316     for(G4int i=0;i<cmd->GetGuidanceEntries();i++)
623       oF << "<h3 id=\"c" << i_thCommand << "\" << 317     { oF << ModStr(cmd->GetGuidanceLine(i)) << "<br>" << G4endl; }
624       if (cmd->GetParameterEntries() > 0) {    << 318     if(!(cmd->GetRange()).isNull())
625         for (G4int i_thParam = 0; i_thParam <  << 319     { oF << "<p><dd>Range : " << ModStr(cmd->GetRange()) << G4endl; }
626           oF << " [<i>" << ModStr(cmd->GetPara << 320     G4std::vector<G4ApplicationState>* availabelStateList = cmd->GetStateList();
627         }                                      << 321     if(availabelStateList->size()==6)
628       }                                        << 322     { oF << "<p><dd>Available at all Geant4 states." << G4endl; }
629       oF << "</h3>" << G4endl;                 << 323     else
630       oF << "<p>" << G4endl;                   << 324     {
631       for (G4int i = 0; i < (G4int)cmd->GetGui << 325       oF << "<p><dd>Available Geant4 state(s) : ";
632         oF << ModStr(cmd->GetGuidanceLine(i))  << 326       for(G4int ias=0;ias<G4int(availabelStateList->size());ias++)
633       }                                        << 327       { oF << G4StateManager::GetStateManager()->GetStateString((*availabelStateList)[ias]) << " " << G4endl; }
634       if (!(cmd->GetRange()).empty()) {        << 328     }
635         oF << "<p>Range : " << ModStr(cmd->Get << 329     if(cmd->GetParameterEntries()>0)
636       }                                        << 330     {
637       std::vector<G4ApplicationState>* availab << 331       oF << "<p><dd>Parameters<table border=1>" << G4endl;
638       if (availabelStateList->size() == 6) {   << 332       for(G4int i_thParam=0;i_thParam<cmd->GetParameterEntries();i_thParam++)
639         oF << "<p>Available at all Geant4 stat << 333       {
640       }                                        << 334         G4UIparameter* prm = cmd->GetParameter(i_thParam);
641       else {                                   << 335         oF << "<tr><td>" << ModStr(prm->GetParameterName()) << G4endl;
642         oF << "<p>Available Geant4 state(s) :  << 336         oF << "<td>type " << prm->GetParameterType() << G4endl;
643         for (auto& ias : *availabelStateList)  << 337         oF << "<td>";
644           oF << G4StateManager::GetStateManage << 338         if(prm->IsOmittable())
645         }                                      << 339         { 
646       }                                        << 340           oF << "Omittable : ";
647       if (cmd->GetParameterEntries() > 0) {    << 341           if(prm->GetCurrentAsDefault())
648         oF << "<p>Parameters<table border=1>"  << 342           { oF << "current value is used as the default value." << G4endl; }
649         for (G4int i_thParam = 0; i_thParam <  << 343           else
650           G4UIparameter* prm = cmd->GetParamet << 344           { oF << "default value = " << prm->GetDefaultValue() << G4endl; }
651           oF << "<tr><td>" << ModStr(prm->GetP << 
652           oF << "<td>type " << prm->GetParamet << 
653           oF << "<td>";                        << 
654           if (prm->IsOmittable()) {            << 
655             oF << "Omittable : ";              << 
656             if (prm->GetCurrentAsDefault()) {  << 
657               oF << "current value is used as  << 
658             }                                  << 
659             else {                             << 
660               oF << "default value = " << prm- << 
661             }                                  << 
662           }                                    << 
663           oF << "<td>";                        << 
664           if (!(prm->GetParameterRange()).empt << 
665             oF << "Parameter range : " << ModS << 
666           }                                    << 
667           else if (!(prm->GetParameterCandidat << 
668             oF << "Parameter candidates : " << << 
669           }                                    << 
670         }                                         345         }
671         oF << "</table>" << G4endl;            << 346         oF << "<td>";
                                                   >> 347         if(!(prm->GetParameterRange()).isNull())
                                                   >> 348         { oF << "Parameter range : " << ModStr(prm->GetParameterRange()) << G4endl; }
                                                   >> 349         else if(!(prm->GetParameterCandidates()).isNull())
                                                   >> 350         { oF << "Parameter candidates : " << ModStr(prm->GetParameterCandidates()) << G4endl; }
672       }                                           351       }
                                                   >> 352       oF << "</table>" << G4endl;
673     }                                             353     }
                                                   >> 354 
674   }                                               355   }
675   oF << "</div></body></html>" << G4endl;      << 356   
                                                   >> 357   oF << "</dl></body></html>" << G4endl;
676   oF.close();                                     358   oF.close();
677 }                                                 359 }
678                                                   360 
679 // ------------------------------------------- << 
680 G4UIcommandTree* G4UIcommandTree::GetTree(cons << 
681 {                                              << 
682   G4String comName = comNameC;                 << 
683   for (auto& i : tree) {                       << 
684     if (comName == i->GetPathName()) {         << 
685       return i;                                << 
686     }                                          << 
687   }                                            << 
688   return nullptr;                              << 
689 }                                              << 
690                                                   361