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