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