IList.h

#pragma once
 
#include "Variant.h"
 
namespace sw
{
    class IList
    {
    public:
        virtual ~IList() = default;
 
    public:
        virtual std::type_index GetElementType() const noexcept = 0;
 
        virtual int Count() const noexcept = 0;
 
        virtual Variant GetVariantAt(int index) = 0;
 
        virtual Variant GetVariantAt(int index) const = 0;
 
        virtual void SetVariantAt(int index, const Variant &value) = 0;
 
        virtual void MoveVariantAt(int index, Variant &value) = 0;
    };
 
    template <typename T>
    class IListT : public IList
    {
    public:
        virtual ~IListT() = default;
 
        virtual std::type_index GetElementType() const noexcept override final
        {
            return typeid(T);
        }
 
        virtual Variant GetVariantAt(int index) override final
        {
            return Variant::MakeRef(GetAt(index));
        }
 
        virtual Variant GetVariantAt(int index) const override final
        {
            return GetVariantValueAtImpl(index);
        }
 
        virtual void SetVariantAt(int index, const Variant &value) override final
        {
            SetVariantAtImpl(index, value);
        }
 
        virtual void MoveVariantAt(int index, Variant &value) override final
        {
            MoveVariantAtImpl(index, value);
        }
 
    private:
        template <typename U = T>
        auto GetVariantValueAtImpl(int index) const
            -> typename std::enable_if<std::is_copy_constructible<U>::value, Variant>::type
        {
            return Variant{GetAt(index)};
        }
 
        template <typename U = T>
        auto GetVariantValueAtImpl(int) const
            -> typename std::enable_if<!std::is_copy_constructible<U>::value, Variant>::type
        {
            throw std::logic_error(
                "Type T must be copy constructible to get Variant by value in IListT.");
        }
 
        template <typename U = T>
        auto SetVariantAtImpl(int index, const Variant &value)
            -> typename std::enable_if<std::is_same<U, Variant>::value>::type
        {
            SetAt(index, value);
        }
 
        template <typename U = T>
        auto SetVariantAtImpl(int index, const Variant &value)
            -> typename std::enable_if<!std::is_same<U, Variant>::value>::type
        {
            if (value.IsNull()) {
                throw std::invalid_argument(
                    "Cannot set a null Variant to a non-Variant IListT.");
            }
            SetAt(index, value.DynamicCast<T>());
        }
 
        template <typename U = T>
        auto MoveVariantAtImpl(int index, Variant &value)
            -> typename std::enable_if<std::is_same<U, Variant>::value>::type
        {
            SetAt(index, std::move(value));
        }
 
        template <typename U = T>
        auto MoveVariantAtImpl(int index, Variant &value)
            -> typename std::enable_if<!std::is_same<U, Variant>::value>::type
        {
            if (value.IsNull()) {
                throw std::invalid_argument(
                    "Cannot set a null Variant to a non-Variant IListT.");
            }
            SetAt(index, std::move(value.DynamicCast<T>()));
        }
 
    public:
        virtual int Count() const noexcept = 0;
 
        virtual T &GetAt(int index) = 0;
 
        virtual const T &GetAt(int index) const = 0;
 
        virtual void SetAt(int index, const T &value) = 0;
 
        virtual void SetAt(int index, T &&value) = 0;
    };
}