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