Merge pull request #2103 from eugeneko/refactor-variant

Make Variant able to store any type.

Source/Urho3D/Core/Context.cpp

@@ -196,7 +196,8 @@ void Context::RemoveSubsystem(StringHash objectType)
 void Context::RegisterAttribute(StringHash objectType, const AttributeInfo& attr)
 {
     // None or pointer types can not be supported
-    if (attr.type_ == VAR_NONE || attr.type_ == VAR_VOIDPTR || attr.type_ == VAR_PTR)
+    if (attr.type_ == VAR_NONE || attr.type_ == VAR_VOIDPTR || attr.type_ == VAR_PTR
+        || attr.type_ == VAR_CUSTOM_HEAP || attr.type_ == VAR_CUSTOM_STACK)
     {
         URHO3D_LOGWARNING("Attempt to register unsupported attribute type " + Variant::GetTypeName(attr.type_) + " to class " +
             GetTypeName(objectType));

Source/Urho3D/Core/Variant.cpp

@@ -67,6 +67,8 @@ static const char* typeNames[] =
     "Rect",
     "IntVector3",
     "Int64",
+    "CustomPtr",
+    "Custom",
     0
 };
 
@@ -74,6 +76,14 @@ static_assert(sizeof(typeNames) / sizeof(const char*) == MAX_VAR_TYPES + 1, "Var
 
 Variant& Variant::operator =(const Variant& rhs)
 {
+    // Handle custom types separately
+    if (rhs.IsCustom())
+    {
+        SetCustomVariantValue(*rhs.GetCustomVariantValuePtr());
+        return *this;
+    }
+
+    // Assign other types here
     SetType(rhs.GetType());
 
     switch (type_)
@@ -141,6 +151,8 @@ bool Variant::operator ==(const Variant& rhs) const
 {
     if (type_ == VAR_VOIDPTR || type_ == VAR_PTR)
         return GetVoidPtr() == rhs.GetVoidPtr();
+    else if (IsCustom() && rhs.IsCustom())
+        return GetCustomVariantValuePtr()->Compare(*rhs.GetCustomVariantValuePtr());
     else if (type_ != rhs.type_)
         return false;
 
@@ -168,7 +180,7 @@ bool Variant::operator ==(const Variant& rhs) const
         return value_.vector4_ == rhs.value_.vector4_;
 
     case VAR_QUATERNION:
-        return value_.quaterion_ == rhs.value_.quaterion_;
+        return value_.quaternion_ == rhs.value_.quaternion_;
 
     case VAR_COLOR:
         return value_.color_ == rhs.value_.color_;
@@ -389,6 +401,32 @@ void Variant::SetBuffer(const void* data, unsigned size)
         memcpy(&buffer[0], data, size);
 }
 
+void Variant::SetCustomVariantValue(const CustomVariantValue& value)
+{
+    // Assign value if destination is already initialized
+    if (CustomVariantValue* custom = GetCustomVariantValuePtr())
+    {
+        if (custom->GetTypeInfo() == value.GetTypeInfo())
+        {
+            custom->Assign(value);
+            return;
+        }
+    }
+
+    if (value.GetSize() <= VARIANT_VALUE_SIZE)
+    {
+        SetType(VAR_CUSTOM_STACK);
+        value_.customValueStack_.~CustomVariantValue();
+        value.Clone(&value_.customValueStack_);
+    }
+    else
+    {
+        SetType(VAR_CUSTOM_HEAP);
+        delete value_.customValueHeap_;
+        value_.customValueHeap_ = value.Clone();
+    }
+}
+
 VectorBuffer Variant::GetVectorBuffer() const
 {
     return VectorBuffer(type_ == VAR_BUFFER ? value_.buffer_ : emptyBuffer);
@@ -425,7 +463,7 @@ String Variant::ToString() const
         return value_.vector4_.ToString();
 
     case VAR_QUATERNION:
-        return value_.quaterion_.ToString();
+        return value_.quaternion_.ToString();
 
     case VAR_COLOR:
         return value_.color_.ToString();
@@ -470,6 +508,10 @@ String Variant::ToString() const
     case VAR_RECT:
         return value_.rect_.ToString();
 
+    case VAR_CUSTOM_HEAP:
+    case VAR_CUSTOM_STACK:
+        return GetCustomVariantValuePtr()->ToString();
+
     default:
         // VAR_RESOURCEREF, VAR_RESOURCEREFLIST, VAR_VARIANTVECTOR, VAR_STRINGVECTOR, VAR_VARIANTMAP
         // Reference string serialization requires typehash-to-name mapping from the context. Can not support here
@@ -504,7 +546,7 @@ bool Variant::IsZero() const
         return value_.vector4_ == Vector4::ZERO;
 
     case VAR_QUATERNION:
-        return value_.quaterion_ == Quaternion::IDENTITY;
+        return value_.quaternion_ == Quaternion::IDENTITY;
 
     case VAR_COLOR:
         // WHITE is considered empty (i.e. default) color in the Color class definition
@@ -569,6 +611,10 @@ bool Variant::IsZero() const
     case VAR_RECT:
         return value_.rect_ == Rect::ZERO;
 
+    case VAR_CUSTOM_HEAP:
+    case VAR_CUSTOM_STACK:
+        return GetCustomVariantValuePtr()->IsZero();
+
     default:
         return true;
     }
@@ -625,6 +671,14 @@ void Variant::SetType(VariantType newType)
         delete value_.matrix4_;
         break;
 
+    case VAR_CUSTOM_HEAP:
+        delete value_.customValueHeap_;
+        break;
+
+    case VAR_CUSTOM_STACK:
+        value_.customValueStack_.~CustomVariantValue();
+        break;
+
     default:
         break;
     }
@@ -677,6 +731,16 @@ void Variant::SetType(VariantType newType)
         value_.matrix4_ = new Matrix4();
         break;
 
+    case VAR_CUSTOM_HEAP:
+        // Must be initialized later
+        value_.customValueHeap_ = nullptr;
+        break;
+
+    case VAR_CUSTOM_STACK:
+        // Initialize virtual table with void custom object
+        new (&value_.customValueStack_) CustomVariantValue();
+        break;
+
     default:
         break;
     }

Source/Urho3D/Core/Variant.h

@@ -30,6 +30,8 @@
 #include "../Math/Rect.h"
 #include "../Math/StringHash.h"
 
+#include <typeinfo>
+
 namespace Urho3D
 {
 
@@ -63,6 +65,9 @@ enum VariantType
     VAR_RECT,
     VAR_INTVECTOR3,
     VAR_INT64,
+    // Add new types here
+    VAR_CUSTOM_HEAP,
+    VAR_CUSTOM_STACK,
     MAX_VAR_TYPES
 };
 
@@ -165,6 +170,115 @@ struct URHO3D_API ResourceRefList
     bool operator !=(const ResourceRefList& rhs) const { return type_ != rhs.type_ || names_ != rhs.names_; }
 };
 
+/// Custom variant value. This type is not abstract to store it in the VariantValue by value.
+class CustomVariantValue
+{
+    // GetValuePtr expects that CustomVariantValue is always convertible to CustomVariantValueImpl<T>.
+    template <class T> friend class CustomVariantValueImpl;
+
+private:
+    /// Construct from type info.
+    CustomVariantValue(const std::type_info& typeInfo) : typeInfo_(typeInfo) {}
+
+public:
+    /// Construct empty.
+    CustomVariantValue() : typeInfo_(typeid(void)) { }
+    /// Destruct.
+    virtual ~CustomVariantValue() { }
+    /// Get the type info.
+    const std::type_info& GetTypeInfo() const { return typeInfo_; }
+    /// Return whether the specified type is stored.
+    template <class T> bool IsType() const { return GetTypeInfo() == typeid(T); }
+    /// Return pointer to value of the specified type. Return null pointer if type does not match.
+    template <class T> T* GetValuePtr();
+    /// Return const pointer to value of the specified type. Return null pointer if type does not match.
+    template <class T> const T* GetValuePtr() const;
+
+    /// Assign value.
+    virtual bool Assign(const CustomVariantValue& rhs) { return false; }
+    /// Clone.
+    virtual CustomVariantValue* Clone() const { return nullptr; }
+    /// Placement clone.
+    virtual void Clone(void* dest) const { }
+    /// Get size.
+    virtual unsigned GetSize() const { return sizeof(CustomVariantValue); }
+
+    /// Compare to another custom value.
+    virtual bool Compare(const CustomVariantValue& rhs) const { (void)rhs; return false; }
+    /// Compare to zero.
+    virtual bool IsZero() const { return false; }
+    /// Convert custom value to string.
+    virtual String ToString() const { return String::EMPTY; }
+
+private:
+    /// Type info.
+    const std::type_info& typeInfo_;
+};
+
+/// Custom variant value type traits. Specialize the template to implement custom type behavior.
+template <class T> struct CustomVariantValueTraits
+{
+    /// Compare types.
+    static bool Compare(const T& lhs, const T& rhs) { (void)lhs, rhs; return false; }
+    /// Check whether the value is zero.
+    static bool IsZero(const T& value) { (void)value; return false; }
+    /// Convert type to string.
+    static String ToString(const T& value) { (void)value; return String::EMPTY; }
+};
+
+/// Custom variant value implementation.
+template <class T> class CustomVariantValueImpl final : public CustomVariantValue
+{
+public:
+    /// This class name.
+    using ClassName = CustomVariantValueImpl<T>;
+    /// Type traits.
+    using Traits = CustomVariantValueTraits<T>;
+    /// Construct from value.
+    CustomVariantValueImpl(const T& value) : CustomVariantValue(typeid(T)), value_(value) {}
+    /// Set value.
+    void SetValue(const T& value) { value_ = value; }
+    /// Get value.
+    T& GetValue() { return value_; }
+    /// Get const value.
+    const T& GetValue() const { return value_; }
+
+    /// Assign value.
+    virtual bool Assign(const CustomVariantValue& rhs) override
+    {
+        if (const T* rhsValue = rhs.GetValuePtr<T>())
+        {
+            SetValue(*rhsValue);
+            return true;
+        }
+        return false;
+    }
+    /// Clone.
+    virtual CustomVariantValue* Clone() const override { return new ClassName(value_); }
+    /// Placement clone.
+    virtual void Clone(void* dest) const override { new (dest) ClassName(value_); }
+    /// Get size.
+    virtual unsigned GetSize() const override { return sizeof(ClassName); }
+
+    /// Compare to another custom value.
+    virtual bool Compare(const CustomVariantValue& rhs) const override
+    {
+        const T* rhsValue = rhs.GetValuePtr<T>();
+        return rhsValue && Traits::Compare(value_, *rhsValue);
+    }
+    /// Compare to zero.
+    virtual bool IsZero() const override { return Traits::IsZero(value_);}
+    /// Convert custom value to string.
+    virtual String ToString() const override { return Traits::ToString(value_); }
+
+private:
+    /// Value.
+    T value_;
+};
+
+/// Make custom variant value.
+template <typename T> CustomVariantValueImpl<T> MakeCustomValue(const T& value) { return CustomVariantValueImpl<T>(value); }
+
 /// Size of variant value. 16 bytes on 32-bit platform, 32 bytes on 64-bit platform.
 static const unsigned VARIANT_VALUE_SIZE = sizeof(void*) * 4;
 
@@ -178,7 +292,7 @@ union VariantValue
     Vector2 vector2_;
     Vector3 vector3_;
     Vector4 vector4_;
-    Quaternion quaterion_;
+    Quaternion quaternion_;
     Color color_;
     String string_;
     PODVector<unsigned char> buffer_;
@@ -198,6 +312,8 @@ union VariantValue
     Rect rect_;
     IntVector3 intVector3_;
     long long int64_;
+    CustomVariantValue* customValueHeap_;
+    CustomVariantValue customValueStack_;
 
     /// Construct uninitialized.
     VariantValue() { }
@@ -402,6 +518,13 @@ public:
         *this = value;
     }
 
+    /// Construct from custom value.
+    template <class T>
+    Variant(const CustomVariantValueImpl<T>& value)
+    {
+        *this = value;
+    }
+
     /// Construct from type and value.
     Variant(const String& type, const String& value)
     {
@@ -504,7 +627,7 @@ public:
     }
 
     /// Assign from a double.
-    Variant& operator = (double rhs)
+    Variant& operator =(double rhs)
     {
         SetType(VAR_DOUBLE);
         value_.double_ = rhs;
@@ -539,7 +662,7 @@ public:
     Variant& operator =(const Quaternion& rhs)
     {
         SetType(VAR_QUATERNION);
-        value_.quaterion_ = rhs;
+        value_.quaternion_ = rhs;
         return *this;
     }
 
@@ -690,6 +813,14 @@ public:
         return *this;
     }
 
+    /// Assign from custom value.
+    template <class T>
+    Variant& operator =(const CustomVariantValueImpl<T>& value)
+    {
+        SetCustomVariantValue(value);
+        return *this;
+    }
+
     /// Test for equality with another variant.
     bool operator ==(const Variant& rhs) const;
 
@@ -735,7 +866,7 @@ public:
     /// Test for equality with a quaternion. To return true, both the type and value must match.
     bool operator ==(const Quaternion& rhs) const
     {
-        return type_ == VAR_QUATERNION ? value_.quaterion_ == rhs : false;
+        return type_ == VAR_QUATERNION ? value_.quaternion_ == rhs : false;
     }
 
     /// Test for equality with a color. To return true, both the type and value must match.
@@ -952,6 +1083,10 @@ public:
     void FromString(VariantType type, const char* value);
     /// Set buffer type from a memory area.
     void SetBuffer(const void* data, unsigned size);
+    /// Set custom value.
+    void SetCustomVariantValue(const CustomVariantValue& value);
+    /// Set custom value.
+    template <class T> void SetCustom(const T& value) { SetCustomVariantValue(MakeCustomValue<T>(value)); }
 
     /// Return int or zero on type mismatch. Floats and doubles are converted.
     int GetInt() const
@@ -1057,7 +1192,7 @@ public:
     /// Return quaternion or identity on type mismatch.
     const Quaternion& GetQuaternion() const
     {
-        return type_ == VAR_QUATERNION ? value_.quaterion_ : Quaternion::IDENTITY;
+        return type_ == VAR_QUATERNION ? value_.quaternion_ : Quaternion::IDENTITY;
     }
 
     /// Return color or default on type mismatch. Vector4 is aliased to Color if necessary.
@@ -1158,6 +1293,43 @@ public:
         return type_ == VAR_MATRIX4 ? *value_.matrix4_ : Matrix4::IDENTITY;
     }
 
+    /// Return pointer to custom variant value.
+    CustomVariantValue* GetCustomVariantValuePtr()
+    {
+        return const_cast<CustomVariantValue*>(const_cast<const Variant*>(this)->GetCustomVariantValuePtr());
+    }
+
+    /// Return const pointer to custom variant value.
+    const CustomVariantValue* GetCustomVariantValuePtr() const
+    {
+        if (type_ == VAR_CUSTOM_HEAP)
+            return value_.customValueHeap_;
+        else if (type_ == VAR_CUSTOM_STACK)
+            return &value_.customValueStack_;
+        else
+            return nullptr;
+    }
+
+    /// Return custom variant value or default-constructed on type mismatch.
+    template <class T> T GetCustom() const
+    {
+        if (const CustomVariantValue* value = GetCustomVariantValuePtr())
+        {
+            if (value->IsType<T>())
+                return *value->GetValuePtr<T>();
+        }
+        return T();
+    }
+
+    /// Return true if specified custom type is stored in the variant.
+    template <class T> bool IsCustomType() const
+    {
+        if (const CustomVariantValue* custom = GetCustomVariantValuePtr())
+            return custom->IsType<T>();
+        else
+            return false;
+    }
+
     /// Return value's type.
     VariantType GetType() const { return type_; }
 
@@ -1171,6 +1343,9 @@ public:
     /// Return true when the variant is empty (i.e. not initialized yet).
     bool IsEmpty() const { return type_ == VAR_NONE; }
 
+    /// Return true when the variant stores custom type.
+    bool IsCustom() const { return type_ == VAR_CUSTOM_HEAP || type_ == VAR_CUSTOM_STACK; }
+
     /// Return the value, template version.
     template <class T> T Get() const;
 
@@ -1189,6 +1364,17 @@ public:
     /// Return a pointer to a modifiable variant map or null on type mismatch.
     VariantMap* GetVariantMapPtr() { return type_ == VAR_VARIANTMAP ? &value_.variantMap_ : 0; }
 
+    /// Return a pointer to a modifiable custom variant value or null on type mismatch.
+    template <class T> T* GetCustomPtr()
+    {
+        if (const CustomVariantValue* value = GetCustomVariantValuePtr())
+        {
+            if (value->IsType<T>())
+                return value->GetValuePtr<T>();
+        }
+        return nullptr;
+    }
+
     /// Return name for variant type.
     static String GetTypeName(VariantType type);
     /// Return variant type from type name.
@@ -1366,4 +1552,25 @@ template <> URHO3D_API Matrix3x4 Variant::Get<Matrix3x4>() const;
 
 template <> URHO3D_API Matrix4 Variant::Get<Matrix4>() const;
 
+// Implementations
+template <class T> T* CustomVariantValue::GetValuePtr()
+{
+    if (IsType<T>())
+    {
+        auto impl = static_cast<CustomVariantValueImpl<T>*>(this);
+        return &impl->GetValue();
+    }
+    return nullptr;
+}
+
+template <class T> const T* CustomVariantValue::GetValuePtr() const
+{
+    if (IsType<T>())
+    {
+        auto impl = static_cast<const CustomVariantValueImpl<T>*>(this);
+        return &impl->GetValue();
+    }
+    return nullptr;
+}
+
 }

Source/Urho3D/IO/Deserializer.cpp

@@ -386,8 +386,14 @@ Variant Deserializer::ReadVariant(VariantType type)
     case VAR_DOUBLE:
         return Variant(ReadDouble());
 
+        // Deserializing custom values is not supported. Return empty
+    case VAR_CUSTOM_HEAP:
+    case VAR_CUSTOM_STACK:
+        ReadUInt();
+        return Variant::EMPTY;
+
     default:
-        return Variant();
+        return Variant::EMPTY;
     }
 }
 

Source/Urho3D/IO/Serializer.cpp

@@ -286,9 +286,11 @@ bool Serializer::WriteVariantData(const Variant& value)
     case VAR_BUFFER:
         return WriteBuffer(value.GetBuffer());
 
-        // Serializing pointers is not supported. Write null
+        // Serializing pointers and custom values is not supported. Write null
     case VAR_VOIDPTR:
     case VAR_PTR:
+    case VAR_CUSTOM_HEAP:
+    case VAR_CUSTOM_STACK:
         return WriteUInt(0);
 
     case VAR_RESOURCEREF: