AJA NTV2 SDK  17.5.0.1242
NTV2 SDK 17.5.0.1242
variant.cpp
Go to the documentation of this file.
1 /* SPDX-License-Identifier: MIT */
8 #include "ajabase/common/variant.h"
9 #include "ajabase/common/common.h"
10 
11 #ifdef AJA_USE_CPLUSPLUS11
12  #include <cstdlib>
13 #else
14  #include <stdlib.h>
15 #endif
16 
17 
18 AJAVariant::AJAVariant(AJAVariantType type)
19  : mType(type)
20 {
21  initialize();
22 }
23 
24 void AJAVariant::initialize()
25 {
26  switch(mType) {
27  case AJA_VARIANT_BOOL: mUnion.mBooleanValue = false; break;
28  case AJA_VARIANT_FLOAT: mUnion.mFloatValue = 0.f; break;
29  case AJA_VARIANT_DOUBLE: mUnion.mDoubleValue = 0.0; break;
30  case AJA_VARIANT_INT8: mUnion.mInt8Value = 0; break;
31  case AJA_VARIANT_UINT8: mUnion.mUInt8Value = 0; break;
32  case AJA_VARIANT_INT16: mUnion.mInt16Value = 0; break;
33  case AJA_VARIANT_UINT16: mUnion.mUInt16Value = 0; break;
34  case AJA_VARIANT_INT32: mUnion.mInt32Value = 0; break;
35  case AJA_VARIANT_UINT32: mUnion.mUInt32Value = 0; break;
36  case AJA_VARIANT_INT64: mUnion.mInt64Value = 0; break;
37  case AJA_VARIANT_UINT64: mUnion.mUInt64Value = 0; break;
38  case AJA_VARIANT_STRING: mStringValue = std::string(); break;
39  default:
40  case AJA_VARIANT_NONE: break;
41  }
42 }
43 
44 AJAVariant & AJAVariant::operator = (const AJAVariant & rhs)
45 {
46  if (&rhs == this)
47  return *this;
48  mType = rhs.mType;
49  switch (mType)
50  {
51  case AJA_VARIANT_BOOL: mUnion.mBooleanValue = rhs.mUnion.mBooleanValue; break;
52  case AJA_VARIANT_FLOAT: mUnion.mFloatValue = rhs.mUnion.mFloatValue; break;
53  case AJA_VARIANT_DOUBLE: mUnion.mDoubleValue = rhs.mUnion.mDoubleValue; break;
54  case AJA_VARIANT_INT8: mUnion.mInt8Value = rhs.mUnion.mInt8Value; break;
55  case AJA_VARIANT_UINT8: mUnion.mUInt8Value = rhs.mUnion.mUInt8Value; break;
56  case AJA_VARIANT_INT16: mUnion.mInt16Value = rhs.mUnion.mInt16Value; break;
57  case AJA_VARIANT_UINT16: mUnion.mUInt16Value = rhs.mUnion.mUInt16Value; break;
58  case AJA_VARIANT_INT32: mUnion.mInt32Value = rhs.mUnion.mInt32Value; break;
59  case AJA_VARIANT_UINT32: mUnion.mUInt32Value = rhs.mUnion.mUInt32Value; break;
60  case AJA_VARIANT_INT64: mUnion.mInt64Value = rhs.mUnion.mInt64Value; break;
61  case AJA_VARIANT_UINT64: mUnion.mUInt64Value = rhs.mUnion.mUInt64Value; break;
62  case AJA_VARIANT_STRING: mStringValue = rhs.mStringValue; break;
63  default:
64  case AJA_VARIANT_NONE: break;
65  }
66  return *this;
67 }
68 
69 
70 // Type conversion methods
71 bool AJAVariant::AsBool() const
72 {
73  switch(mType)
74  {
75  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue;
76  case AJA_VARIANT_FLOAT: return mUnion.mFloatValue ? true : false;
77  case AJA_VARIANT_DOUBLE: return mUnion.mDoubleValue ? true : false;
78  case AJA_VARIANT_INT8: return mUnion.mInt8Value ? true : false;
79  case AJA_VARIANT_UINT8: return mUnion.mUInt8Value ? true : false;
80  case AJA_VARIANT_INT16: return mUnion.mInt16Value ? true : false;
81  case AJA_VARIANT_UINT16: return mUnion.mUInt16Value ? true : false;
82  case AJA_VARIANT_INT32: return mUnion.mInt32Value ? true : false;
83  case AJA_VARIANT_UINT32: return mUnion.mUInt32Value ? true : false;
84  case AJA_VARIANT_INT64: return mUnion.mInt64Value ? true : false;
85  case AJA_VARIANT_UINT64: return mUnion.mUInt64Value ? true : false;
86  case AJA_VARIANT_STRING:
87  {
88  if (mStringValue.empty())
89  return false;
90  std::string tmp(mStringValue);
91  aja::lower(tmp);
92  if (tmp == "true" || tmp == "1" || tmp == "y")
93  return true;
94  return false;
95  }
96  default:
97  case AJA_VARIANT_NONE: break;
98  }
99  return false;
100 }
101 
102 float AJAVariant::AsFloat() const
103 {
104  switch(mType)
105  {
106  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1.f : 0.f;
107  case AJA_VARIANT_FLOAT: return mUnion.mFloatValue;
108  case AJA_VARIANT_DOUBLE: return float(mUnion.mDoubleValue);
109  case AJA_VARIANT_INT8: return float(mUnion.mInt8Value);
110  case AJA_VARIANT_UINT8: return float(mUnion.mUInt8Value);
111  case AJA_VARIANT_INT16: return float(mUnion.mInt16Value);
112  case AJA_VARIANT_UINT16: return float(mUnion.mUInt16Value);
113  case AJA_VARIANT_INT32: return float(mUnion.mInt32Value);
114  case AJA_VARIANT_UINT32: return float(mUnion.mUInt32Value);
115  case AJA_VARIANT_INT64: return float(mUnion.mInt64Value);
116  case AJA_VARIANT_UINT64: return float(mUnion.mUInt64Value);
117  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0.f
118 #ifdef AJA_USE_CPLUSPLUS11
119  : std::strtof(mStringValue.data(), NULL);
120 #else
121  : float(atof(mStringValue.data()));
122 #endif
123  default:
124  case AJA_VARIANT_NONE: break;
125  }
126  return 0.f;
127 }
128 
129 double AJAVariant::AsDouble() const
130 {
131  switch(mType)
132  {
133  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1.0 : 0.0;
134  case AJA_VARIANT_FLOAT: return mUnion.mFloatValue;
135  case AJA_VARIANT_DOUBLE: return mUnion.mDoubleValue;
136  case AJA_VARIANT_INT8: return double(mUnion.mInt8Value);
137  case AJA_VARIANT_UINT8: return double(mUnion.mUInt8Value);
138  case AJA_VARIANT_INT16: return double(mUnion.mInt16Value);
139  case AJA_VARIANT_UINT16: return double(mUnion.mUInt16Value);
140  case AJA_VARIANT_INT32: return double(mUnion.mInt32Value);
141  case AJA_VARIANT_UINT32: return double(mUnion.mUInt32Value);
142  case AJA_VARIANT_INT64: return double(mUnion.mInt64Value);
143  case AJA_VARIANT_UINT64: return double(mUnion.mUInt64Value);
144  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0.0 : strtod(mStringValue.data(), NULL);
145  default:
146  case AJA_VARIANT_NONE: break;
147  }
148  return 0.0;
149 }
150 
151 int8_t AJAVariant::AsInt8() const
152 {
153  switch(mType)
154  {
155  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
156  case AJA_VARIANT_FLOAT: return int8_t(mUnion.mFloatValue);
157  case AJA_VARIANT_DOUBLE: return int8_t(mUnion.mDoubleValue);
158  case AJA_VARIANT_INT8: return mUnion.mInt8Value;
159  case AJA_VARIANT_UINT8: return int8_t(mUnion.mUInt8Value);
160  case AJA_VARIANT_INT16: return int8_t(mUnion.mInt16Value);
161  case AJA_VARIANT_UINT16: return int8_t(mUnion.mUInt16Value);
162  case AJA_VARIANT_INT32: return int8_t(mUnion.mInt32Value);
163  case AJA_VARIANT_UINT32: return int8_t(mUnion.mUInt32Value);
164  case AJA_VARIANT_INT64: return int8_t(mUnion.mInt64Value);
165  case AJA_VARIANT_UINT64: return int8_t(mUnion.mUInt64Value);
166  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : int8_t(strtol(mStringValue.data(), NULL, 0));
167  default:
168  case AJA_VARIANT_NONE: break;
169  }
170  return 0;
171 }
172 
173 uint8_t AJAVariant::AsUInt8() const
174 {
175  switch(mType)
176  {
177  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
178  case AJA_VARIANT_FLOAT: return uint8_t(mUnion.mFloatValue);
179  case AJA_VARIANT_DOUBLE: return uint8_t(mUnion.mDoubleValue);
180  case AJA_VARIANT_INT8: return uint8_t(mUnion.mInt8Value);
181  case AJA_VARIANT_UINT8: return mUnion.mUInt8Value;
182  case AJA_VARIANT_INT16: return uint8_t(mUnion.mInt16Value);
183  case AJA_VARIANT_UINT16: return uint8_t(mUnion.mUInt16Value);
184  case AJA_VARIANT_INT32: return uint8_t(mUnion.mInt32Value);
185  case AJA_VARIANT_UINT32: return uint8_t(mUnion.mUInt32Value);
186  case AJA_VARIANT_INT64: return uint8_t(mUnion.mInt64Value);
187  case AJA_VARIANT_UINT64: return uint8_t(mUnion.mUInt64Value);
188  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : uint8_t(strtol(mStringValue.data(), NULL, 0));
189  default:
190  case AJA_VARIANT_NONE: break;
191  }
192  return 0;
193 }
194 
195 int16_t AJAVariant::AsInt16() const
196 {
197  switch(mType)
198  {
199  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
200  case AJA_VARIANT_FLOAT: return int16_t(mUnion.mFloatValue);
201  case AJA_VARIANT_DOUBLE: return int16_t(mUnion.mDoubleValue);
202  case AJA_VARIANT_INT8: return int16_t(mUnion.mInt8Value);
203  case AJA_VARIANT_UINT8: return int16_t(mUnion.mUInt8Value);
204  case AJA_VARIANT_INT16: return mUnion.mInt16Value;
205  case AJA_VARIANT_UINT16: return int16_t(mUnion.mUInt16Value);
206  case AJA_VARIANT_INT32: return int16_t(mUnion.mInt32Value);
207  case AJA_VARIANT_UINT32: return int16_t(mUnion.mUInt32Value);
208  case AJA_VARIANT_INT64: return int16_t(mUnion.mInt64Value);
209  case AJA_VARIANT_UINT64: return int16_t(mUnion.mUInt64Value);
210  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : int16_t(strtol(mStringValue.data(), NULL, 0));
211  default:
212  case AJA_VARIANT_NONE: break;
213  }
214  return 0;
215 }
216 
217 uint16_t AJAVariant::AsUInt16() const
218 {
219  switch(mType)
220  {
221  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
222  case AJA_VARIANT_FLOAT: return uint16_t(mUnion.mFloatValue);
223  case AJA_VARIANT_DOUBLE: return uint16_t(mUnion.mDoubleValue);
224  case AJA_VARIANT_INT8: return uint16_t(mUnion.mInt8Value);
225  case AJA_VARIANT_UINT8: return uint16_t(mUnion.mUInt8Value);
226  case AJA_VARIANT_INT16: return uint16_t(mUnion.mInt16Value);
227  case AJA_VARIANT_UINT16: return mUnion.mUInt16Value;
228  case AJA_VARIANT_INT32: return uint16_t(mUnion.mInt32Value);
229  case AJA_VARIANT_UINT32: return uint16_t(mUnion.mUInt32Value);
230  case AJA_VARIANT_INT64: return uint16_t(mUnion.mInt64Value);
231  case AJA_VARIANT_UINT64: return uint16_t(mUnion.mUInt64Value);
232  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : uint16_t(strtol(mStringValue.data(), NULL, 0));
233  default:
234  case AJA_VARIANT_NONE: break;
235  }
236  return 0;
237 }
238 
239 int32_t AJAVariant::AsInt32() const
240 {
241  switch(mType)
242  {
243  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
244  case AJA_VARIANT_FLOAT: return int32_t(mUnion.mFloatValue);
245  case AJA_VARIANT_DOUBLE: return int32_t(mUnion.mDoubleValue);
246  case AJA_VARIANT_INT8: return int32_t(mUnion.mInt8Value);
247  case AJA_VARIANT_UINT8: return int32_t(mUnion.mUInt8Value);
248  case AJA_VARIANT_INT16: return int32_t(mUnion.mInt16Value);
249  case AJA_VARIANT_UINT16: return int32_t(mUnion.mUInt16Value);
250  case AJA_VARIANT_INT32: return mUnion.mInt32Value;
251  case AJA_VARIANT_UINT32: return int32_t(mUnion.mUInt32Value);
252  case AJA_VARIANT_INT64: return int32_t(mUnion.mInt64Value);
253  case AJA_VARIANT_UINT64: return int32_t(mUnion.mUInt64Value);
254  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : int32_t(strtol(mStringValue.data(), NULL, 0));
255  default:
256  case AJA_VARIANT_NONE: break;
257  }
258  return 0;
259 }
260 
261 uint32_t AJAVariant::AsUInt32() const
262 {
263  switch(mType)
264  {
265  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
266  case AJA_VARIANT_FLOAT: return uint32_t(mUnion.mFloatValue);
267  case AJA_VARIANT_DOUBLE: return uint32_t(mUnion.mDoubleValue);
268  case AJA_VARIANT_INT8: return uint32_t(mUnion.mInt8Value);
269  case AJA_VARIANT_UINT8: return uint32_t(mUnion.mUInt8Value);
270  case AJA_VARIANT_INT16: return uint32_t(mUnion.mInt16Value);
271  case AJA_VARIANT_UINT16: return uint32_t(mUnion.mUInt16Value);
272  case AJA_VARIANT_INT32: return uint32_t(mUnion.mInt32Value);
273  case AJA_VARIANT_UINT32: return mUnion.mUInt32Value;
274  case AJA_VARIANT_INT64: return uint32_t(mUnion.mInt64Value);
275  case AJA_VARIANT_UINT64: return uint32_t(mUnion.mUInt64Value);
276  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0 : strtoul(mStringValue.data(), NULL, 0);
277  default:
278  case AJA_VARIANT_NONE: break;
279  }
280  return 0;
281 }
282 
283 int64_t AJAVariant::AsInt64() const
284 {
285  switch(mType)
286  {
287  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
288  case AJA_VARIANT_FLOAT: return int64_t(mUnion.mFloatValue);
289  case AJA_VARIANT_DOUBLE: return int64_t(mUnion.mDoubleValue);
290  case AJA_VARIANT_INT8: return int64_t(mUnion.mInt8Value);
291  case AJA_VARIANT_UINT8: return int64_t(mUnion.mUInt8Value);
292  case AJA_VARIANT_INT16: return int64_t(mUnion.mInt16Value);
293  case AJA_VARIANT_UINT16: return int64_t(mUnion.mUInt16Value);
294  case AJA_VARIANT_INT32: return int64_t(mUnion.mInt32Value);
295  case AJA_VARIANT_UINT32: return int64_t(mUnion.mUInt32Value);
296  case AJA_VARIANT_INT64: return mUnion.mInt64Value;
297  case AJA_VARIANT_UINT64: return int64_t(mUnion.mUInt64Value);
298  case AJA_VARIANT_STRING: return mStringValue.empty() ? 0
299 #ifdef AJA_USE_CPLUSPLUS11
300  : std::strtoll(mStringValue.data(), NULL, 0);
301 #else
302  : atol(mStringValue.data());
303 #endif
304  default:
305  case AJA_VARIANT_NONE: break;
306  }
307  return 0;
308 }
309 
310 uint64_t AJAVariant::AsUInt64() const
311 {
312  switch(mType)
313  {
314  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? 1 : 0;
315  case AJA_VARIANT_FLOAT: return uint64_t(mUnion.mFloatValue);
316  case AJA_VARIANT_DOUBLE: return uint64_t(mUnion.mDoubleValue);
317  case AJA_VARIANT_INT8: return uint64_t(mUnion.mInt8Value);
318  case AJA_VARIANT_UINT8: return uint64_t(mUnion.mUInt8Value);
319  case AJA_VARIANT_INT16: return uint64_t(mUnion.mInt16Value);
320  case AJA_VARIANT_UINT16: return uint64_t(mUnion.mUInt16Value);
321  case AJA_VARIANT_INT32: return uint64_t(mUnion.mInt32Value);
322  case AJA_VARIANT_UINT32: return uint64_t(mUnion.mUInt32Value);
323  case AJA_VARIANT_INT64: return uint64_t(mUnion.mInt64Value);
324  case AJA_VARIANT_UINT64: return mUnion.mUInt64Value;
325  case AJA_VARIANT_STRING:
326  {
327  if (mStringValue.empty())
328  return 0;
329 #ifdef AJA_USE_CPLUSPLUS11
330  return std::strtoull(mStringValue.data(), NULL, 0);
331 #else
332  char* endptr;
333  const char* data = mStringValue.data();
334 #if defined(_MSC_VER) && _MSC_VER < 1900
335  unsigned long value = _strtoui64(data, &endptr, 10);
336 #else
337  unsigned long value = strtoull(data, &endptr, 10);
338 #endif
339  if (data == endptr)
340  return 0;
341  return value;
342 #endif
343  }
344  default:
345  case AJA_VARIANT_NONE: break;
346  }
347  return 0;
348 }
349 
350 std::string AJAVariant::AsString() const
351 {
352  switch(mType)
353  {
354  case AJA_VARIANT_BOOL: return mUnion.mBooleanValue ? "true" : "false";
355  case AJA_VARIANT_FLOAT: return aja::to_string(mUnion.mFloatValue);
356  case AJA_VARIANT_DOUBLE: return aja::to_string(mUnion.mDoubleValue);
357  case AJA_VARIANT_INT8: return aja::to_string(mUnion.mInt8Value);
358  case AJA_VARIANT_UINT8: return aja::to_string(mUnion.mUInt8Value);
359  case AJA_VARIANT_INT16: return aja::to_string(mUnion.mInt16Value);
360  case AJA_VARIANT_UINT16: return aja::to_string(mUnion.mUInt16Value);
361  case AJA_VARIANT_INT32: return aja::to_string(mUnion.mInt32Value);
362  case AJA_VARIANT_UINT32: return aja::to_string(mUnion.mUInt32Value);
363  case AJA_VARIANT_INT64: return aja::to_string((long long)mUnion.mInt64Value);
364  case AJA_VARIANT_UINT64: return aja::to_string((unsigned long long)mUnion.mUInt64Value);
365  case AJA_VARIANT_STRING: return mStringValue;
366  default:
367  case AJA_VARIANT_NONE: break;
368  }
369  return std::string();
370 }
371 
372 bool AJAVariant::IsNumeric() const
373 {
374  switch(mType)
375  {
376  case AJA_VARIANT_FLOAT:
377  case AJA_VARIANT_DOUBLE:
378  case AJA_VARIANT_INT8:
379  case AJA_VARIANT_UINT8:
380  case AJA_VARIANT_INT16:
381  case AJA_VARIANT_UINT16:
382  case AJA_VARIANT_INT32:
383  case AJA_VARIANT_UINT32:
384  case AJA_VARIANT_INT64:
385  case AJA_VARIANT_UINT64:
386  return true;
387  default:
388  break;
389  }
390  return false;
391 }
392 
393 bool AJAVariant::IsUnsigned() const
394 {
395  switch(mType)
396  {
397  case AJA_VARIANT_UINT8:
398  case AJA_VARIANT_UINT16:
399  case AJA_VARIANT_UINT32:
400  case AJA_VARIANT_UINT64:
401  return true;
402  default:
403  break;
404  }
405  return false;
406 }
407 
408 bool AJAVariant::IsSigned() const
409 {
410  switch(mType)
411  {
412  case AJA_VARIANT_FLOAT:
413  case AJA_VARIANT_DOUBLE:
414  case AJA_VARIANT_INT8:
415  case AJA_VARIANT_INT16:
416  case AJA_VARIANT_INT32:
417  case AJA_VARIANT_INT64:
418  return true;
419  default:
420  break;
421  }
422  return false;
423 }
AJA_VARIANT_INT32
@ AJA_VARIANT_INT32
Definition: variant.h:27
AJA_VARIANT_DOUBLE
@ AJA_VARIANT_DOUBLE
Definition: variant.h:22
AJA_VARIANT_UINT64
@ AJA_VARIANT_UINT64
Definition: variant.h:30
AJA_VARIANT_UINT32
@ AJA_VARIANT_UINT32
Definition: variant.h:28
AJAVariant::mBooleanValue
bool mBooleanValue
Definition: variant.h:313
NULL
#define NULL
Definition: ntv2caption608types.h:19
AJAVariant::mUInt8Value
uint8_t mUInt8Value
Definition: variant.h:317
AJA_VARIANT_INT64
@ AJA_VARIANT_INT64
Definition: variant.h:29
AJAVariant::IsSigned
bool IsSigned() const
Definition: variant.cpp:408
AJAVariant::AsInt8
int8_t AsInt8() const
Definition: variant.cpp:151
AJAVariant::AsUInt8
uint8_t AsUInt8() const
Definition: variant.cpp:173
AJAVariant::AsFloat
float AsFloat() const
Definition: variant.cpp:102
AJAVariant::mInt64Value
int64_t mInt64Value
Definition: variant.h:322
AJAVariant::AsString
std::string AsString() const
Definition: variant.cpp:350
AJA_VARIANT_UINT8
@ AJA_VARIANT_UINT8
Definition: variant.h:24
AJAVariant::IsUnsigned
bool IsUnsigned() const
Definition: variant.cpp:393
AJAVariant::mInt16Value
int16_t mInt16Value
Definition: variant.h:318
AJAVariant::AsBool
bool AsBool() const
Definition: variant.cpp:71
AJAVariant::mInt32Value
int32_t mInt32Value
Definition: variant.h:320
aja::lower
std::string & lower(std::string &str)
Definition: common.cpp:436
AJAVariant::AsInt64
int64_t AsInt64() const
Definition: variant.cpp:283
AJAVariantType
AJAVariantType
The data types that AJAVariant supports.
Definition: variant.h:17
AJAVariant::AsInt16
int16_t AsInt16() const
Definition: variant.cpp:195
AJAVariant::AsDouble
double AsDouble() const
Definition: variant.cpp:129
AJAVariant::AsInt32
int32_t AsInt32() const
Definition: variant.cpp:239
AJAVariant::mFloatValue
float mFloatValue
Definition: variant.h:314
AJAVariant::mDoubleValue
double mDoubleValue
Definition: variant.h:315
AJAVariant::AsUInt64
uint64_t AsUInt64() const
Definition: variant.cpp:310
AJA_VARIANT_NONE
@ AJA_VARIANT_NONE
Definition: variant.h:19
AJA_VARIANT_UINT16
@ AJA_VARIANT_UINT16
Definition: variant.h:26
AJAVariant
A simple Variant class.
Definition: variant.h:37
AJAVariant::AJAVariant
AJAVariant(const AJAVariantType type=AJA_VARIANT_INT32)
Definition: variant.cpp:18
AJAVariant::mUInt16Value
uint16_t mUInt16Value
Definition: variant.h:319
AJAVariant::AsUInt16
uint16_t AsUInt16() const
Definition: variant.cpp:217
AJAVariant::mInt8Value
int8_t mInt8Value
Definition: variant.h:316
variant.h
Declares the AJAVariant class.
AJA_VARIANT_BOOL
@ AJA_VARIANT_BOOL
Definition: variant.h:20
AJA_VARIANT_STRING
@ AJA_VARIANT_STRING
Definition: variant.h:31
AJAVariant::IsNumeric
bool IsNumeric() const
Definition: variant.cpp:372
common.h
Private include file for all ajabase sources.
AJAVariant::mUInt64Value
uint64_t mUInt64Value
Definition: variant.h:323
AJAVariant::mUInt32Value
uint32_t mUInt32Value
Definition: variant.h:321
AJA_VARIANT_INT8
@ AJA_VARIANT_INT8
Definition: variant.h:23
true
#define true
Definition: ntv2devicefeatures.h:26
AJA_VARIANT_FLOAT
@ AJA_VARIANT_FLOAT
Definition: variant.h:21
aja::to_string
std::string to_string(bool val)
Definition: common.cpp:180
AJA_VARIANT_INT16
@ AJA_VARIANT_INT16
Definition: variant.h:25
AJAVariant::operator=
AJAVariant & operator=(const AJAVariant &other)
Definition: variant.cpp:44
AJAVariant::AsUInt32
uint32_t AsUInt32() const
Definition: variant.cpp:261