tuple.h

#pragma once
#include <tuple>
#include <system/object.h>
#include <system/object_ext.h>
#include <system/runtime/compiler_services/ituple.h>
 
namespace System {
 
template<typename ...Args>
class Tuple;
 
namespace Details {
 
template <typename T>
struct IsTuple { static constexpr bool value = false; };
 
template <typename T>
struct IsTuple<SharedPtr<Tuple<T>>> { static constexpr bool value = true; };
 
static constexpr int32_t MaxTupleIndex = 7;
 
template<std::size_t Index = 0, typename... Args>
typename std::enable_if<Index == MaxTupleIndex, void>::type
    CheckRest()
{
    if(!IsTuple<typename std::tuple_element<Index, std::tuple<Args...>>::type>::value)
    {
        throw ArgumentException(u"The last element of an 8-tuple must be of type Tuple");
    }
}
 
template<std::size_t Index = 0, typename... Args>
typename std::enable_if<Index != MaxTupleIndex, void>::type
    CheckRest()
{
    static_assert(Index <= MaxTupleIndex, "The Tuple class can store only 8 items");
}
 
struct ReturnValueHolder
{
    template<typename T>
    typename std::enable_if<!IsSmartPtr<T>::value, void>::type Hold(T& returnValue)
    {
        value = ObjectExt::Box(returnValue);
    }
 
    template<typename T>
    typename std::enable_if<IsSmartPtr<T>::value, void>::type Hold(T& returnValue)
    {
        value = returnValue;
    }
 
    SharedPtr<Object> value;
};
 
template<std::size_t I = 0, typename RetHolder, typename... Tp>
typename std::enable_if<I == sizeof...(Tp), void>::type
    FindItem(int, const std::tuple<Tp...>& , RetHolder&)
{ }
 
template<std::size_t Index = 0, typename RetHolder, typename... Args>
typename std::enable_if< Index < sizeof...(Args), void>::type
    FindItem(int index, const std::tuple<Args...>& tuple, RetHolder& holder)
{
    if (index == 0)
    {
        holder.Hold(std::get<Index>(tuple));
    }
    else
    {
        FindItem<Index + 1, RetHolder, Args...>(index - 1, tuple, holder);
    }
}
 
} // namespace Details
 
template<typename ... Args>
class Tuple : public Runtime::CompilerServices::ITuple
{
private:
    RTTI_INFO_TEMPLATE_CLASS(System::Tuple<Args...>, System::BaseTypesInfo<Runtime::CompilerServices::ITuple>);
 
    using tuple_t = std::tuple<Args...>;
 
public:
    Tuple(Args... args)
        : m_tuple(std::forward<Args>(args)...)
    {
        Details::CheckRest<std::tuple_size<tuple_t>::value - 1, Args...>();
    }
 
    template<int32_t Index>
    typename std::tuple_element<Index, tuple_t>::type get_Item() const
    {
        return std::get<Index>(m_tuple);
    }
    
    bool Equals(SharedPtr<Object> obj) override
    {
        if (obj.get() == this)
        {
            return true;
        }
 
        auto tuple = System::AsCast<Tuple<Args...>>(obj);
        if (tuple == nullptr)
        {
            return false;
        }
        
        return Equals<0, Args...>(m_tuple, tuple->m_tuple);
    }
 
protected: // System::Runtime::CompilerServices::ITuple
    
    SharedPtr<Object> idx_get(int index) const override
    {
        if (index >= get_Length())
        {
            throw IndexOutOfRangeException(u"Tuple");
        }
 
        Details::ReturnValueHolder return_value_holder;
        Details::FindItem(index, m_tuple, return_value_holder);
        
        return return_value_holder.value;
    }
 
    int32_t get_Length() const override
    {
        return static_cast<int32_t>(std::tuple_size<tuple_t>{});
    }
 
private:
    template<std::size_t Index = 0, typename... Types>
    static typename std::enable_if<Index == sizeof...(Types), bool>::type
        Equals(const std::tuple<Types...>& a, const std::tuple<Types...>& b)
    {
        return true;
    }
 
    template<std::size_t Index = 0, typename... Types>
    static typename std::enable_if<Index < sizeof...(Types), bool>::type
        Equals(const std::tuple<Types...>& a, const std::tuple<Types...>& b)
    {
        if (!ObjectExt::Equals(std::get<Index>(a), std::get<Index>(b)))
        {
            return false;
        }
 
        return Equals<Index + 1, Types...>(a, b);
    }
 
private:
    tuple_t m_tuple;
};
 
class TupleFactory
{
public:
    template<typename ... Args>
    static SharedPtr<Tuple<Args...>> Create(Args... args)
    {
        return MakeObject<Tuple<Args...>>(std::forward<Args>(args)...);
    }
 
    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename TRest>
    static SharedPtr<Tuple<T1, T2, T3, T4, T5, T6, T7, SharedPtr<Tuple<TRest>>>> Create(T1 item1, T2 item2, T3 item3, T4 item4, T5 item5, T6 item6, T7 item7, TRest rest)
    {
        return MakeObject<Tuple<T1, T2, T3, T4, T5, T6, T7, SharedPtr<Tuple<TRest>>>>(item1, item2, item3, item4, item5, item6, item7, MakeObject<Tuple<TRest>>(rest));
    }
};
 
} // namespace System