Variant.h

#pragma once
 
#include <Foundation/Algorithm/HashingUtils.h>
#include <Foundation/Containers/DynamicArray.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Math/Declarations.h>
#include <Foundation/Strings/HashedString.h>
#include <Foundation/Threading/AtomicInteger.h>
#include <Foundation/Types/TypedPointer.h>
#include <Foundation/Types/Types.h>
#include <Foundation/Types/VariantType.h>
 
#include <Foundation/Reflection/Implementation/DynamicRTTI.h>
#include <Foundation/Utilities/ConversionUtils.h>
 
class plRTTI;
 
struct plTypedObject
{
  PL_DECLARE_POD_TYPE();
  const void* m_pObject = nullptr;
  const plRTTI* m_pType = nullptr;
 
  bool operator==(const plTypedObject& rhs) const
  {
    return m_pObject == rhs.m_pObject;
  }
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plTypedObject&);
};
 
class PL_FOUNDATION_DLL plVariant
{
public:
  using Type = plVariantType;
  template <typename T>
  using TypeDeduction = plVariantTypeDeduction<T>;
 
  struct StringWrapper
  {
    PL_ALWAYS_INLINE StringWrapper(const char* szStr)
      : m_str(szStr)
    {
    }
    const char* m_str;
  };
 
  plVariant(); // [tested]
 
  plVariant(const plVariant& other); // [tested]
 
  plVariant(plVariant&& other) noexcept; // [tested]
 
  plVariant(const bool& value);
  plVariant(const plInt8& value);
  plVariant(const plUInt8& value);
  plVariant(const plInt16& value);
  plVariant(const plUInt16& value);
  plVariant(const plInt32& value);
  plVariant(const plUInt32& value);
  plVariant(const plInt64& value);
  plVariant(const plUInt64& value);
  plVariant(const float& value);
  plVariant(const double& value);
  plVariant(const plColor& value);
  plVariant(const plVec2& value);
  plVariant(const plVec3& value);
  plVariant(const plVec4& value);
  plVariant(const plVec2I32& value);
  plVariant(const plVec3I32& value);
  plVariant(const plVec4I32& value);
  plVariant(const plVec2U32& value);
  plVariant(const plVec3U32& value);
  plVariant(const plVec4U32& value);
  plVariant(const plQuat& value);
  plVariant(const plMat3& value);
  plVariant(const plMat4& value);
  plVariant(const plTransform& value);
  plVariant(const char* value);
  plVariant(const plString& value);
  plVariant(const plUntrackedString& value);
  plVariant(const plStringView& value, bool bCopyString = true);
  plVariant(const plDataBuffer& value);
  plVariant(const plTime& value);
  plVariant(const plUuid& value);
  plVariant(const plAngle& value);
  plVariant(const plColorGammaUB& value);
  plVariant(const plHashedString& value);
  plVariant(const plTempHashedString& value);
 
  plVariant(const plVariantArray& value);
  plVariant(const plVariantDictionary& value);
 
  plVariant(const plTypedPointer& value);
  plVariant(const plTypedObject& value);
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::CustomTypeCast, int> = 0>
  plVariant(const T& value);
 
  template <typename T>
  plVariant(const T* value);
 
  plVariant(void* value, const plRTTI* pType);
 
  void CopyTypedObject(const void* value, const plRTTI* pType); // [tested]
 
  void MoveTypedObject(void* value, const plRTTI* pType); // [tested]
 
  ~plVariant();
 
  void operator=(const plVariant& other); // [tested]
 
  void operator=(plVariant&& other) noexcept; // [tested]
 
  template <typename T>
  void operator=(const T& value); // [tested]
 
  bool operator==(const plVariant& other) const; // [tested]
 
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plVariant&);
 
  template <typename T>
  bool operator==(const T& other) const; // [tested]
 
#if PL_DISABLED(PL_USE_CPP20_OPERATORS)
  template <typename T>
  bool operator!=(const T& other) const // [tested]
  {
    return !(*this == other);
  }
#endif
 
  bool IsValid() const; // [tested]
 
  bool IsNumber() const; // [tested]
 
  bool IsFloatingPoint() const; // [tested]
 
  bool IsString() const; // [tested]
 
  bool IsHashedString() const;
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::DirectCast, int> = 0>
  bool IsA() const; // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::PointerCast, int> = 0>
  bool IsA() const; // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::TypedObject, int> = 0>
  bool IsA() const; // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::CustomTypeCast, int> = 0>
  bool IsA() const; // [tested]
 
  Type::Enum GetType() const; // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::DirectCast, int> = 0>
  const T& Get() const; // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::PointerCast, int> = 0>
  T Get() const;        // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::TypedObject, int> = 0>
  const T Get() const;  // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::CustomTypeCast, int> = 0>
  const T& Get() const; // [tested]
 
  plTypedPointer GetWriteAccess(); // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::DirectCast, int> = 0>
  T& GetWritable();                // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::PointerCast, int> = 0>
  T GetWritable();                 // [tested]
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::CustomTypeCast, int> = 0>
  T& GetWritable();                // [tested]
 
 
  const void* GetData() const; // [tested]
 
  const plRTTI* GetReflectedType() const; // [tested]
 
  const plVariant operator[](plUInt32 uiIndex) const; // [tested]
 
  const plVariant operator[](StringWrapper key) const; // [tested]
 
  template <typename T>
  bool CanConvertTo() const; // [tested]
 
  bool CanConvertTo(Type::Enum type) const; // [tested]
 
  template <typename T>
  T ConvertTo(plResult* out_pConversionStatus = nullptr) const; // [tested]
 
  plVariant ConvertTo(Type::Enum type, plResult* out_pConversionStatus = nullptr) const; // [tested]
 
  template <typename Functor, class... Args>
  static auto DispatchTo(Functor& ref_functor, Type::Enum type, Args&&... args); // [tested]
 
  plUInt64 ComputeHash(plUInt64 uiSeed = 0) const;
 
private:
  friend class plVariantHelper;
  friend struct CompareFunc;
  friend struct GetTypeFromVariantFunc;
 
  struct SharedData
  {
    void* m_Ptr;
    const plRTTI* m_pType;
    plAtomicInteger32 m_uiRef = 1;
    PL_ALWAYS_INLINE SharedData(void* pPtr, const plRTTI* pType)
      : m_Ptr(pPtr)
      , m_pType(pType)
    {
    }
    virtual ~SharedData() = default;
    virtual SharedData* Clone() const = 0;
  };
 
  template <typename T>
  class TypedSharedData : public SharedData
  {
  private:
    T m_t;
 
  public:
    PL_ALWAYS_INLINE TypedSharedData(const T& value, const plRTTI* pType = nullptr)
      : SharedData(&m_t, pType)
      , m_t(value)
    {
    }
 
    virtual SharedData* Clone() const override
    {
      return PL_DEFAULT_NEW(TypedSharedData<T>, m_t, m_pType);
    }
  };
 
  class RTTISharedData : public SharedData
  {
  public:
    RTTISharedData(void* pData, const plRTTI* pType);
 
    ~RTTISharedData();
 
    virtual SharedData* Clone() const override;
  };
 
  struct InlinedStruct
  {
    constexpr static int DataSize = 4 * sizeof(float) - sizeof(void*);
    plUInt8 m_Data[DataSize];
    const plRTTI* m_pType;
  };
 
  union Data
  {
    float f[4];
    SharedData* shared;
    InlinedStruct inlined;
  } m_Data;
 
  plUInt32 m_uiType : 31;
  plUInt32 m_bIsShared : 1; // NOLINT(pl*)
 
  template <typename T>
  void InitInplace(const T& value);
 
  template <typename T>
  void InitShared(const T& value);
 
  template <typename T>
  void InitTypedObject(const T& value, plTraitInt<0>);
  template <typename T>
  void InitTypedObject(const T& value, plTraitInt<1>);
 
  void InitTypedPointer(void* value, const plRTTI* pType);
 
  void Release();
  void CopyFrom(const plVariant& other);
  void MoveFrom(plVariant&& other);
 
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::DirectCast, int> = 0>
  const T& Cast() const;
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::PointerCast, int> = 0>
  T Cast() const;
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::TypedObject, int> = 0>
  const T Cast() const;
  template <typename T, typename std::enable_if_t<plVariantTypeDeduction<T>::classification == plVariantClass::CustomTypeCast, int> = 0>
  const T& Cast() const;
 
  static bool IsNumberStatic(plUInt32 type);
  static bool IsFloatingPointStatic(plUInt32 type);
  static bool IsStringStatic(plUInt32 type);
  static bool IsHashedStringStatic(plUInt32 type);
  static bool IsVector2Static(plUInt32 type);
  static bool IsVector3Static(plUInt32 type);
  static bool IsVector4Static(plUInt32 type);
 
  // Needed to prevent including plRTTI in plVariant.h
  static bool IsDerivedFrom(const plRTTI* pType1, const plRTTI* pType2);
  static plStringView GetTypeName(const plRTTI* pType);
 
  template <typename T>
  T ConvertNumber() const;
};
 
template <typename T>
PL_ALWAYS_INLINE T plDynamicCast(const plVariant& variant)
{
  if (variant.IsA<T>())
  {
    return variant.Get<T>();
  }
 
  return nullptr;
}
 
// Simple math operator overloads. An invalid variant is returned if the given variants have incompatible types.
PL_FOUNDATION_DLL plVariant operator+(const plVariant& a, const plVariant& b);
PL_FOUNDATION_DLL plVariant operator-(const plVariant& a, const plVariant& b);
PL_FOUNDATION_DLL plVariant operator*(const plVariant& a, const plVariant& b);
PL_FOUNDATION_DLL plVariant operator/(const plVariant& a, const plVariant& b);
 
namespace plMath
{
  PL_FOUNDATION_DLL plVariant Lerp(const plVariant& a, const plVariant& b, double fFactor);
} // namespace plMath
 
#include <Foundation/Types/Implementation/VariantHelper_inl.h>
 
#include <Foundation/Types/Implementation/Variant_inl.h>