Variant.h

#pragma once
 
#include "Reflection.h"
 
namespace sw
{
    struct ObjectRef final {
        DynamicObject *ptr;
    };
 
    class Variant final
    {
    private:
        std::unique_ptr<DynamicObject> _obj;
 
        DynamicObject *(*_cloner)(const DynamicObject &) = nullptr;
 
    public:
        Variant() = default;
 
        Variant(std::nullptr_t) noexcept
        {
        }
 
        Variant(ObjectRef ref)
        {
            if (ref.ptr != nullptr) {
                _obj.reset(new BoxedObject<ObjectRef>(ref));
                ResetCloner<ObjectRef>();
            }
        }
 
        template <
            typename T,
            typename std::enable_if<!std::is_same<Variant, typename std::decay<T>::type>::value, int>::type = 0>
        Variant(T &&obj)
        {
            Reset(std::forward<T>(obj));
        }
 
        Variant(const Variant &other)
        {
            if (other._obj != nullptr) {
                _obj.reset(other._cloner(*other._obj));
                _cloner = other._cloner;
            }
        }
 
        Variant(Variant &&other) noexcept
            : _obj(std::move(other._obj)), _cloner(other._cloner)
        {
            other._cloner = nullptr;
        }
 
        Variant &operator=(const Variant &other)
        {
            Reset(other);
            return *this;
        }
 
        Variant &operator=(Variant &&other) noexcept
        {
            Reset(std::move(other));
            return *this;
        }
 
        explicit operator bool() const noexcept
        {
            return _obj != nullptr;
        }
 
        bool IsNull() const noexcept
        {
            return _obj == nullptr;
        }
 
        bool HasValue() const noexcept
        {
            return _obj != nullptr;
        }
 
        bool ReferenceEquals(const Variant &other) const noexcept
        {
            const DynamicObject *a = Object();
            const DynamicObject *b = other.Object();
 
            if (a == nullptr && b == nullptr) {
                return true;
            }
            if (a == nullptr || b == nullptr) {
                return false;
            }
            return a->ReferenceEquals(*b);
        }
 
        void Reset() noexcept
        {
            _obj.reset();
            _cloner = nullptr;
        }
 
        void Reset(std::nullptr_t) noexcept
        {
            Reset();
        }
 
        void Reset(ObjectRef ref)
        {
            if (ref.ptr == nullptr) {
                Reset();
            } else {
                _obj.reset(new BoxedObject<ObjectRef>(ref));
                ResetCloner<ObjectRef>();
            }
        }
 
        void Reset(const Variant &other)
        {
            if (this == &other) {
                return;
            }
 
            if (other._obj == nullptr) {
                Reset();
            } else {
                _obj.reset(other._cloner(*other._obj));
                _cloner = other._cloner;
            }
        }
 
        void Reset(Variant &&other) noexcept
        {
            if (this != &other) {
                _obj          = std::move(other._obj);
                _cloner       = other._cloner;
                other._cloner = nullptr;
            }
        }
 
        template <typename T>
        auto Reset(T &&obj)
            -> typename std::enable_if<
                !std::is_same<Variant, typename std::decay<T>::type>::value &&
                std::is_base_of<DynamicObject, typename std::decay<T>::type>::value>::type
        {
            using U = typename std::decay<T>::type;
            _obj.reset(new U(std::forward<T>(obj)));
            ResetCloner<U>();
        }
 
        template <typename T>
        auto Reset(T &&obj)
            -> typename std::enable_if<
                !std::is_same<Variant, typename std::decay<T>::type>::value &&
                !std::is_base_of<DynamicObject, typename std::decay<T>::type>::value>::type
        {
            using U = typename std::decay<T>::type;
            _obj.reset(new BoxedObject<U>(std::forward<T>(obj)));
            ResetCloner<U>();
        }
 
        DynamicObject *Object() noexcept
        {
            if (_obj == nullptr) {
                return nullptr;
            }
 
            ObjectRef *ref = nullptr;
 
            if (_obj->IsType<ObjectRef>(&ref)) {
                return ref->ptr;
            }
            return _obj.get();
        }
 
        const DynamicObject *Object() const noexcept
        {
            if (_obj == nullptr) {
                return nullptr;
            }
 
            const ObjectRef *ref = nullptr;
 
            if (_obj->IsType<ObjectRef>(&ref)) {
                return ref->ptr;
            }
            return _obj.get();
        }
 
        std::type_index GetType() const
        {
            const DynamicObject *p = Object();
            return p == nullptr ? typeid(void) : p->GetType();
        }
 
        template <typename T>
        bool IsType(T **pout = nullptr)
        {
            DynamicObject *p = Object();
 
            if (p == nullptr) {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
            return p->IsType<T>(pout);
        }
 
        template <typename T>
        bool IsType(const T **pout = nullptr) const
        {
            const DynamicObject *p = Object();
 
            if (p == nullptr) {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            }
            return p->IsType<T>(pout);
        }
 
        template <typename T>
        T &DynamicCast()
        {
            DynamicObject *p = Object();
 
            if (p == nullptr) {
                throw std::bad_cast();
            }
            return p->DynamicCast<T>();
        }
 
        template <typename T>
        const T &DynamicCast() const
        {
            const DynamicObject *p = Object();
 
            if (p == nullptr) {
                throw std::bad_cast();
            }
            return p->DynamicCast<T>();
        }
 
        template <typename T>
        T &UnsafeCast()
        {
            DynamicObject *p = Object();
 
            if (p == nullptr) {
                throw std::bad_cast();
            }
            return p->UnsafeCast<T>();
        }
 
        template <typename T>
        const T &UnsafeCast() const
        {
            const DynamicObject *p = Object();
 
            if (p == nullptr) {
                throw std::bad_cast();
            }
            return p->UnsafeCast<T>();
        }
 
    private:
        template <typename T>
        auto ResetCloner()
            -> typename std::enable_if<std::is_copy_constructible<T>::value && std::is_base_of<DynamicObject, T>::value>::type
        {
            _cloner = [](const DynamicObject &other) -> DynamicObject * {
                return new T(other.UnsafeCast<T>());
            };
        }
 
        template <typename T>
        auto ResetCloner()
            -> typename std::enable_if<std::is_copy_constructible<T>::value && !std::is_base_of<DynamicObject, T>::value>::type
        {
            _cloner = [](const DynamicObject &other) -> DynamicObject * {
                return new BoxedObject<T>(other.UnsafeCast<BoxedObject<T>>());
            };
        }
 
        template <typename T>
        auto ResetCloner()
            -> typename std::enable_if<!std::is_copy_constructible<T>::value>::type
        {
            _cloner = [](const DynamicObject &other) -> DynamicObject * {
                throw std::runtime_error("Object is not copy constructible.");
            };
        }
 
    public:
        template <typename T, typename... Args>
        static auto MakeVal(Args &&...args)
            -> typename std::enable_if<
                !std::is_same<T, Variant>::value &&
                    std::is_base_of<DynamicObject, T>::value,
                Variant>::type
        {
            Variant v;
            v._obj.reset(new T(std::forward<Args>(args)...));
            v.ResetCloner<T>();
            return v;
        }
 
        template <typename T, typename... Args>
        static auto MakeVal(Args &&...args)
            -> typename std::enable_if<
                !std::is_same<T, Variant>::value &&
                    !std::is_base_of<DynamicObject, T>::value,
                Variant>::type
        {
            Variant v;
            v._obj.reset(new BoxedObject<T>(std::forward<Args>(args)...));
            v.ResetCloner<T>();
            return v;
        }
 
        static Variant MakeRef(Variant &v)
        {
            DynamicObject *p = v.Object();
            return p == nullptr ? Variant{} : MakeRef(*p);
        }
 
        template <typename T>
        static auto MakeRef(T &obj)
            -> typename std::enable_if<
                !std::is_same<T, Variant>::value &&
                    std::is_base_of<DynamicObject, T>::value,
                Variant>::type
        {
            Variant v;
            v._obj.reset(new BoxedObject<ObjectRef>(ObjectRef{&obj}));
            v.ResetCloner<ObjectRef>();
            return v;
        }
 
        template <typename T>
        static auto MakeRef(T &obj)
            -> typename std::enable_if<
                !std::is_same<T, Variant>::value &&
                    !std::is_base_of<DynamicObject, T>::value,
                Variant>::type
        {
            Variant v;
            v._obj.reset(new BoxedObject<T>(BoxedObject<T>::MakeRef(&obj)));
            v.ResetCloner<T>();
            return v;
        }
    };
}