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