PLCnext API Documentation  21.0.0.35466
RscVariant.hxx
1 //
3 // Copyright PHOENIX CONTACT Electronics GmbH
4 //
6 #pragma once
7 #include "Arp/System/Commons/Exceptions/Exceptions.h"
8 #include "Arp/System/Rsc/Services/Rsc.h"
9 #include "Arp/System/Rsc/Services/RscGuid.hpp"
10 #include "Arp/System/Rsc/Services/RscVersion.hpp"
11 #include "Arp/System/Rsc/Services/RscString.hxx"
12 #include "Arp/System/Rsc/Services/SecureString.hxx"
13 #include <cstring>
14 #include <cstddef>
15 #include <sstream>
16 #include <iomanip>
17 
18 namespace Arp { namespace System { namespace Rsc { namespace Services
19 {
20 
21 using namespace Arp::System::Commons;
22 
23 // forwards
24 class RscArrayReader;
25 class RscArrayWriter;
26 class RemotingReader;
27 class RemotingWriter;
28 template<int N> class RscStructReader;
29 template<int N> class RscStructWriter;
30 template<class T, bool IsClass, bool IsSerializable> class RscValueAdapter;
31 
38 template<int MaxStringSize = 0>
40 {
41 public: // typedefs/friends
42  friend class RscArrayReader;
43  friend class RscArrayWriter;
44  template<int N> friend class RscStructReader;
45  template<int N> friend class RscStructWriter;
46  template<class T, bool IsClass, bool IsSerializable> friend class RscValueAdapter;
47  template<int N> friend class SecureString;
48 
49  using ReadElementFunction = std::function<RscType(RscType expectedType, byte* pValue)>;
50  using WriteElementFunction = std::function<void(RscType valueType, const byte* pValue)>;
52 
53 public: // construction/destruction
59 
63  template <class T>
64  RscVariant(const T& value);
65 
70  RscVariant(const String& value);
71 
76  RscVariant(const char* value);
77 
82  template<int N>
83  RscVariant(const RscString<N>& value);
84 
89  template<int N>
90  RscVariant(const SecureString<N>& value);
91 
100  RscVariant(size_t arraySize, RscType arrayElementType, size_t dimensions = 1, size_t fieldCount = 0);
101 
111  RscVariant(size_t arraySize, RscType arrayElementType, ReadElementFunction* pFunction, size_t dimensions = 1, size_t fieldCount = 0);
112 
122  RscVariant(size_t arraySize, RscType arrayElementType, WriteElementFunction* pFunction, size_t dimensions = 1, size_t fieldCount = 0);
123 
127  RscVariant(size_t fieldCount, ReadElementFunction* pFunction);
128 
132  RscVariant(const RscVariant<MaxStringSize>&) = default;
133 
137  RscVariant(RscVariant&&) = default;
138 
139 public: // Static factory operations
145  static RscVariant<MaxStringSize> CreateStructVariant(size_t fieldCount);
146 
155  static RscVariant<MaxStringSize> CreateArrayVariant(size_t arraySize, RscType elementType, size_t dimensions = 1, size_t fieldCount = 0);
156 
157 private: // static factory operations
158  static RscVariant<MaxStringSize> CreateStructVariant(size_t fieldCount, RemotingWriter& writer);
159  static RscVariant<MaxStringSize> CreateArrayVariant(size_t arraySize, RscType elementType, RemotingWriter& writer, size_t dimensions = 1, size_t fieldCount = 0);
160 
161 public: // operators
162  template <class T>
163  RscVariant& operator=(const T& value);
164  RscVariant& operator=(const String& value);
165  RscVariant& operator=(const char* value);
166  template<int N>
167  RscVariant& operator=(const RscString<N>& value);
168  template<int N>
169  RscVariant& operator=(const SecureString<N>& value);
170  RscVariant& operator=(const RscVariant& value) = default;
171  RscVariant& operator=(RscVariant&&) = default;
172  bool operator==(const RscVariant& value)const;
173  bool operator!=(const RscVariant& value)const;
174 
175 public: // getter/setter
180  RscType GetType(void)const;
181 
186  RscType GetValueType(void)const;
187 
193  RscType GetArrayElementType(void)const;
194 
200  size_t GetArrayDimensions(void)const;
201 
207  size_t GetFieldCount(void) const;
208 
213  const char* GetChars(void)const;
214 
220  void SetWriteElementFunction(WriteElementFunction* pFunction) const;
221 
226  const byte* GetDataAddress(void)const;
227 
232  byte* GetDataAddress(void);
233 
238  void SetType(RscType rscType);
239 
240 public: // operations
245  template<class T>
246  T GetValue(void)const;
247 
252  template<class T>
253  void CopyTo(T& value)const;
254 
259  String ToString(void)const;
260 
261 private: // Setter/Getter for internal use and friend classes
262  RscArrayInformation& GetArrayInformation(void);
263  const RscArrayInformation& GetArrayInformation(void) const;
264  RscStructInformation& GetStructInformation(void);
265  const RscStructInformation& GetStructInformation(void) const;
266 
267 private: // methods
268  void Assign(const char*, size_t len, RscType type = RscType::Utf8String);
269  void InitComplexTypeInfo(void);
270  bool ContainsTypeInformation(void) const;
271  size_t GetSize(void)const;
272 
273 private: // nested types
274  struct ComplexTypeInfo
275  {
276  union
277  {
278  RscArrayInformation arrayInformation;
279  RscStructInformation structInformation;
280  };
281  RemotingReader* pReader = nullptr;
282  mutable RemotingWriter* pWriter = nullptr;
283  ReadElementFunction* pReadElementFunction = nullptr;
284  mutable WriteElementFunction* pWriteElementFunction = nullptr;
285  };
286 
287 private: // static fields
288  static const size_t maxPrimitiveSize = 8;
289 #ifdef ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
290  static const size_t minBufferSize = std::max(maxPrimitiveSize, std::max(sizeof(RscGuid), sizeof(RscVersion)));
291 #else
292  static const size_t minBufferSize = maxPrimitiveSize;
293 #endif // ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
294 
295  static const size_t bufferSize = minBufferSize < (size_t)MaxStringSize ? (size_t)MaxStringSize : minBufferSize;
296 
297 private: // fields
298  union
299  {
300  ComplexTypeInfo typeInfo;
301  byte buffer[bufferSize];
302  };
303  RscType type = RscType::None;
304 };
305 
306 
308 // inline methods of RscType helper
309 template<int N>
310 inline constexpr RscType GetRscTypeFrom(const RscVariant<N>& /*value*/)
311 {
312  return RscType::Object;
313 }
314 
316 // inline methods of class RscVariant
317 
318 template<int MaxStringSize>
320  : type(typeArg)
321 {
322 }
323 
324 template<int MaxStringSize>
325 template<class T>
327 {
328  this->operator=(value);
329 }
330 
331 template<int MaxStringSize>
333  : type(RscType::Utf8String)
334 {
335  this->operator=(value);
336 }
337 
338 template<int MaxStringSize>
339 inline RscVariant<MaxStringSize>::RscVariant(const char* value)
340 {
341  this->operator=(value);
342 }
343 
344 template<int MaxStringSize>
345 template<int N>
347 {
348  this->operator=(value);
349 }
350 
351 template<int MaxStringSize>
352 template<int N>
354 {
355  this->operator=(value);
356 }
357 
358 template<int MaxStringSize>
359 inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, size_t dimensions, size_t fieldCount)
360  : type(RscType::Array)
361 {
362  if(arrayElementType == RscType::Struct && fieldCount == 0)
363  {
364  throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
365  }
366  this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
367  this->typeInfo.pReader = nullptr;
368  this->typeInfo.pWriter = nullptr;
369  this->typeInfo.pReadElementFunction = nullptr;
370  this->typeInfo.pWriteElementFunction = nullptr;
371 }
372 
373 template<int MaxStringSize>
374 inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, ReadElementFunction* pFunction, size_t dimensions, size_t fieldCount)
375  : type(RscType::Array)
376 {
377  if(arrayElementType == RscType::Struct && fieldCount == 0)
378  {
379  throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
380  }
381  this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
382  this->typeInfo.pReader = nullptr;
383  this->typeInfo.pWriter = nullptr;
384  this->typeInfo.pReadElementFunction = pFunction;
385  this->typeInfo.pWriteElementFunction = nullptr;
386 }
387 
388 template<int MaxStringSize>
389 inline RscVariant<MaxStringSize>::RscVariant(size_t arraySize, RscType arrayElementType, WriteElementFunction* pFunction, size_t dimensions, size_t fieldCount)
390  : type(RscType::Array)
391 {
392  if(arrayElementType == RscType::Struct && fieldCount == 0)
393  {
394  throw ArgumentException::Create("fieldCount", fieldCount, "fieldCount has to be set for struct element types");
395  }
396  this->GetArrayInformation() = RscArrayInformation(arraySize, arrayElementType, dimensions, fieldCount);
397  this->typeInfo.pReader = nullptr;
398  this->typeInfo.pWriter = nullptr;
399  this->typeInfo.pReadElementFunction = nullptr;
400  this->typeInfo.pWriteElementFunction = pFunction;
401 }
402 
403 template<int MaxStringSize>
404 inline RscVariant<MaxStringSize>::RscVariant(size_t fieldCount, ReadElementFunction* pFunction)
405  : type(RscType::Struct)
406 {
407  this->InitComplexTypeInfo();
408  this->GetStructInformation() = RscStructInformation(fieldCount);
409  this->typeInfo.pReadElementFunction = pFunction;
410 }
411 
412 template<int MaxStringSize>
414 {
415  return this->type;
416 }
417 
418 template<int MaxStringSize>
420 {
421  switch (this->type)
422  {
423  case RscType::IecTime:
424  return RscType::Int32;
425  case RscType::IecTime64:
426  case RscType::IecDate64:
427  case RscType::IecDateTime64:
428  case RscType::IecTimeOfDay64:
429  return RscType::Int64;
430  default:
431  // no mapping
432  return this->type;
433  }
434 }
435 
436 template<int MaxStringSize>
438 {
439  return this->GetArrayInformation().ElementType;
440 }
441 
442 template<int MaxStringSize>
444 {
445  if(this->GetType() != RscType::Array)
446  {
447  throw InvalidOperationException("RscVariant doesn't contain array information");
448  }
449  return this->typeInfo.arrayInformation;
450 }
451 
452 template<int MaxStringSize>
454 {
455  if(this->GetType() != RscType::Array)
456  {
457  throw InvalidOperationException("RscVariant doesn't contain array information");
458  }
459  return this->typeInfo.arrayInformation;
460 }
461 
462 template<int MaxStringSize>
464 {
465  if(this->GetType() != RscType::Struct)
466  {
467  throw InvalidOperationException("RscVariant doesn't contain struct information");
468  }
469  return this->typeInfo.structInformation;
470 }
471 
472 template<int MaxStringSize>
474 {
475  if(this->GetType() != RscType::Struct)
476  {
477  throw InvalidOperationException("RscVariant doesn't contain struct information");
478  }
479  return this->typeInfo.structInformation;
480 }
481 
482 template<int MaxStringSize>
484 {
485  return this->GetArrayInformation().Dimensions;
486 }
487 
488 template<int MaxStringSize>
490 {
491  return this->GetStructInformation().FieldCount;
492 }
493 
494 template<int MaxStringSize>
496 {
497  return this->buffer;
498 }
499 
500 template<int MaxStringSize>
502 {
503  return this->buffer;
504 }
505 
506 template<int MaxStringSize>
508 {
509  this->type = rscType;
510 }
511 
512 template<int MaxStringSize>
514 {
515  return (this->type == RscType::Struct || this->type == RscType::Array);
516 }
517 
518 template<int MaxStringSize>
519 template<class T>
521 {
522  this->type = GetRscType<T>();
523  if(this->type == RscType::None)
524  {
525  throw NotSupportedException("Cannot assign from argument: Type of argument is not supported");
526  }
527 #ifndef ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
528  if (this->type == RscType::Version || this->type == RscType::Guid)
529  {
530  throw NotImplementedException("Type RscVersion and RscGuid are currently not supported by RscVariant");
531  }
532 #endif // ARP_SYSTEM_RSC_SUPPORT_VERSION_GUID_AS_OBJECT
533  *reinterpret_cast<T*>(this->buffer) = value;
534  return *this;
535 }
536 
537 template<int MaxStringSize>
539 {
540  RscVariant<MaxStringSize> result(RscType::Struct);
541  result.InitComplexTypeInfo();
542  result.GetStructInformation().FieldCount = fieldCount;
543  return result;
544 }
545 
546 template<int MaxStringSize>
547 inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateArrayVariant(size_t arraySize, RscType elementType, size_t dimensions, size_t fieldCount)
548 {
549  RscVariant<MaxStringSize> result(arraySize, elementType, dimensions, fieldCount);
550  return result;
551 }
552 
553 template<int MaxStringSize>
554 inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateStructVariant(size_t fieldCount, RemotingWriter& writer)
555 {
557  result.typeInfo.pWriter = &writer;
558  return result;
559 }
560 
561 template<int MaxStringSize>
562 inline RscVariant<MaxStringSize> RscVariant<MaxStringSize>::CreateArrayVariant(size_t arraySize, RscType elementType, RemotingWriter& writer, size_t dimensions, size_t fieldCount)
563 {
564  RscVariant<MaxStringSize> result(arraySize, elementType, dimensions, fieldCount);
565  result.typeInfo.pWriter = &writer;
566  return result;
567 }
568 
569 template<int MaxStringSize>
571 {
572  size_t len = value.Length();
573  this->Assign(value.CStr(), len);
574  return *this;
575 }
576 
577 template<int MaxStringSize>
579 {
580  size_t len = strlen(value);
581  this->Assign(value, len);
582  return *this;
583 }
584 
585 template<int MaxStringSize>
586 template<int N>
588 {
589  this->Assign(value.CStr(), strlen(value.CStr()), RscType::Utf8String);
590  return *this;
591 }
592 
593 template<int MaxStringSize>
594 template<int N>
596 {
597  this->Assign(value.CStr(), strlen(value.CStr()), RscType::SecureString);
598  return *this;
599 }
600 
601 template<int MaxStringSize>
602 inline void RscVariant<MaxStringSize>::Assign(const char* value, size_t len, RscType typeArg)
603 {
604  if (len >= MaxStringSize)
605  {
606  throw ArgumentException("Cannot copy string: argument string length {0} exceeds MaxStringSize {1}", len, MaxStringSize);
607  }
608  if (typeArg != RscType::Utf8String && typeArg != RscType::SecureString)
609  {
610  throw NotSupportedException("RscType '{0}' not supported", typeArg);
611  }
612  memcpy(this->buffer, value, len);
613  this->buffer[len] = '\0';
614  this->type = typeArg;
615 }
616 
617 template<int MaxStringSize>
618 inline bool RscVariant<MaxStringSize>::operator==(const RscVariant& value)const
619 {
620  if (this->GetType() != value.GetType())
621  {
622  return false;
623  }
624 
625  if (this->GetSize() != value.GetSize())
626  {
627  return false;
628  }
629 
630  if (memcmp(this->buffer, value.buffer, this->GetSize()) != 0)
631  {
632  return false;
633  }
634 
635  if (this->GetType() == RscType::Utf8String)
636  {
637  if (strcmp((char*)this->buffer, (char*)value.buffer) != 0)
638  {
639  return false;
640  }
641  }
642 
643  return true;
644 }
645 
646 template<int MaxStringSize>
647 inline bool RscVariant<MaxStringSize>::operator!=(const RscVariant& value)const
648 {
649  return !(*this == value);
650 }
651 
652 template<int MaxStringSize>
654 {
655  // needed, because elements of union are not initialized
656  this->typeInfo.pReader = nullptr;
657  this->typeInfo.pWriter = nullptr;
658  this->typeInfo.pReadElementFunction = nullptr;
659  this->typeInfo.pWriteElementFunction = nullptr;
660 }
661 
662 template<int MaxStringSize>
663 template<class T>
664 inline void RscVariant<MaxStringSize>::CopyTo(T& value) const
665 {
666  RscType argType = GetRscType<T>();
667  if(this->GetValueType() != argType)
668  {
669  throw InvalidCastException("Cannot copy value to argument: RscVariant contains data type {0} but arg is of type {1}", this->type, argType);
670  }
671  value = *reinterpret_cast<const T*>(this->buffer);
672 }
673 
674 template<int MaxStringSize>
675 inline const char* RscVariant<MaxStringSize>::GetChars() const
676 {
677  if (this->type != RscType::Utf8String && this->type != RscType::SecureString && this->type != RscType::AnsiString)
678  {
679  throw InvalidCastException("Cannot convert to string: RscVariant is of type {0}", this->type);
680  }
681  return reinterpret_cast<const char*>(this->buffer);
682 }
683 
684 template<int MaxStringSize>
685 inline void RscVariant<MaxStringSize>::SetWriteElementFunction(WriteElementFunction * pFunction) const
686 {
687  if(this->type != RscType::Array && this->type != RscType::Struct)
688  {
689  throw InvalidOperationException("Method only allowed for array and struct objects");
690  }
691  this->typeInfo.pWriteElementFunction = pFunction;
692 }
693 
694 template<int MaxStringSize>
695 template<class T>
697 {
698  T result;
699  this->CopyTo(result);
700  return result;
701 }
702 
703 template<int MaxStringSize>
705 {
706  const byte* pValue = this->GetDataAddress();
707 
708  switch (this->type)
709  {
710  case RscType::SecureString:
711  case RscType::AnsiString:
712  case RscType::Utf8String:
713  return reinterpret_cast<const char*>(pValue);
714  case RscType::DateTime:
715  return reinterpret_cast<const DateTime*>(pValue)->ToIso8601String();
716  case RscType::Bool:
717  {
718  std::ostringstream oss;
719  oss << std::boolalpha << *reinterpret_cast<const bool*>(pValue);
720  if (oss.fail())
721  {
722  throw InvalidOperationException("Value of RscVariant is not of type bool.");
723  }
724  return oss.str();
725  }
726  case RscType::Char:
727  return std::to_string(*reinterpret_cast<const char16*>(pValue));
728  case RscType::Int16:
729  return std::to_string(*reinterpret_cast<const int16*>(pValue));
730  case RscType::Int32:
731  case RscType::IecTime:
732  return std::to_string(*reinterpret_cast<const int32*>(pValue));
733  case RscType::Int8:
734  return std::to_string(*reinterpret_cast<const int8*>(pValue));
735  case RscType::Int64:
736  case RscType::IecTime64:
737  case RscType::IecDate64:
738  case RscType::IecDateTime64:
739  case RscType::IecTimeOfDay64:
740  return std::to_string(*reinterpret_cast<const int64*>(pValue));
741  case RscType::None:
742  case RscType::Null:
743  return String::Empty;
744  case RscType::Real32:
745  return std::to_string(*reinterpret_cast<const float*>(pValue));
746  case RscType::Real64:
747  return std::to_string(*reinterpret_cast<const double*>(pValue));
748  case RscType::Uint16:
749  return std::to_string(*reinterpret_cast<const uint16*>(pValue));
750  case RscType::Uint32:
751  return std::to_string(*reinterpret_cast<const uint32*>(pValue));
752  case RscType::Uint64:
753  return std::to_string(*reinterpret_cast<const uint64*>(pValue));
754  case RscType::Uint8:
755  return std::to_string(*reinterpret_cast<const uint8*>(pValue));
756  case RscType::Version:
757  return reinterpret_cast<const RscVersion*>(pValue)->ToString();
758  case RscType::Guid:
759  return reinterpret_cast<const RscGuid*>(pValue)->ToString();
760  case RscType::Void:
761  return String::Empty;
762  default:
763  // case RscType::Array:
764  throw NotSupportedException("RscVariant::ToString() not supported for type '{0}'", type);
765  }
766 }
767 
768 template<int MaxStringSize>
769 inline size_t RscVariant<MaxStringSize>::GetSize(void)const
770 {
771  switch (this->GetValueType())
772  {
773  case RscType::Void:
774  return 0;
775  break;
776  case RscType::Bool:
777  case RscType::Int8:
778  case RscType::Uint8:
779  return 1;
780  break;
781  case RscType::Char:
782  case RscType::Int16:
783  case RscType::Uint16:
784  return 2;
785  break;
786  case RscType::Int32:
787  case RscType::Uint32:
788  case RscType::Real32:
789  case RscType::IecTime:
790  return 4;
791  break;
792  case RscType::Int64:
793  case RscType::Uint64:
794  case RscType::Real64:
795  case RscType::DateTime:
796  case RscType::IecTime64:
797  case RscType::IecDate64:
798  case RscType::IecDateTime64:
799  case RscType::IecTimeOfDay64:
800  return 8;
801  break;
802  case RscType::Utf8String:
803  return strlen((char*)this->buffer);
804  break;
805  case RscType::Array:
806  {
807  return sizeof(RscArrayInformation);
808  break;
809  }
810  case RscType::Struct:
811  {
812  return sizeof(RscStructInformation);
813  break;
814  }
815  case RscType::SecureString:
816  default:
817  throw NotSupportedException("RscType {0} not supported.", this->GetValueType());
818  }
819 }
820 
821 }}}} // end of namespace Arp::System::Rsc::Services
822 
const char * CStr(void) const
Returns pointer to internal buffer.
Definition: RscString.hxx:109
Definition: RscGuid.hpp:17
Helper class to read a struct from an RscVariant. This class uses the struct information stored in Rs...
Definition: RscStructReader.hxx:24
Helper class to read an array of primtive types from an RscVariant. This class uses the array informa...
Definition: RscArrayWriter.hpp:21
bool operator!=(const BasicString< CharType, Alloc > &left, const BasicString< CharType, Alloc > &right)
Compares the left string to the right string on inequality.
Definition: BasicString.hxx:1788
This exception is used when a method is not supported.
Definition: NotSupportedException.hpp:14
Arp::BasicVersion Version
The Arp Version class.
Definition: TypeSystem.h:29
This exception is used when a method is not implemented yet.
Definition: NotImplementedException.hpp:14
The class contains date and time informations.
Definition: DateTime.hpp:44
Helper class to read an array of primtive types from an RscVariant. This class uses the array informa...
Definition: RscArrayReader.hpp:22
This exception is used when an invalid cast occurs.
Definition: InvalidCastException.hpp:14
const CharType * CStr() const
Gets the character data of this string.
Definition: BasicString.hxx:1507
RscType
Datatypes supported by Rsc. Values are identical with CommonRemoting::RemotingMarshalType. Only supported types of RemotingMarshalType are included.
Definition: RscType.hpp:27
Rsc container class for primitive data type, strings or information about arrays or structs...
Definition: RscVariant.hxx:39
Object type handled by Rsc as RscVariant
Specifies a version with 4 version numbers and is marshalled to .NET type System.Version.
Definition: RscVersion.hpp:20
This exception is used when a method call is invalid for object&#39;s current state.
Definition: InvalidOperationException.hpp:14
size_type Length() const
Returns the number of char elements in this string.
Definition: BasicString.hxx:1062
This exception is used when an invalid argument occurs.
Definition: ArgumentException.hpp:14
Specialized version of RscString for security context. Not implemented in this version. Wraps only RscString
Definition: RscType.hpp:18
Root namespace for the PLCnext API
RscType GetType(void) const
Gets the RscType of the contained element
Definition: RscVariant.hxx:413
Contains information to marshall an array
Definition: RscType.hpp:120
bool operator==(const BasicString< CharType, Alloc > &left, const BasicString< CharType, Alloc > &right)
Compares the left string to the right string on equality.
Definition: BasicString.hxx:1752
System components used by the System, Device, Plc or Io domains.
Contains information to marshall an struct
Definition: RscType.hpp:154
Helper class to write a struct from an RscVariant. This class uses the struct information stored in R...
Definition: RscStructWriter.hxx:18
Contains a static string with string lentgh up to N characters. The string has to be null terminated...
Definition: RscString.hxx:18
This is a small immutable wrapper around the boost::uuids::uuid class and represents a universal uniq...
Definition: Uuid.hpp:18
Namespace for basic functions of the framework
Definition: Console.hpp:14
RscVariant(RscType type=RscType::None)
Creates an empty instance of RscVariant
Definition: RscVariant.hxx:319
unsigned char byte
The Arp character type.
Definition: PrimitiveTypes.hpp:23