EnumClasses.h
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // (c) 2006 by Basler Vision Technologies
3 // Section: Vision Components
4 // Project: GenApi
5 // Author: Margret Albrecht
6 // $Header$
7 //
8 // License: This file is published under the license of the EMVA GenICam Standard Group.
9 // A text file describing the legal terms is included in your installation as 'GenICam_license.pdf'.
10 // If for some reason you are missing this file please contact the EMVA or visit the website
11 // (http://www.genicam.org) for a full copy.
12 //
13 // THIS SOFTWARE IS PROVIDED BY THE EMVA GENICAM STANDARD GROUP "AS IS"
14 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE EMVA GENICAM STANDARD GROUP
17 // OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
20 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
21 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
23 // POSSIBILITY OF SUCH DAMAGE.
24 //-----------------------------------------------------------------------------
30 #ifndef GENAPI_ENUMCLASSES_H
31 #define GENAPI_ENUMCLASSES_H
32 #include <GenApi/Types.h>
33 
34 namespace GENAPI_NAMESPACE
35 {
36  //*************************************************************
37  // Build in enummeration classes
38  //*************************************************************
39 
41 
43  {
44  public:
46  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ESign *pValue)
47  {
48  if (!pValue) return false;
49  if( ValueStr == "Signed" )
50  *pValue = Signed;
51  else if( ValueStr == "Unsigned" )
52  *pValue = Unsigned;
53  else
54  return false;
55  return true;
56  }
58  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ESign *pValue)
59  {
60 
61  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
62  if( *pValue == Signed )
63  ValueStr = "Signed";
64  else if( *pValue == Unsigned )
65  ValueStr = "Unsigned";
66  else
67  ValueStr = "_UndefinedSign";
68  }
69 
72  {
74  ToString(Result, &Value);
75  return Result;
76  }
77  };
78 
83  {
84  public:
86  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EEndianess *pValue)
87  {
88  if (!pValue) return false;
89  if( ValueStr == "BigEndian" )
90  *pValue = BigEndian;
91  else if( ValueStr == "LittleEndian" )
92  *pValue = LittleEndian;
93  else
94  return false;
95  return true;
96  }
98  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EEndianess *pValue)
99  {
100 
101  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
102  if( *pValue == BigEndian )
103  ValueStr = "BigEndian";
104  else if( *pValue == LittleEndian )
105  ValueStr = "LittleEndian";
106  else
107  ValueStr = "_UndefinedEndian";
108  }
109 
112  {
114  ToString(Result, &Value);
115  return Result;
116  }
117  };
118 
123  {
124  public:
126  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ERepresentation *pValue)
127  {
128  if (!pValue) return false;
129  if( ValueStr == "Linear" )
130  *pValue = Linear;
131  else if( ValueStr == "Logarithmic" )
132  *pValue = Logarithmic;
133  else if( ValueStr == "Boolean" )
134  *pValue = Boolean;
135  else if( ValueStr == "PureNumber" )
136  *pValue = PureNumber;
137  else if( ValueStr == "HexNumber" )
138  *pValue = HexNumber;
139  else if( ValueStr == "IPV4Address" )
140  *pValue = IPV4Address;
141  else if( ValueStr == "MACAddress" )
142  *pValue = MACAddress;
143  else
144  return false;
145  return true;
146  }
148  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ERepresentation *pValue)
149  {
150  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
151  if( *pValue == Linear )
152  ValueStr = "Linear";
153  else if( *pValue == Logarithmic )
154  ValueStr = "Logarithmic";
155  else if( *pValue == Boolean )
156  ValueStr = "Boolean";
157  else if( *pValue == PureNumber )
158  ValueStr = "PureNumber";
159  else if( *pValue == HexNumber )
160  ValueStr = "HexNumber";
161  else if( *pValue == IPV4Address )
162  ValueStr = "IPV4Address";
163  else if( *pValue == MACAddress )
164  ValueStr = "MACAddress";
165  else
166  ValueStr = "_UndefinedRepresentation";
167  }
168 
171  {
173  ToString(Result, &Value);
174  return Result;
175  }
176  };
177 
182  {
183  public:
185  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EVisibility *pValue)
186  {
187  if (!pValue) return false;
188  if( ValueStr == "Beginner" )
189  *pValue = Beginner;
190  else if( ValueStr == "Expert" )
191  *pValue = Expert;
192  else if( ValueStr == "Guru" )
193  *pValue = Guru;
194  else if( ValueStr == "Invisible" )
195  *pValue = Invisible;
196  else
197  return false;
198  return true;
199  }
201  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EVisibility *pValue)
202  {
203  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
204  if( *pValue == Beginner )
205  ValueStr = "Beginner";
206  else if( *pValue == Expert )
207  ValueStr = "Expert";
208  else if( *pValue == Guru )
209  ValueStr = "Guru";
210  else if( *pValue == Invisible )
211  ValueStr = "Invisible";
212  else
213  ValueStr = "_UndefinedVisibility";
214  }
217  {
219  ToString(Result, &Value);
220  return Result;
221  }
222  };
223 
228  {
229  public:
231  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EAccessMode *pValue)
232  {
233 
234  if (!pValue) return false;
235  if( ValueStr == "RW" )
236  *pValue = RW;
237  else if( ValueStr == "RO" )
238  *pValue = RO;
239  else if( ValueStr == "WO" )
240  *pValue = WO;
241  else if( ValueStr == "NA" )
242  *pValue = NA;
243  else if( ValueStr == "NI" )
244  *pValue = NI;
245  else
246  return false;
247  return true;
248  }
250  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EAccessMode *pValue)
251  {
252  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
253  if( *pValue == RW )
254  ValueStr = "RW";
255  else if( *pValue == RO )
256  ValueStr = "RO";
257  else if( *pValue == WO )
258  ValueStr = "WO";
259  else if( *pValue == NI )
260  ValueStr = "NI";
261  else if( *pValue == NA )
262  ValueStr = "NA";
263  else
264  ValueStr = "_UndefinedAccessMode";
265  }
266 
269  {
271  ToString(Result, &Value);
272  return Result;
273  }
274  };
275 
280  {
281  public:
283  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ECachingMode *pValue )
284  {
285  if( ! pValue ) return false;
286  if( ValueStr == "NoCache" )
287  *pValue = NoCache;
288  else if( ValueStr == "WriteThrough" )
289  *pValue = WriteThrough;
290  else if( ValueStr == "WriteAround" )
291  *pValue = WriteAround;
292  else
293  return false;
294  return true;
295  }
296  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ECachingMode *pValue)
297  {
298  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
299  if( *pValue == NoCache )
300  ValueStr = "NoCache";
301  else if( *pValue == WriteThrough )
302  ValueStr = "WriteThrough";
303  else if( *pValue == WriteAround )
304  ValueStr = "WriteAround";
305  else
306  ValueStr = "_UndefinedCachingMode";
307  }
310  {
312  ToString(Result, &Value);
313  return Result;
314  }
315 
316  };
317 
322  {
323  public:
325  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ENameSpace *pValue)
326  {
327  if (!pValue) return false;
328  if( ValueStr == "Custom" )
329  *pValue = Custom;
330  else if( ValueStr == "Standard" )
331  *pValue = Standard;
332  else
333  return false;
334  return true;
335  }
337  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ENameSpace *pValue)
338  {
339  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
340  if( *pValue == Custom )
341  ValueStr = "Custom";
342  else if( *pValue == Standard )
343  ValueStr = "Standard";
344  else
345  ValueStr = "_UndefinedNameSpace";
346  }
349  {
351  ToString(Result, &Value);
352  return Result;
353  }
354  };
355 
360  {
361  public:
363  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EYesNo *pValue)
364  {
365  if (!pValue) return false;
366  if( ValueStr == "Yes" )
367  *pValue = Yes;
368  else if( ValueStr == "No" )
369  *pValue = No;
370  else
371  return false;
372  return true;
373  }
375  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EYesNo *pValue)
376  {
377  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
378  if( *pValue == Yes)
379  ValueStr = "Yes";
380  else if( *pValue == No )
381  ValueStr = "No";
382  else
383  ValueStr = "_UndefinedYesNo";
384  }
385 
388  {
390  ToString(Result, &Value);
391  return Result;
392  }
393  };
394 
399  {
400  public:
402  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EStandardNameSpace *pValue)
403  {
404  if (!pValue) return false;
405  if( ValueStr == "None" )
406  *pValue = None;
407  else if( ValueStr == "GEV" )
408  *pValue = GEV;
409  else if( ValueStr == "IIDC" )
410  *pValue = IIDC;
411  else if( ValueStr == "CL" )
412  *pValue = CL;
413  else if( ValueStr == "USB" )
414  *pValue = USB;
415  else
416  return false;
417  return true;
418  }
421  {
422  if( ! pValue ) throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
423  if( *pValue == None )
424  ValueStr = "None";
425  else if( *pValue == GEV )
426  ValueStr = "GEV";
427  else if( *pValue == IIDC )
428  ValueStr = "IIDC";
429  else if( *pValue == CL )
430  ValueStr = "CL";
431  else if( *pValue == USB )
432  ValueStr = "USB";
433  else
434  ValueStr = "_UndefinedStandardNameSpace";
435  }
438  {
440  ToString(Result, &Value);
441  return Result;
442  }
443  };
444 
449  {
450  public:
452  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ESlope *pValue)
453  {
454  if (!pValue)
455  return false;
456 
457  if( ValueStr == "Increasing" )
458  *pValue = Increasing;
459  else if( ValueStr == "Decreasing" )
460  *pValue = Decreasing;
461  else if( ValueStr == "Varying" )
462  *pValue = Varying;
463  else if( ValueStr == "Automatic" )
464  *pValue = Automatic;
465  else
466  return false;
467 
468  return true;
469  }
471  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ESlope *pValue)
472  {
473  if( ! pValue )
474  throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
475 
476  if( *pValue == Increasing )
477  ValueStr = "Increasing";
478  else if( *pValue == Decreasing )
479  ValueStr = "Decreasing";
480  else if( *pValue == Varying )
481  ValueStr = "Varying";
482  else if( *pValue == Automatic )
483  ValueStr = "Automatic";
484  else
485  ValueStr = "_UndefinedESlope";
486  }
489  {
491  ToString(Result, &Value);
492  return Result;
493  }
494  };
495 
500  {
501  public:
503  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EDisplayNotation *pValue)
504  {
505  if (!pValue)
506  return false;
507 
508  if( ValueStr == "Automatic" )
509  *pValue = fnAutomatic;
510  else if( ValueStr == "Fixed" )
511  *pValue = fnFixed;
512  else if( ValueStr == "Scientific" )
513  *pValue = fnScientific;
514  else
515  return false;
516 
517  return true;
518  }
520  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EDisplayNotation *pValue)
521  {
522  if( ! pValue )
523  throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
524 
525  if( *pValue == fnAutomatic )
526  ValueStr = "Automatic";
527  else if( *pValue == fnFixed )
528  ValueStr = "Fixed";
529  else if( *pValue == fnScientific )
530  ValueStr = "Scientific";
531  else
532  ValueStr = "_UndefinedEDisplayNotation";
533  }
536  {
538  ToString(Result, &Value);
539  return Result;
540  }
541  };
542 
547  {
548  public:
550  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EInputDirection *pValue)
551  {
552  if (!pValue)
553  return false;
554 
555  if( ValueStr == "From" )
556  *pValue = idFrom;
557  else if( ValueStr == "To" )
558  *pValue = idTo;
559  else if( ValueStr == "None" )
560  *pValue = idNone;
561  else
562  return false;
563 
564  return true;
565  }
567  static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EInputDirection *pValue)
568  {
569  if( ! pValue )
570  throw INVALID_ARGUMENT_EXCEPTION( "NULL argument pValue" );
571 
572  if( *pValue == idFrom )
573  ValueStr = "From";
574  else if( *pValue == idTo )
575  ValueStr = "To";
576  else if( *pValue == idNone )
577  ValueStr = "None";
578  else
579  ValueStr = "_UndefinedEInputDirection";
580  }
583  {
585  ToString(Result, &Value);
586  return Result;
587  }
588  };
589 
592  {
593  public:
595  static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EGenApiSchemaVersion *pValue)
596  {
597  if (!pValue) return false;
598  if (ValueStr == "v1_0")
599  *pValue = v1_0;
600  else if (ValueStr == "v1_1")
601  *pValue = v1_1;
602  else
603  return false;
604  return true;
605  }
608  {
609 
610  assert(!pValue);
611  if (*pValue == v1_0)
612  ValueStr = "v1_0";
613  else if (*pValue == v1_1)
614  ValueStr = "v1_1";
615  else
616  ValueStr = "_Undefined";
617  }
618 
621  {
623  ToString(Result, &Value);
624  return Result;
625  }
626  };
627 
628 
629 }
630 
631 #endif // ifndef GENAPI_ENUMCLASSES_H
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EStandardNameSpace *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:402
enum GENAPI_NAMESPACE::_EVisibility EVisibility
recommended visibility of a node
Slider with logarithmic behaviour.
Definition: Types.h:92
static GENICAM_NAMESPACE::gcstring ToString(ESign Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:71
name resides in one of the standard namespaces
Definition: Types.h:121
Hex number in an edit control.
Definition: Types.h:95
Common types used in the public GenApi interface.
Integer is signed.
Definition: Types.h:47
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ENameSpace *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:337
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EAccessMode *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:250
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EGenApiSchemaVersion *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:607
strictly monotonous decreasing
Definition: Types.h:158
Indicates a swiss knife that it is used as worker for a converter computing FROM. ...
Definition: Types.h:233
name resides in custom namespace
Definition: Types.h:120
enum GENAPI_NAMESPACE::_EEndianess EEndianess
Endianess of a value in a register.
static GENICAM_NAMESPACE::gcstring ToString(ENameSpace Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:348
name resides in 1394 IIDC namespace
Definition: Types.h:132
Decimal number in an edit control.
Definition: Types.h:94
Visible for Gurus.
Definition: Types.h:72
slope is determined automatically by probing the function
Definition: Types.h:160
enum GENAPI_NAMESPACE::_ESign ESign
signed or unsigned integers
static GENICAM_NAMESPACE::gcstring ToString(ESlope Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:488
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ECachingMode *pValue)
Definition: EnumClasses.h:296
Not Visible.
Definition: Types.h:73
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EYesNo *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:363
strictly monotonous increasing
Definition: Types.h:157
static GENICAM_NAMESPACE::gcstring ToString(EYesNo Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:387
static GENICAM_NAMESPACE::gcstring ToString(EVisibility Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:216
EEndianessClass holds conversion methods for the endianess enumeration.
Definition: EnumClasses.h:82
Holds conversion methods for the notation type of floats.
Definition: EnumClasses.h:546
static GENICAM_NAMESPACE::gcstring ToString(ECachingMode Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:309
EAccessModeClass holds conversion methods for the access mode enumeration.
Definition: EnumClasses.h:227
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EStandardNameSpace *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:420
Register is big endian.
Definition: Types.h:110
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EDisplayNotation *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:520
#define GENAPI_DECL
Definition: GenApiDll.h:55
Visible for experts or Gurus.
Definition: Types.h:71
the notation is scientific, e.g. 1.234e2
Definition: Types.h:183
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ESign *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:46
ERepresentationClass holds conversion methods for the representation enumeration. ...
Definition: EnumClasses.h:122
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EVisibility *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:201
Holds conversion methods for the namespace enumeration.
Definition: EnumClasses.h:321
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ESlope *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:452
Write to cache and register.
Definition: Types.h:82
enum GENAPI_NAMESPACE::_ERepresentation ERepresentation
recommended representation of a node value
static GENICAM_NAMESPACE::gcstring ToString(EStandardNameSpace Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:437
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EInputDirection *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:550
enum GENAPI_NAMESPACE::_ECachingMode ECachingMode
caching mode of a register
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EAccessMode *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:231
enum GENAPI_NAMESPACE::_EDisplayNotation EDisplayNotation
typedef for float notation
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ENameSpace *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:325
virtual GENICAM_NAMESPACE::gcstring ToString()=0
Returns a string representation of the digit.
Indicates a swiss knife that it is used as worker for a converter computing TO.
Definition: Types.h:234
Register is little endian.
Definition: Types.h:111
Holds conversion methods for the notation type of floats.
Definition: EnumClasses.h:499
helper class converting EGenApiSchemaVersion from and to string
Definition: EnumClasses.h:591
enum GENAPI_NAMESPACE::_EYesNo EYesNo
Defines the choices of a Yes/No alternatives.
static GENICAM_NAMESPACE::gcstring ToString(EInputDirection Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:582
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ESign *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:58
Write to register, write to cache on read.
Definition: Types.h:83
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EEndianess *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:98
name resides in USB namespace
Definition: Types.h:134
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EGenApiSchemaVersion *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:595
Integer is unsigned.
Definition: Types.h:48
EVisibilityClass holds conversion methods for the visibility enumeration.
Definition: EnumClasses.h:181
name resides in custom namespace
Definition: Types.h:130
Not implemented.
Definition: Types.h:56
Read Only.
Definition: Types.h:59
ECachingModeClass holds conversion methods for the caching mode enumeration.
Definition: EnumClasses.h:279
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EVisibility *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:185
enum GENAPI_NAMESPACE::_EGenApiSchemaVersion EGenApiSchemaVersion
GenApi schema version.
Holds conversion methods for the standard namespace enumeration.
Definition: EnumClasses.h:398
name resides in camera link namespace
Definition: Types.h:133
Always visible.
Definition: Types.h:70
static GENICAM_NAMESPACE::gcstring ToString(EDisplayNotation Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:535
Not available.
Definition: Types.h:57
Write Only.
Definition: Types.h:58
A string class which is a clone of std::string.
Definition: GCString.h:52
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EDisplayNotation *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:503
static GENICAM_NAMESPACE::gcstring ToString(ERepresentation Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:170
enum GENAPI_NAMESPACE::_EStandardNameSpace EStandardNameSpace
Defines from which standard namespace a node name comes from.
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, EEndianess *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:86
Holds conversion methods for the standard namespace enumeration.
Definition: EnumClasses.h:359
SwissKnife is not used within a converter.
Definition: Types.h:235
slope changes, e.g. at run-time
Definition: Types.h:159
the notation if either scientific or fixed depending on what is shorter
Definition: Types.h:181
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ESlope *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:471
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ERepresentation *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:126
enum GENAPI_NAMESPACE::_EAccessMode EAccessMode
access mode of a node
enum GENAPI_NAMESPACE::_EInputDirection EInputDirection
typedef for link type
Slider with linear behavior.
Definition: Types.h:91
#define INVALID_ARGUMENT_EXCEPTION
Fires an invalid argument exception, e.g. throw INVALID_ARGUMENT_EXCEPTION("%ld too large"...
Definition: GCException.h:238
static bool FromString(const GENICAM_NAMESPACE::gcstring &ValueStr, ECachingMode *pValue)
Converts a string to enum value.
Definition: EnumClasses.h:283
ESignClass holds conversion methods for the sign enumeration.
Definition: EnumClasses.h:42
enum GENAPI_NAMESPACE::_ESlope ESlope
typedef for formula type
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, ERepresentation *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:148
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EInputDirection *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:567
Read and Write.
Definition: Types.h:60
static GENICAM_NAMESPACE::gcstring ToString(EEndianess Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:111
Holds conversion methods for the converter formulas.
Definition: EnumClasses.h:448
static void ToString(GENICAM_NAMESPACE::gcstring &ValueStr, EYesNo *pValue)
Converts a string to an int32_t property.
Definition: EnumClasses.h:375
static GENICAM_NAMESPACE::gcstring ToString(EAccessMode Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:268
static GENICAM_NAMESPACE::gcstring ToString(EGenApiSchemaVersion Value)
Converts a string to an int32_t property.
Definition: EnumClasses.h:620
name resides in GigE Vision namespace
Definition: Types.h:131
Lexical analyzer for CIntSwissKnife.
Definition: Autovector.h:48
the notation is fixed, e.g. 123.4
Definition: Types.h:182
Do not use cache.
Definition: Types.h:81
enum GENAPI_NAMESPACE::_ENameSpace ENameSpace
Defines if a node name is standard or custom.


rc_genicam_api
Author(s): Heiko Hirschmueller
autogenerated on Wed Mar 17 2021 02:48:40