| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // G4StateManager class implementation 26 // G4StateManager class implementation
27 // 27 //
28 // Authors: G.Cosmo, M.Asai - November 1996 28 // Authors: G.Cosmo, M.Asai - November 1996
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4StateManager.hh" 31 #include "G4StateManager.hh"
32 #include "G4ios.hh" 32 #include "G4ios.hh"
33 33
34 // Initialization of the static pointer of the 34 // Initialization of the static pointer of the single class instance
35 // 35 //
36 G4ThreadLocal G4StateManager* G4StateManager:: 36 G4ThreadLocal G4StateManager* G4StateManager::theStateManager = nullptr;
37 G4int G4StateManager::verboseLevel 37 G4int G4StateManager::verboseLevel = 0;
38 38
39 // ------------------------------------------- 39 // --------------------------------------------------------------------
40 G4StateManager::G4StateManager() 40 G4StateManager::G4StateManager()
41 { 41 {
42 #ifdef G4MULTITHREADED 42 #ifdef G4MULTITHREADED
43 G4iosInitialization(); 43 G4iosInitialization();
44 #endif 44 #endif
45 } 45 }
46 46
47 G4StateManager::~G4StateManager() 47 G4StateManager::~G4StateManager()
48 { 48 {
49 G4VStateDependent* state = nullptr; 49 G4VStateDependent* state = nullptr;
50 50
51 while(!theDependentsList.empty()) 51 while(!theDependentsList.empty())
52 { 52 {
53 state = theDependentsList.back(); 53 state = theDependentsList.back();
54 theDependentsList.pop_back(); 54 theDependentsList.pop_back();
55 for(auto i = theDependentsList.cbegin(); i 55 for(auto i = theDependentsList.cbegin(); i != theDependentsList.cend();)
56 { 56 {
57 if(*i == state) 57 if(*i == state)
58 { 58 {
59 i = theDependentsList.erase(i); 59 i = theDependentsList.erase(i);
60 } 60 }
61 else 61 else
62 { 62 {
63 ++i; 63 ++i;
64 } 64 }
65 } 65 }
66 delete state; 66 delete state;
67 } 67 }
68 theStateManager = nullptr; 68 theStateManager = nullptr;
69 #ifdef G4MULTITHREADED_DEACTIVATE 69 #ifdef G4MULTITHREADED_DEACTIVATE
70 G4iosFinalization(); 70 G4iosFinalization();
71 #endif 71 #endif
72 } 72 }
73 73
74 // ------------------------------------------- 74 // --------------------------------------------------------------------
75 G4StateManager* G4StateManager::GetStateManage 75 G4StateManager* G4StateManager::GetStateManager()
76 { 76 {
77 if(theStateManager == nullptr) 77 if(theStateManager == nullptr)
78 { 78 {
79 theStateManager = new G4StateManager; 79 theStateManager = new G4StateManager;
80 } 80 }
81 return theStateManager; 81 return theStateManager;
82 } 82 }
83 83
84 // ------------------------------------------- 84 // --------------------------------------------------------------------
85 G4bool G4StateManager::RegisterDependent(G4VSt 85 G4bool G4StateManager::RegisterDependent(G4VStateDependent* aDependent,
86 G4boo 86 G4bool bottom)
87 { 87 {
88 G4bool ack = true; 88 G4bool ack = true;
89 if(!bottom) 89 if(!bottom)
90 { 90 {
91 theDependentsList.push_back(aDependent); 91 theDependentsList.push_back(aDependent);
92 } 92 }
93 else 93 else
94 { 94 {
95 if(theBottomDependent != nullptr) 95 if(theBottomDependent != nullptr)
96 { 96 {
97 theDependentsList.push_back(theBottomDep 97 theDependentsList.push_back(theBottomDependent);
98 } 98 }
99 theBottomDependent = aDependent; 99 theBottomDependent = aDependent;
100 } 100 }
101 return ack; 101 return ack;
102 } 102 }
103 103
104 // ------------------------------------------- 104 // --------------------------------------------------------------------
105 G4bool G4StateManager::DeregisterDependent(G4V 105 G4bool G4StateManager::DeregisterDependent(G4VStateDependent* aDependent)
106 { 106 {
107 G4VStateDependent* tmp = nullptr; 107 G4VStateDependent* tmp = nullptr;
108 for(auto i = theDependentsList.cbegin(); i ! 108 for(auto i = theDependentsList.cbegin(); i != theDependentsList.cend();)
109 { 109 {
110 if(**i == *aDependent) 110 if(**i == *aDependent)
111 { 111 {
112 tmp = *i; 112 tmp = *i;
113 i = theDependentsList.erase(i); 113 i = theDependentsList.erase(i);
114 } 114 }
115 else 115 else
116 { 116 {
117 ++i; 117 ++i;
118 } 118 }
119 } 119 }
120 return (tmp != nullptr); 120 return (tmp != nullptr);
121 } 121 }
122 122
123 // ------------------------------------------- 123 // --------------------------------------------------------------------
124 const G4ApplicationState& G4StateManager::GetC 124 const G4ApplicationState& G4StateManager::GetCurrentState() const
125 { 125 {
126 return theCurrentState; 126 return theCurrentState;
127 } 127 }
128 128
129 // ------------------------------------------- 129 // --------------------------------------------------------------------
130 const G4ApplicationState& G4StateManager::GetP 130 const G4ApplicationState& G4StateManager::GetPreviousState() const
131 { 131 {
132 return thePreviousState; 132 return thePreviousState;
133 } 133 }
134 134
135 // ------------------------------------------- 135 // --------------------------------------------------------------------
136 G4bool G4StateManager::SetNewState(const G4App 136 G4bool G4StateManager::SetNewState(const G4ApplicationState& requestedState)
137 { 137 {
138 return SetNewState(requestedState, nullptr); 138 return SetNewState(requestedState, nullptr);
139 } 139 }
140 140
141 // ------------------------------------------- 141 // --------------------------------------------------------------------
142 G4bool G4StateManager::SetNewState(const G4App 142 G4bool G4StateManager::SetNewState(const G4ApplicationState& requestedState,
143 const char* 143 const char* msg)
144 { 144 {
145 if(requestedState == G4State_Abort && suppre 145 if(requestedState == G4State_Abort && suppressAbortion > 0)
146 { 146 {
147 if(suppressAbortion == 2) 147 if(suppressAbortion == 2)
148 { 148 {
149 return false; 149 return false;
150 } 150 }
151 if(theCurrentState == G4State_EventProc) 151 if(theCurrentState == G4State_EventProc)
152 { 152 {
153 return false; 153 return false;
154 } 154 }
155 } 155 }
156 msgptr = msg; 156 msgptr = msg;
157 std::size_t i = 0; 157 std::size_t i = 0;
158 G4bool ack = true; 158 G4bool ack = true;
159 G4ApplicationState savedState = thePreviousS 159 G4ApplicationState savedState = thePreviousState;
160 thePreviousState = theCurrentSt 160 thePreviousState = theCurrentState;
161 161
162 while((ack) && (i < theDependentsList.size() 162 while((ack) && (i < theDependentsList.size()))
163 { 163 {
164 ack = theDependentsList[i]->Notify(request 164 ack = theDependentsList[i]->Notify(requestedState);
165 ++i; 165 ++i;
166 } 166 }
167 if(theBottomDependent != nullptr) 167 if(theBottomDependent != nullptr)
168 { 168 {
169 ack = theBottomDependent->Notify(requested 169 ack = theBottomDependent->Notify(requestedState);
170 } 170 }
171 171
172 if(!ack) 172 if(!ack)
173 { 173 {
174 thePreviousState = savedState; 174 thePreviousState = savedState;
175 } 175 }
176 else 176 else
177 { 177 {
178 theCurrentState = requestedState; 178 theCurrentState = requestedState;
179 if(verboseLevel > 0) 179 if(verboseLevel > 0)
180 { 180 {
181 G4cout << "#### G4StateManager::SetNewSt 181 G4cout << "#### G4StateManager::SetNewState from "
182 << GetStateString(thePreviousStat 182 << GetStateString(thePreviousState) << " to "
183 << GetStateString(requestedState) 183 << GetStateString(requestedState) << G4endl;
184 } 184 }
185 } 185 }
186 msgptr = nullptr; 186 msgptr = nullptr;
187 return ack; 187 return ack;
188 } 188 }
189 189
190 // ------------------------------------------- 190 // --------------------------------------------------------------------
191 G4VStateDependent* G4StateManager::RemoveDepen 191 G4VStateDependent* G4StateManager::RemoveDependent(
192 const G4VStateDependent* aDependent) 192 const G4VStateDependent* aDependent)
193 { 193 {
194 G4VStateDependent* tmp = nullptr; 194 G4VStateDependent* tmp = nullptr;
195 for(auto i = theDependentsList.cbegin(); i ! 195 for(auto i = theDependentsList.cbegin(); i != theDependentsList.cend();)
196 { 196 {
197 if(**i == *aDependent) 197 if(**i == *aDependent)
198 { 198 {
199 tmp = *i; 199 tmp = *i;
200 i = theDependentsList.erase(i); 200 i = theDependentsList.erase(i);
201 } 201 }
202 else 202 else
203 { 203 {
204 ++i; 204 ++i;
205 } 205 }
206 } 206 }
207 return tmp; 207 return tmp;
208 } 208 }
209 209
210 // ------------------------------------------- 210 // --------------------------------------------------------------------
211 G4String G4StateManager::GetStateString(const 211 G4String G4StateManager::GetStateString(const G4ApplicationState& aState) const
212 { 212 {
213 G4String stateName; 213 G4String stateName;
214 switch(aState) 214 switch(aState)
215 { 215 {
216 case G4State_PreInit: 216 case G4State_PreInit:
217 stateName = "PreInit"; 217 stateName = "PreInit";
218 break; 218 break;
219 case G4State_Init: 219 case G4State_Init:
220 stateName = "Init"; 220 stateName = "Init";
221 break; 221 break;
222 case G4State_Idle: 222 case G4State_Idle:
223 stateName = "Idle"; 223 stateName = "Idle";
224 break; 224 break;
225 case G4State_GeomClosed: 225 case G4State_GeomClosed:
226 stateName = "GeomClosed"; 226 stateName = "GeomClosed";
227 break; 227 break;
228 case G4State_EventProc: 228 case G4State_EventProc:
229 stateName = "EventProc"; 229 stateName = "EventProc";
230 break; 230 break;
231 case G4State_Quit: 231 case G4State_Quit:
232 stateName = "Quit"; 232 stateName = "Quit";
233 break; 233 break;
234 case G4State_Abort: 234 case G4State_Abort:
235 stateName = "Abort"; 235 stateName = "Abort";
236 break; 236 break;
237 default: 237 default:
238 stateName = "Unknown"; 238 stateName = "Unknown";
239 break; 239 break;
240 } 240 }
241 return stateName; 241 return stateName;
242 } 242 }
243 243
244 // ------------------------------------------- 244 // --------------------------------------------------------------------
245 void G4StateManager::SetVerboseLevel(G4int val 245 void G4StateManager::SetVerboseLevel(G4int val) { verboseLevel = val; }
246 <<
247 // ------------------------------------------- <<
248 void G4StateManager::NotifyDeletion(const G4Ev <<
249 { <<
250 for(auto& d : theDependentsList) <<
251 { d->NotifyDeletion(evt); } <<
252 } <<
253 <<
254 // ------------------------------------------- <<
255 void G4StateManager::NotifyDeletion(const G4Ru <<
256 { <<
257 for(auto& d : theDependentsList) <<
258 { d->NotifyDeletion(rn); } <<
259 } <<
260 246