Variant.h

#pragma once
 
#include "Reflection.h"
 
namespace sw
{
    class Variant final : public IEqualityComparable<Variant>
    {
    private:
        std::unique_ptr<DynamicObject> _obj;
 
        DynamicObject *(*_cloner)(const DynamicObject &) = nullptr;
 
    public:
        Variant() = default;
 
        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;
        }
 
        operator bool() const noexcept
        {
            return _obj != nullptr;
        }
 
        bool IsNull() const noexcept
        {
            return _obj == nullptr;
        }
 
        bool Equals(const Variant &other) const noexcept
        {
            return _obj == other._obj;
        }
 
        void Reset()
        {
            _obj.reset();
            _cloner = nullptr;
        }
 
        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() const noexcept
        {
            return _obj.get();
        }
 
        template <typename T>
        bool IsType(T **pout = nullptr)
        {
            if (_obj == nullptr) {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            } else {
                return _obj->IsType<T>(pout);
            }
        }
 
        template <typename T>
        bool IsType(const T **pout = nullptr) const
        {
            if (_obj == nullptr) {
                if (pout != nullptr) {
                    *pout = nullptr;
                }
                return false;
            } else {
                return _obj->IsType<T>(pout);
            }
        }
 
        template <typename T>
        T &DynamicCast()
        {
            ThrowBadCastIfEmpty();
            return _obj->DynamicCast<T>();
        }
 
        template <typename T>
        const T &DynamicCast() const
        {
            ThrowBadCastIfEmpty();
            return _obj->DynamicCast<T>();
        }
 
        template <typename T>
        T &UnsafeCast()
        {
            ThrowBadCastIfEmpty();
            return _obj->UnsafeCast<T>();
        }
 
        template <typename T>
        const T &UnsafeCast() const
        {
            ThrowBadCastIfEmpty();
            return _obj->UnsafeCast<T>();
        }
 
    private:
        void ThrowBadCastIfEmpty() const
        {
            if (_obj == nullptr) {
                throw std::bad_cast();
            }
        }
 
        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.");
            };
        }
    };
}