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