VariantType.h

#pragma once
 
#include <Foundation/Strings/String.h>
#include <Foundation/Types/Types.h>
 
class plReflectedClass;
class plVariant;
struct plTime;
class plUuid;
class plStringView;
struct plTypedObject;
struct plTypedPointer;
 
using plDataBuffer = plDynamicArray<plUInt8>;
using plVariantArray = plDynamicArray<plVariant>;
using plVariantDictionary = plHashTable<plString, plVariant>;
 
struct plVariantType
{
  using StorageType = plUInt8;
  enum Enum : plUInt8
  {
    Invalid = 0, 
 
    FirstStandardType = 1,
    Bool,             
    Int8,             
    UInt8,            
    Int16,            
    UInt16,           
    Int32,            
    UInt32,           
    Int64,            
    UInt64,           
    Float,            
    Double,           
    Color,            
    Vector2,          
    Vector3,          
    Vector4,          
    Vector2I,         
    Vector3I,         
    Vector4I,         
    Vector2U,         
    Vector3U,         
    Vector4U,         
    Quaternion,       
    Matrix3,          
    Matrix4,          
    Transform,        
    String,           
    StringView,       
    DataBuffer,       
    Time,             
    Uuid,             
    Angle,            
    ColorGamma,       
    HashedString,     
    TempHashedString, 
    LastStandardType,
 
    FirstExtendedType = 64,
    VariantArray,      
    VariantDictionary, 
    TypedPointer,      
    TypedObject,       
    LastExtendedType,  
 
    MAX_ENUM_VALUE = LastExtendedType,
    Default = Invalid  
  };
};
 
PL_DEFINE_AS_POD_TYPE(plVariantType::Enum);
 
struct plVariantClass
{
  enum Enum
  {
    Invalid,
    DirectCast,     
    PointerCast,    
    TypedObject,    
    CustomTypeCast, 
  };
};
 
template <typename T>
struct plVariantTypeDeduction
{
  static constexpr plVariantType::Enum value = plVariantType::Invalid;
  static constexpr bool forceSharing = false;
  static constexpr bool hasReflectedMembers = false;
  static constexpr plVariantClass::Enum classification = plVariantClass::Invalid;
 
  using StorageType = T;
};
 
#define PL_DECLARE_CUSTOM_VARIANT_TYPE(TYPE)                                               \
  template <>                                                                              \
  struct plVariantTypeDeduction<TYPE>                                                      \
  {                                                                                        \
    static constexpr plVariantType::Enum value = plVariantType::TypedObject;               \
    static constexpr bool forceSharing = false;                                            \
    static constexpr bool hasReflectedMembers = true;                                      \
    static constexpr plVariantClass::Enum classification = plVariantClass::CustomTypeCast; \
                                                                                           \
    using StorageType = TYPE;                                                              \
  };
 
#include <Foundation/Types/Implementation/VariantTypeDeduction_inl.h>