Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Functions
G4UIparsing Namespace Reference

Functions

template<typename T>
T StoT (const G4String &s)
 
template<typename T>
G4String TtoS (T value)
 
G4bool ChkMax (const char *str, short maxDigits)
 
G4bool IsInt (const char *str, short maxDigits)
 
G4bool ExpectExponent (const char *str)
 
G4bool IsDouble (const char *str)
 
G4int CompareInt (G4int arg1, G4int op, G4int arg2, G4int &errCode)
 
G4int CompareLong (G4long arg1, G4int op, G4long arg2, G4int &errCode)
 
G4int CompareDouble (G4double arg1, G4int op, G4double arg2, G4int &errCode)
 
G4bool RangeCheck (const G4UIparameter &p, const char *value)
 
G4bool RangeCheck (const G4UIcommand &p, const char *value)
 

Function Documentation

◆ ChkMax()

G4bool G4UIparsing::ChkMax ( const char * str,
short maxDigits )
inline

Definition at line 63 of file G4UIparsing.hh.

64{
65 if(maxDigits > 10) {
66 // long int assumed
67 auto tmpval = std::stoll(str);
68 if(tmpval > LONG_MAX || tmpval < LONG_MIN) {
69 G4cerr << "input string '" << str << "' out-of-range for conversion to 'long int' value" << G4endl;
70 return false;
71 }
72 } else {
73 // int assumed
74 auto tmpval = std::stol(str);
75 if(tmpval > INT_MAX || tmpval < INT_MIN) {
76 G4cerr << "input string '" << str << "' out-of-range for conversion to 'int' value" << G4endl;
77 return false;
78 }
79 }
80 return true;
81}
G4cerr
G4GLOB_DLL std::ostream G4cerr
G4endl
#define G4endl
Definition G4ios.hh:67
INT_MIN
#define INT_MIN
Definition templates.hh:94
INT_MAX
#define INT_MAX
Definition templates.hh:90

Referenced by IsInt().

◆ CompareDouble()

G4int G4UIparsing::CompareDouble ( G4double arg1,
G4int op,
G4double arg2,
G4int & errCode )
inline

Definition at line 285 of file G4UIparsing.hh.

286{
287 G4int result = -1;
288 switch (op) {
289 case G4UItokenNum::GT:
290 result = static_cast<G4int>(arg1 > arg2);
291 break;
292 case G4UItokenNum::GE:
293 result = static_cast<G4int>(arg1 >= arg2);
294 break;
295 case G4UItokenNum::LT:
296 result = static_cast<G4int>(arg1 < arg2);
297 break;
298 case G4UItokenNum::LE:
299 result = static_cast<G4int>(arg1 <= arg2);
300 break;
301 case G4UItokenNum::EQ:
302 result = static_cast<G4int>(arg1 == arg2);
303 break;
304 case G4UItokenNum::NE:
305 result = static_cast<G4int>(arg1 != arg2);
306 break;
307 default:
308 G4cerr << "Parameter range: error at CompareDouble" << G4endl;
309 errCode = 1;
310 }
311 return result;
312}
G4int
int G4int
Definition G4Types.hh:85

◆ CompareInt()

G4int G4UIparsing::CompareInt ( G4int arg1,
G4int op,
G4int arg2,
G4int & errCode )
inline

Definition at line 225 of file G4UIparsing.hh.

226{
227 G4int result = -1;
228 switch (op) {
229 case G4UItokenNum::GT:
230 result = static_cast<G4int>(arg1 > arg2);
231 break;
232 case G4UItokenNum::GE:
233 result = static_cast<G4int>(arg1 >= arg2);
234 break;
235 case G4UItokenNum::LT:
236 result = static_cast<G4int>(arg1 < arg2);
237 break;
238 case G4UItokenNum::LE:
239 result = static_cast<G4int>(arg1 <= arg2);
240 break;
241 case G4UItokenNum::EQ:
242 result = static_cast<G4int>(arg1 == arg2);
243 break;
244 case G4UItokenNum::NE:
245 result = static_cast<G4int>(arg1 != arg2);
246 break;
247 default:
248 G4cerr << "Parameter range: error at CompareInt" << G4endl;
249 errCode = 1;
250 }
251 return result;
252}

◆ CompareLong()

G4int G4UIparsing::CompareLong ( G4long arg1,
G4int op,
G4long arg2,
G4int & errCode )
inline

Definition at line 255 of file G4UIparsing.hh.

256{
257 G4int result = -1;
258 switch (op) {
259 case G4UItokenNum::GT:
260 result = static_cast<G4int>(arg1 > arg2);
261 break;
262 case G4UItokenNum::GE:
263 result = static_cast<G4int>(arg1 >= arg2);
264 break;
265 case G4UItokenNum::LT:
266 result = static_cast<G4int>(arg1 < arg2);
267 break;
268 case G4UItokenNum::LE:
269 result = static_cast<G4int>(arg1 <= arg2);
270 break;
271 case G4UItokenNum::EQ:
272 result = static_cast<G4int>(arg1 == arg2);
273 break;
274 case G4UItokenNum::NE:
275 result = static_cast<G4int>(arg1 != arg2);
276 break;
277 default:
278 G4cerr << "Parameter range: error at CompareInt" << G4endl;
279 errCode = 1;
280 }
281 return result;
282}

◆ ExpectExponent()

G4bool G4UIparsing::ExpectExponent ( const char * str)
inline

Definition at line 110 of file G4UIparsing.hh.

111{
112 return IsInt(str, 7);
113}
G4UIparsing::IsInt
G4bool IsInt(const char *str, short maxDigits)
Definition G4UIparsing.hh:84

Referenced by IsDouble().

◆ IsDouble()

G4bool G4UIparsing::IsDouble ( const char * str)
inline

Definition at line 115 of file G4UIparsing.hh.

116{
117 const char* p = str;
118 switch (*p) {
119 case '+':
120 case '-':
121 ++p;
122 if (isdigit(*p) != 0) {
123 while (isdigit((G4int)(*p)) != 0) {
124 ++p;
125 }
126 switch (*p) {
127 case '\0':
128 return true; // break;
129 case 'E':
130 case 'e':
131 return ExpectExponent(++p); // break;
132 case '.':
133 ++p;
134 if (*p == '\0') {
135 return true;
136 }
137 if (*p == 'e' || *p == 'E') {
138 return ExpectExponent(++p);
139 }
140 if (isdigit(*p) != 0) {
141 while (isdigit((G4int)(*p)) != 0) {
142 ++p;
143 }
144 if (*p == '\0') {
145 return true;
146 }
147 if (*p == 'e' || *p == 'E') {
148 return ExpectExponent(++p);
149 }
150 }
151 else {
152 return false;
153 }
154 break;
155 default:
156 return false;
157 }
158 }
159 if (*p == '.') {
160 ++p;
161 if (isdigit(*p) != 0) {
162 while (isdigit((G4int)(*p)) != 0) {
163 ++p;
164 }
165 if (*p == '\0') {
166 return true;
167 }
168 if (*p == 'e' || *p == 'E') {
169 return ExpectExponent(++p);
170 }
171 }
172 }
173 break;
174 case '.':
175 ++p;
176 if (isdigit(*p) != 0) {
177 while (isdigit((G4int)(*p)) != 0) {
178 ++p;
179 }
180 if (*p == '\0') {
181 return true;
182 }
183 if (*p == 'e' || *p == 'E') {
184 return ExpectExponent(++p);
185 }
186 }
187 break;
188 default: // digit is expected
189 if (isdigit(*p) != 0) {
190 while (isdigit((G4int)(*p)) != 0) {
191 ++p;
192 }
193 if (*p == '\0') {
194 return true;
195 }
196 if (*p == 'e' || *p == 'E') {
197 return ExpectExponent(++p);
198 }
199 if (*p == '.') {
200 ++p;
201 if (*p == '\0') {
202 return true;
203 }
204 if (*p == 'e' || *p == 'E') {
205 return ExpectExponent(++p);
206 }
207 if (isdigit(*p) != 0) {
208 while (isdigit((G4int)(*p)) != 0) {
209 ++p;
210 }
211 if (*p == '\0') {
212 return true;
213 }
214 if (*p == 'e' || *p == 'E') {
215 return ExpectExponent(++p);
216 }
217 }
218 }
219 }
220 }
221 return false;
222}
G4UIparsing::ExpectExponent
G4bool ExpectExponent(const char *str)
Definition G4UIparsing.hh:110

◆ IsInt()

G4bool G4UIparsing::IsInt ( const char * str,
short maxDigits )
inline

Definition at line 84 of file G4UIparsing.hh.

85{
86 const char* p = str;
87 G4int length = 0;
88 if (*p == '+' || *p == '-') {
89 ++p;
90 }
91 if (isdigit((G4int)(*p)) != 0) {
92 while (isdigit((G4int)(*p)) != 0) {
93 ++p;
94 ++length;
95 }
96 if (*p == '\0') {
97 if (length > maxDigits) {
98 G4cerr << "digit length exceeds" << G4endl;
99 return false;
100 }
101 return ChkMax(str,maxDigits);
102 }
103 }
104 return false;
105}
G4UIparsing::ChkMax
G4bool ChkMax(const char *str, short maxDigits)
Definition G4UIparsing.hh:63

Referenced by ExpectExponent().

◆ RangeCheck() [1/2]

G4bool G4UIparsing::RangeCheck ( const G4UIcommand & p,
const char * value )

Definition at line 669 of file G4UIparsing.cc.

670{
671 G4UIRangeChecker r;
672 return r.DoCheck(p, value);
673}

◆ RangeCheck() [2/2]

G4bool G4UIparsing::RangeCheck ( const G4UIparameter & p,
const char * value )

Definition at line 663 of file G4UIparsing.cc.

664{
665 G4UIRangeChecker r;
666 return r.DoCheck(p, value);
667}

Referenced by G4UIcommand::CheckNewValue(), G4UIparameter::CheckNewValue(), RangeCheck(), and RangeCheck().

◆ StoT()

template<typename T>
T G4UIparsing::StoT ( const G4String & s)
inline

Definition at line 45 of file G4UIparsing.hh.

46{
47 T vl;
48 std::istringstream is(s);
49 is >> vl;
50 return vl;
51}

Referenced by G4UIcommand::ConvertToDouble(), G4UIcommand::ConvertToInt(), G4UIcommand::ConvertToLongInt(), G4UImessenger::StoD(), G4UImessenger::StoI(), and G4UImessenger::StoL().

◆ TtoS()

template<typename T>
G4String G4UIparsing::TtoS ( T value)
inline

Definition at line 55 of file G4UIparsing.hh.

56{
57 std::ostringstream os;
58 os << value;
59 return os.str();
60}

Referenced by G4UIcommand::ConvertToString(), G4UIcommand::ConvertToString(), G4UIparameter::SetDefaultValue(), G4UIparameter::SetDefaultValue(), and G4UIparameter::SetDefaultValue().