Geant4-11
G4StateManager.cc
Go to the documentation of this file.
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//
38
39// --------------------------------------------------------------------
41{
42#ifdef G4MULTITHREADED
44#endif
45}
46
48{
49 G4VStateDependent* state = nullptr;
50
51 while(theDependentsList.size() > 0)
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
71#endif
72}
73
74// --------------------------------------------------------------------
76{
77 if(theStateManager == nullptr)
78 {
80 }
81 return theStateManager;
82}
83
84// --------------------------------------------------------------------
86 G4bool bottom)
87{
88 G4bool ack = true;
89 if(!bottom)
90 {
91 theDependentsList.push_back(aDependent);
92 }
93 else
94 {
96 {
98 }
99 theBottomDependent = aDependent;
100 }
101 return ack;
102}
103
104// --------------------------------------------------------------------
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// --------------------------------------------------------------------
125{
126 return theCurrentState;
127}
128
129// --------------------------------------------------------------------
131{
132 return thePreviousState;
133}
134
135// --------------------------------------------------------------------
137{
138 return SetNewState(requestedState, nullptr);
139}
140
141// --------------------------------------------------------------------
143 const char* msg)
144{
145 if(requestedState == G4State_Abort && suppressAbortion > 0)
146 {
147 if(suppressAbortion == 2)
148 {
149 return false;
150 }
152 {
153 return false;
154 }
155 }
156 msgptr = msg;
157 std::size_t i = 0;
158 G4bool ack = true;
161
162 while((ack) && (i < theDependentsList.size()))
163 {
164 ack = theDependentsList[i]->Notify(requestedState);
165 ++i;
166 }
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// --------------------------------------------------------------------
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// --------------------------------------------------------------------
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;
226 stateName = "GeomClosed";
227 break;
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// --------------------------------------------------------------------
G4ApplicationState
@ G4State_EventProc
@ G4State_Init
@ G4State_Idle
@ G4State_Quit
@ G4State_Abort
@ G4State_GeomClosed
@ G4State_PreInit
bool G4bool
Definition: G4Types.hh:86
int G4int
Definition: G4Types.hh:85
void G4iosFinalization()
Definition: G4ios.cc:112
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
void G4iosInitialization()
Definition: G4ios.cc:111
const G4ApplicationState & GetCurrentState() const
const char * msgptr
G4VStateDependent * RemoveDependent(const G4VStateDependent *aDependent)
G4String GetStateString(const G4ApplicationState &aState) const
G4bool RegisterDependent(G4VStateDependent *aDependent, G4bool bottom=false)
G4ApplicationState theCurrentState
G4ApplicationState thePreviousState
static G4StateManager * GetStateManager()
static G4int verboseLevel
static void SetVerboseLevel(G4int val)
static G4ThreadLocal G4StateManager * theStateManager
G4VStateDependent * theBottomDependent
std::vector< G4VStateDependent * > theDependentsList
G4bool SetNewState(const G4ApplicationState &requestedState)
G4bool DeregisterDependent(G4VStateDependent *aDependent)
const G4ApplicationState & GetPreviousState() const
virtual G4bool Notify(G4ApplicationState requestedState)=0
#define G4ThreadLocal
Definition: tls.hh:77