value_tuple.h

#pragma once
#include <tuple>
#include <system/object_ext.h>
#include <system/tuple.h>
#include <system/details/apply.h>
#include <system/runtime/compiler_services/ituple.h>
 
namespace System {
 
struct ValueTupleTypeInfo : TypeInfoPtr
{
    ValueTupleTypeInfo()
        : TypeInfoPtr(u"System::ValueTuple")
    {}
};
 
template<typename ... Args>
class ValueTuple : public Details::BoxableObjectBase
{
    using tuple_t = std::tuple<Args...>;
    static constexpr std::size_t tuple_size = sizeof...(Args);
 
private:
    template <typename... OtherArgs> friend class ValueTuple;
    friend class BoxedValue<ValueTuple<Args...>>;
    typedef ValueTupleTypeInfo ThisTypeInfo;
 
public:
    ValueTuple()
    {
    }
 
    template <typename = std::enable_if_t<(tuple_size > 0)>>
    ValueTuple(Args... args) : m_tuple(std::forward<Args>(args)...)
    {
    }
 
    static const TypeInfo& Type()
    {
        return *static_holder<ThisTypeInfo>();
    }
 
    template <std::size_t Index>
    std::tuple_element_t<Index, tuple_t>& Item()
    {
        static_assert(Index < tuple_size, "Index out of ragnge.");
 
        return std::get<Index>(m_tuple);
    }
 
    template <std::size_t Index>
    const std::tuple_element_t<Index, tuple_t>& Item() const
    {
        static_assert(Index < tuple_size, "Index out of ragnge.");
 
        return std::get<Index>(m_tuple);
    }
 
    bool Equals(SharedPtr<Object> obj)
    {
        return System::ObjectExt::Is<ValueTuple>(obj) && Equals<0, Args...>(m_tuple, ObjectExt::Unbox<ValueTuple>(obj).m_tuple);
    }
 
    bool Equals(const ValueTuple& other)
    {
        return *this == other;
    }
 
    System::String ToString() const
    {
        System::String result = u"(";
        ToString(m_tuple, result);
        result += u")";
        return result;
    }
 
    int32_t GetHashCode() const
    {
        int32_t result = 0;
        GetHashCode(m_tuple, result);
        return result;
    }
 
    const TypeInfo& GetType() const
    {
        return Type();
    }
 
    bool operator == (const ValueTuple& other) const
    {
        return Equals<0, Args...>(m_tuple, other.m_tuple);
    }
 
    template<typename ... OtherArgs>
    ValueTuple& operator = (const ValueTuple<OtherArgs...>& otherTuple)
    {
        m_tuple = otherTuple.m_tuple;
        return *this;
    }
 
    template <typename T>
    ValueTuple& operator = (const SharedPtr<T>& deconstructiblePtr)
    {
        System::Details::apply([&](auto&... args) { deconstructiblePtr->Deconstruct(args...); }, m_tuple);
        return *this;
    }
 
    tuple_t& tuple() {return m_tuple;}
    const tuple_t& tuple() const {return m_tuple;}
 
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);
    }
 
    template<std::size_t Index = 0>
    static typename std::enable_if<Index == tuple_size, void>::type ToString(const tuple_t& tuple, System::String& result) {}
    template<std::size_t Index = 0>
    static typename std::enable_if<Index < tuple_size, void>::type ToString(const tuple_t& tuple, System::String& result)
    {
        if (Index > 0)
        {
            result += u", ";
        }
        result += ObjectExt::ToString(std::get<Index>(tuple));
        ToString<Index + 1>(tuple, result);
    }
 
    template<std::size_t Index = 0>
    static typename std::enable_if<Index == tuple_size, void>::type GetHashCode(const tuple_t& tuple, int32_t& result) {}
    template<std::size_t Index = 0>
    static typename std::enable_if<Index < tuple_size, void>::type GetHashCode(const tuple_t& tuple, int32_t& result)
    {
        result ^= (ObjectExt::GetHashCode(std::get<Index>(tuple)) << (Index * 2));
        GetHashCode<Index + 1>(tuple, result);
    }
 
private:
    tuple_t m_tuple;
};
 
template <typename... Args>
class BoxedValue<ValueTuple<Args...>> : public Runtime::CompilerServices::ITuple
{
    using ValueT = ValueTuple<Args...>;
 
    typedef System::BoxedValue<ValueTuple<Args...>> thisType;
    typedef System::BaseTypesInfo<System::Object, Runtime::CompilerServices::ITuple> baseTypes;
 
    typedef TypeInfo::BoxedValue<ValueT> ThisTypeInfo;
 
    RTTI_INFO_BOXED_CUSTOM(thisType, baseTypes);
 
public:
    BoxedValue(const ValueT& value) : m_type_hash(typeid(ValueT).hash_code()), m_value(value)
    {}
 
    const System::TypeInfo& GetType() const override
    {
        return System::ObjectType::GetType<ValueT>();
    }
 
    bool Equals(ptr obj) override
    {
        if (!obj || !obj->Is(Type()))
            return false;
 
        auto boxed = obj.Cast<BoxedValue<ValueT>>();
        return m_value == boxed->m_value;
    }
 
    int GetHashCode() const override
    {
        return m_value.GetHashCode();
    }
 
    String ToString() const override
    {
        return m_value.ToString();
    }
 
    const ValueT& unbox() const
    {
        return m_value;
    }
 
    template <class V>
    bool is() const
    {
        return typeid(V).hash_code() == m_type_hash;
    }
 
protected:
    SharedPtr<Object> idx_get(int index) const override
    {
        if (index >= get_Length())
        {
            throw IndexOutOfRangeException(u"ValueTuple");
        }
 
        Details::ReturnValueHolder return_value_holder;
        Details::FindItem(index, m_value.m_tuple, return_value_holder);
 
        return return_value_holder.value;
    }
 
    int32_t get_Length() const override
    {
        return m_value.tuple_size;
    }
 
private:
    size_t m_type_hash;
    ValueT m_value;
};
 
template <typename... Args>
ValueTuple<Args...> MakeTuple(Args... args)
{
    return ValueTuple<Args...>(args...);
}
 
template <typename... Args>
ValueTuple<Args...> TieTuple(Args&&... args)
{
    return ValueTuple<Args&&...>(std::forward<Args>(args)...);
}
 
template <std::size_t N, typename... Args>
auto Get(const ValueTuple<Args...>& tuple)
{
    return tuple.template Item<N>();
}
 
} // namespace System