| 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 // G4GenericMessenger <<
27 // 26 //
28 // Class description: <<
29 // 27 //
30 // A generic messenger class. <<
31 28
32 // Author: P.Mato, CERN - 27 September 2012 << 29 #ifndef G4GenericMessenger_h
33 // ------------------------------------------- << 30 #define G4GenericMessenger_h 1
34 #ifndef G4GenericMessenger_hh <<
35 #define G4GenericMessenger_hh 1 <<
36 31
37 #include "G4AnyMethod.hh" << 32 #include "G4UImessenger.hh"
>> 33 #include "G4UIcommand.hh"
38 #include "G4AnyType.hh" 34 #include "G4AnyType.hh"
>> 35 #include "G4AnyMethod.hh"
39 #include "G4ApplicationState.hh" 36 #include "G4ApplicationState.hh"
40 #include "G4UIcommand.hh" <<
41 #include "G4UImessenger.hh" <<
42 37
43 #include <map> 38 #include <map>
44 #include <vector> 39 #include <vector>
45 40
46 class G4UIdirectory; 41 class G4UIdirectory;
47 42
>> 43 /// This class is generic messenger.
>> 44
48 class G4GenericMessenger : public G4UImessenge 45 class G4GenericMessenger : public G4UImessenger
49 { 46 {
50 public: << 47 public:
51 // Contructor << 48 /// Contructor
52 G4GenericMessenger(void* obj, const G4Stri << 49 G4GenericMessenger(void* obj, const G4String& dir = "", const G4String& doc = "");
53 << 50 /// Destructor
54 // Destructor << 51 virtual ~G4GenericMessenger();
55 ~G4GenericMessenger() override; << 52 /// The concrete, but generic implementation of this method.
56 << 53 virtual G4String GetCurrentValue(G4UIcommand* command);
57 // The concrete, but generic implementatio << 54 /// The concrete, generic implementation of this method converts the string "newValue" to action.
58 G4String GetCurrentValue(G4UIcommand* comm << 55 virtual void SetNewValue(G4UIcommand* command, G4String newValue);
59 << 56
60 // The concrete, generic implementation o << 57 public:
61 // the string "newValue" to action. << 58 struct Command {
62 void SetNewValue(G4UIcommand* command, G4S << 59 enum UnitSpec {UnitCategory, UnitDefault};
63 << 60 Command(G4UIcommand* cmd, const std::type_info& ti) : command(cmd), type(&ti) {}
64 public: << 61 Command() : command(0), type(0) {}
65 struct Command << 62 // Command& operator =(const Command& rhs) { command = rhs.command; type = rhs.type; }
66 { << 63 Command& SetStates(G4ApplicationState s0) {command->AvailableForStates(s0); return *this;}
67 enum UnitSpec << 64 Command& SetStates(G4ApplicationState s0, G4ApplicationState s1) {command->AvailableForStates(s0, s1); return *this;}
68 { << 65 Command& SetStates(G4ApplicationState s0, G4ApplicationState s1, G4ApplicationState s2){command->AvailableForStates(s0,s1,s2); return *this;}
69 UnitCategory, << 66 Command& SetStates(G4ApplicationState s0, G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3) {command->AvailableForStates(s0,s1,s2,s3); return *this;}
70 UnitDefault << 67 Command& SetStates(G4ApplicationState s0, G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3, G4ApplicationState s4) {command->AvailableForStates(s0,s1,s2,s3,s4); return *this;}
71 }; << 68 Command& SetRange(const G4String& range) {command->SetRange(range.c_str()); return *this;}
72 Command(G4UIcommand* cmd, const std::t << 69 Command& SetGuidance(const G4String& s0) { command->SetGuidance(s0); return *this; }
73 Command() = default; << 70 Command& SetUnit(const G4String&, UnitSpec = UnitDefault);
74 << 71 Command& SetUnitCategory(const G4String& u) {return SetUnit(u, UnitCategory);}
75 Command& SetStates(G4ApplicationState << 72 Command& SetDefaultUnit(const G4String& u) {return SetUnit(u, UnitDefault);}
76 { << 73 Command& SetParameterName(const G4String&, G4bool, G4bool =false);
77 command->AvailableForStates(s0); << 74 Command& SetDefaultValue(const G4String&);
78 return *this; << 75 Command& SetCandidates(const G4String&);
79 } << 76 Command& SetToBeBroadcasted(G4bool s0) { command->SetToBeBroadcasted(s0); return *this; }
80 Command& SetStates(G4ApplicationState << 77 Command& SetToBeFlushed(G4bool s0) { command->SetToBeFlushed(s0); return *this; }
81 { << 78 Command& SetWorkerThreadOnly(G4bool s0) { command->SetWorkerThreadOnly(s0); return *this; }
82 command->AvailableForStates(s0, s1); << 79
83 return *this; << 80 G4UIcommand* command;
84 } << 81 const std::type_info* type;
85 Command& SetStates(G4ApplicationState << 82 };
86 { << 83 struct Property : public Command {
87 command->AvailableForStates(s0, s1, << 84 Property(const G4AnyType& var, G4UIcommand* cmd) : Command(cmd, var.TypeInfo()) , variable(var) {}
88 return *this; << 85 Property() {}
89 } << 86 G4AnyType variable;
90 Command& SetStates(G4ApplicationState << 87 };
91 G4ApplicationState << 88 struct Method : public Command {
92 { << 89 Method(const G4AnyMethod& fun, void* obj, G4UIcommand* cmd) : Command(cmd, fun.ArgType()), method(fun), object(obj) {}
93 command->AvailableForStates(s0, s1, << 90 Method() : object(0) {}
94 return *this; << 91 G4AnyMethod method;
95 } << 92 void* object;
96 Command& SetStates(G4ApplicationState << 93 };
97 G4ApplicationState << 94
98 { << 95 ///Declare Methods
99 command->AvailableForStates(s0, s1, << 96 Command& DeclareProperty(const G4String& name, const G4AnyType& variable, const G4String& doc = "");
100 return *this; << 97 Command& DeclarePropertyWithUnit
101 } << 98 (const G4String& name, const G4String& defaultUnit, const G4AnyType& variable, const G4String& doc = "");
102 Command& SetRange(const G4String& rang << 99 Command& DeclareMethod(const G4String& name, const G4AnyMethod& fun, const G4String& doc = "");
103 { << 100 Command& DeclareMethodWithUnit
104 command->SetRange(range.c_str()); << 101 (const G4String& name, const G4String& defaultUnit, const G4AnyMethod& fun, const G4String& doc = "");
105 return *this; << 102 void SetDirectory(const G4String& dir) {directory = dir;}
106 } << 103 void SetGuidance(const G4String& s);
107 Command& SetGuidance(const G4String& s << 104
108 { << 105 private:
109 command->SetGuidance(s0); << 106 std::map<G4String, Property> properties;
110 return *this; << 107 std::map<G4String, Method> methods;
111 } << 108 G4UIdirectory* dircmd;
112 Command& SetUnit(const G4String&, Unit << 109 G4String directory;
113 Command& SetUnitCategory(const G4Strin << 110 void* object;
114 Command& SetDefaultUnit(const G4String <<
115 Command& SetParameterName(const G4Stri <<
116 Command& SetParameterName(G4int pIdx, <<
117 Command& SetParameterName(const G4Stri <<
118 G4bool = fal <<
119 Command& SetDefaultValue(const G4Strin <<
120 Command& SetDefaultValue(G4int pIdx, c <<
121 Command& SetCandidates(const G4String& <<
122 Command& SetCandidates(G4int pIdx, con <<
123 Command& SetToBeBroadcasted(G4bool s0) <<
124 { <<
125 command->SetToBeBroadcasted(s0); <<
126 return *this; <<
127 } <<
128 Command& SetToBeFlushed(G4bool s0) <<
129 { <<
130 command->SetToBeFlushed(s0); <<
131 return *this; <<
132 } <<
133 Command& SetWorkerThreadOnly(G4bool s0 <<
134 { <<
135 command->SetWorkerThreadOnly(s0); <<
136 return *this; <<
137 } <<
138 <<
139 G4UIcommand* command = nullptr; <<
140 const std::type_info* type = nullptr; <<
141 }; <<
142 <<
143 struct Property : public Command <<
144 { <<
145 Property(const G4AnyType& var, G4UIcom <<
146 : Command(cmd, var.TypeInfo()), vari <<
147 {} <<
148 Property() = default; <<
149 G4AnyType variable; <<
150 }; <<
151 <<
152 struct Method : public Command <<
153 { <<
154 Method(const G4AnyMethod& fun, void* o <<
155 : Command(cmd, fun.ArgType()), metho <<
156 {} <<
157 Method() = default; <<
158 G4AnyMethod method; <<
159 void* object = nullptr; <<
160 }; <<
161 <<
162 // Declare Methods <<
163 <<
164 Command& DeclareProperty(const G4String& n <<
165 const G4String& d <<
166 Command& DeclarePropertyWithUnit(const G4S <<
167 const G4A <<
168 Command& DeclareMethod(const G4String& nam <<
169 Command& DeclareMethodWithUnit(const G4Str <<
170 const G4Any <<
171 void SetDirectory(const G4String& dir) { d <<
172 void SetGuidance(const G4String& s); <<
173 void Sort(G4bool val = true) <<
174 { <<
175 if (dircmd != nullptr) { <<
176 dircmd->Sort(val); <<
177 } <<
178 } <<
179 <<
180 private: <<
181 std::map<G4String, Property> properties; <<
182 std::map<G4String, Method> methods; <<
183 G4UIdirectory* dircmd = nullptr; <<
184 G4String directory; <<
185 void* object = nullptr; <<
186 }; 111 };
187 112
>> 113
188 #endif 114 #endif
>> 115
189 116