| 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 <<
27 // 26 //
28 // Authors: G.Cosmo, M.Asai - November 1996 << 27 // $Id: G4StateManager.cc,v 1.15 2010-10-01 16:36:31 gcosmo Exp $
29 // ------------------------------------------- << 28 // GEANT4 tag $Name: not supported by cvs2svn $
>> 29 //
>> 30 //
>> 31 // ------------------------------------------------------------
>> 32 // GEANT 4 class implementation file
>> 33 //
>> 34 // ---------------- G4StateManager ----------------
>> 35 // by Gabriele Cosmo, November 1996
>> 36 // ------------------------------------------------------------
30 37
31 #include "G4StateManager.hh" 38 #include "G4StateManager.hh"
32 #include "G4ios.hh" <<
33 39
34 // Initialization of the static pointer of the 40 // Initialization of the static pointer of the single class instance
35 // 41 //
36 G4ThreadLocal G4StateManager* G4StateManager:: << 42 G4StateManager* G4StateManager::theStateManager = 0;
37 G4int G4StateManager::verboseLevel <<
38 43
39 // ------------------------------------------- <<
40 G4StateManager::G4StateManager() 44 G4StateManager::G4StateManager()
>> 45 : theCurrentState(G4State_PreInit),
>> 46 thePreviousState(G4State_PreInit),
>> 47 theBottomDependent(0),
>> 48 suppressAbortion(0),
>> 49 msgptr(0),
>> 50 exceptionHandler(0)
41 { 51 {
42 #ifdef G4MULTITHREADED <<
43 G4iosInitialization(); <<
44 #endif <<
45 } 52 }
46 53
47 G4StateManager::~G4StateManager() 54 G4StateManager::~G4StateManager()
48 { 55 {
49 G4VStateDependent* state = nullptr; << 56 G4VStateDependent* state=0;
50 57
51 while(!theDependentsList.empty()) << 58 while (theDependentsList.size()>0)
52 { 59 {
53 state = theDependentsList.back(); 60 state = theDependentsList.back();
54 theDependentsList.pop_back(); 61 theDependentsList.pop_back();
55 for(auto i = theDependentsList.cbegin(); i << 62 for (std::vector<G4VStateDependent*>::iterator
>> 63 i=theDependentsList.begin(); i!=theDependentsList.end();)
56 { 64 {
57 if(*i == state) << 65 if (*i==state)
58 { 66 {
59 i = theDependentsList.erase(i); 67 i = theDependentsList.erase(i);
60 } 68 }
61 else 69 else
62 { 70 {
63 ++i; 71 ++i;
64 } 72 }
65 } << 73 }
66 delete state; << 74 if ( state ) { delete state; }
67 } << 75 }
68 theStateManager = nullptr; <<
69 #ifdef G4MULTITHREADED_DEACTIVATE <<
70 G4iosFinalization(); <<
71 #endif <<
72 } 76 }
73 77
74 // ------------------------------------------- << 78 // -------------------------------------------------------------------------
75 G4StateManager* G4StateManager::GetStateManage << 79 // No matter how copy-constructor and operators below are implemented ...
>> 80 // just dummy implementations, since not relevant for the singleton and
>> 81 // declared private.
>> 82 //
>> 83 G4StateManager::G4StateManager(const G4StateManager &right)
>> 84 : theCurrentState(right.theCurrentState),
>> 85 thePreviousState(right.thePreviousState),
>> 86 theDependentsList(right.theDependentsList),
>> 87 theBottomDependent(right.theBottomDependent),
>> 88 suppressAbortion(right.suppressAbortion),
>> 89 msgptr(right.msgptr),
>> 90 exceptionHandler(right.exceptionHandler)
76 { 91 {
77 if(theStateManager == nullptr) <<
78 { <<
79 theStateManager = new G4StateManager; <<
80 } <<
81 return theStateManager; <<
82 } 92 }
83 93
84 // ------------------------------------------- << 94 G4StateManager&
85 G4bool G4StateManager::RegisterDependent(G4VSt << 95 G4StateManager::operator=(const G4StateManager &right)
86 G4boo <<
87 { 96 {
88 G4bool ack = true; << 97 if (&right == this) { return *this; }
89 if(!bottom) << 98
90 { << 99 theCurrentState = right.theCurrentState;
91 theDependentsList.push_back(aDependent); << 100 thePreviousState = right.thePreviousState;
92 } << 101 theDependentsList = right.theDependentsList;
93 else << 102 theBottomDependent = right.theBottomDependent;
94 { << 103 suppressAbortion = right.suppressAbortion;
95 if(theBottomDependent != nullptr) << 104 msgptr = right.msgptr;
>> 105 exceptionHandler = right.exceptionHandler;
>> 106
>> 107 return *this;
>> 108 }
>> 109
>> 110 G4int
>> 111 G4StateManager::operator==(const G4StateManager &right) const
>> 112 {
>> 113 return (this == &right);
>> 114 }
>> 115
>> 116 G4int
>> 117 G4StateManager::operator!=(const G4StateManager &right) const
>> 118 {
>> 119 return (this != &right);
>> 120 }
>> 121 //
>> 122 // -------------------------------------------------------------------------
>> 123
>> 124 G4StateManager*
>> 125 G4StateManager::GetStateManager()
>> 126 {
>> 127 if (!theStateManager)
96 { 128 {
97 theDependentsList.push_back(theBottomDep << 129 theStateManager = new G4StateManager;
98 } 130 }
99 theBottomDependent = aDependent; << 131 return theStateManager;
100 } <<
101 return ack; <<
102 } 132 }
103 133
104 // ------------------------------------------- << 134 G4bool
105 G4bool G4StateManager::DeregisterDependent(G4V << 135 G4StateManager::RegisterDependent(G4VStateDependent* aDependent, G4bool bottom)
106 { 136 {
107 G4VStateDependent* tmp = nullptr; << 137 G4bool ack=true;
108 for(auto i = theDependentsList.cbegin(); i ! << 138 if(!bottom)
>> 139 {
>> 140 theDependentsList.push_back(aDependent);
>> 141 }
>> 142 else
>> 143 {
>> 144 if(theBottomDependent)
>> 145 {
>> 146 theDependentsList.push_back(theBottomDependent);
>> 147 }
>> 148 theBottomDependent = aDependent;
>> 149 }
>> 150 return ack;
>> 151 }
>> 152
>> 153 G4bool
>> 154 G4StateManager::DeregisterDependent(G4VStateDependent* aDependent)
>> 155 {
>> 156 G4VStateDependent* tmp = 0;
>> 157 for (std::vector<G4VStateDependent*>::iterator i=theDependentsList.begin();
>> 158 i!=theDependentsList.end();)
109 { 159 {
110 if(**i == *aDependent) << 160 if (**i==*aDependent)
111 { 161 {
112 tmp = *i; 162 tmp = *i;
113 i = theDependentsList.erase(i); << 163 i = theDependentsList.erase(i);
114 } 164 }
115 else 165 else
116 { 166 {
117 ++i; 167 ++i;
118 } 168 }
119 } 169 }
120 return (tmp != nullptr); << 170 return (tmp != 0);
121 } 171 }
122 172
123 // ------------------------------------------- << 173 G4ApplicationState
124 const G4ApplicationState& G4StateManager::GetC << 174 G4StateManager::GetCurrentState() const
125 { 175 {
126 return theCurrentState; << 176 return theCurrentState;
127 } 177 }
128 178
129 // ------------------------------------------- << 179 G4ApplicationState
130 const G4ApplicationState& G4StateManager::GetP << 180 G4StateManager::GetPreviousState() const
131 { 181 {
132 return thePreviousState; << 182 return thePreviousState;
133 } 183 }
134 184
135 // ------------------------------------------- << 185 G4bool
136 G4bool G4StateManager::SetNewState(const G4App << 186 G4StateManager::SetNewState(G4ApplicationState requestedState)
137 { << 187 { return SetNewState(requestedState,0); }
138 return SetNewState(requestedState, nullptr); <<
139 } <<
140 188
141 // ------------------------------------------- << 189 G4bool
142 G4bool G4StateManager::SetNewState(const G4App << 190 G4StateManager::SetNewState(G4ApplicationState requestedState, const char* msg)
143 const char* <<
144 { 191 {
145 if(requestedState == G4State_Abort && suppre << 192 if(requestedState==G4State_Abort && suppressAbortion>0)
146 { << 193 {
147 if(suppressAbortion == 2) << 194 if(suppressAbortion==2) { return false; }
148 { << 195 if(theCurrentState==G4State_EventProc) { return false; }
149 return false; << 196 }
150 } << 197 msgptr = msg;
151 if(theCurrentState == G4State_EventProc) << 198 size_t i=0;
152 { << 199 G4bool ack = true;
153 return false; << 200 G4ApplicationState savedState = thePreviousState;
154 } << 201 thePreviousState = theCurrentState;
155 } << 202 while ((ack) && (i<theDependentsList.size()))
156 msgptr = msg; << 203 {
157 std::size_t i = 0; << 204 ack = theDependentsList[i]->Notify(requestedState);
158 G4bool ack = true; << 205 i++;
159 G4ApplicationState savedState = thePreviousS << 206 }
160 thePreviousState = theCurrentSt << 207 if(theBottomDependent)
161 << 208 {
162 while((ack) && (i < theDependentsList.size() << 209 ack = theBottomDependent->Notify(requestedState);
163 { << 210 }
164 ack = theDependentsList[i]->Notify(request <<
165 ++i; <<
166 } <<
167 if(theBottomDependent != nullptr) <<
168 { <<
169 ack = theBottomDependent->Notify(requested <<
170 } <<
171 211
172 if(!ack) << 212 if(!ack)
173 { << 213 { thePreviousState = savedState; }
174 thePreviousState = savedState; << 214 else
175 } << 215 { theCurrentState = requestedState; }
176 else << 216 msgptr = 0;
177 { << 217 return ack;
178 theCurrentState = requestedState; <<
179 if(verboseLevel > 0) <<
180 { <<
181 G4cout << "#### G4StateManager::SetNewSt <<
182 << GetStateString(thePreviousStat <<
183 << GetStateString(requestedState) <<
184 } <<
185 } <<
186 msgptr = nullptr; <<
187 return ack; <<
188 } 218 }
189 219
190 // ------------------------------------------- << 220 G4VStateDependent*
191 G4VStateDependent* G4StateManager::RemoveDepen << 221 G4StateManager::RemoveDependent(const G4VStateDependent* aDependent)
192 const G4VStateDependent* aDependent) <<
193 { 222 {
194 G4VStateDependent* tmp = nullptr; << 223 G4VStateDependent* tmp = 0;
195 for(auto i = theDependentsList.cbegin(); i ! << 224 for (std::vector<G4VStateDependent*>::iterator i=theDependentsList.begin();
>> 225 i!=theDependentsList.end();)
196 { 226 {
197 if(**i == *aDependent) << 227 if (**i==*aDependent)
198 { 228 {
199 tmp = *i; 229 tmp = *i;
200 i = theDependentsList.erase(i); << 230 i = theDependentsList.erase(i);
201 } 231 }
202 else 232 else
203 { 233 {
204 ++i; 234 ++i;
205 } 235 }
206 } 236 }
207 return tmp; 237 return tmp;
208 } 238 }
209 239
210 // ------------------------------------------- << 240 G4String
211 G4String G4StateManager::GetStateString(const << 241 G4StateManager::GetStateString(G4ApplicationState aState) const
212 { 242 {
213 G4String stateName; 243 G4String stateName;
214 switch(aState) 244 switch(aState)
215 { 245 {
216 case G4State_PreInit: 246 case G4State_PreInit:
217 stateName = "PreInit"; << 247 stateName = "PreInit"; break;
218 break; <<
219 case G4State_Init: 248 case G4State_Init:
220 stateName = "Init"; << 249 stateName = "Init"; break;
221 break; <<
222 case G4State_Idle: 250 case G4State_Idle:
223 stateName = "Idle"; << 251 stateName = "Idle"; break;
224 break; <<
225 case G4State_GeomClosed: 252 case G4State_GeomClosed:
226 stateName = "GeomClosed"; << 253 stateName = "GeomClosed"; break;
227 break; <<
228 case G4State_EventProc: 254 case G4State_EventProc:
229 stateName = "EventProc"; << 255 stateName = "EventProc"; break;
230 break; <<
231 case G4State_Quit: 256 case G4State_Quit:
232 stateName = "Quit"; << 257 stateName = "Quit"; break;
233 break; <<
234 case G4State_Abort: 258 case G4State_Abort:
235 stateName = "Abort"; << 259 stateName = "Abort"; break;
236 break; <<
237 default: 260 default:
238 stateName = "Unknown"; << 261 stateName = "Unknown"; break;
239 break; <<
240 } 262 }
241 return stateName; 263 return stateName;
242 } 264 }
243 265
244 // ------------------------------------------- << 266 //void G4StateManager::Pause()
245 void G4StateManager::SetVerboseLevel(G4int val << 267 //{
246 << 268 // Pause("G4_pause> ");
247 // ------------------------------------------- << 269 //}
248 void G4StateManager::NotifyDeletion(const G4Ev << 270 //
249 { << 271 //void G4StateManager::Pause(const char* msg)
250 for(auto& d : theDependentsList) << 272 //{
251 { d->NotifyDeletion(evt); } << 273 // G4String msgS = msg;
252 } << 274 // Pause(msgS);
253 << 275 //}
254 // ------------------------------------------- << 276 //
255 void G4StateManager::NotifyDeletion(const G4Ru << 277 //void G4StateManager::Pause(G4String msg)
256 { << 278 //{
257 for(auto& d : theDependentsList) << 279 // G4UImanager::GetUIpointer()->PauseSession(msg);
258 { d->NotifyDeletion(rn); } << 280 //}
259 } <<
260 281