value_tuple.h

#pragma once
#include <tuple>
#include <system/object_ext.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;
    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);
    }
 
    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;
    }
 
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>
static ValueTuple<Args...> MakeTuple(Args... args)
{
    return ValueTuple<Args...>(args...);
}
 
template <typename... Args>
static ValueTuple<Args...> TieTuple(Args&&... args)
{
    return ValueTuple<Args&&...>(std::forward<Args>(args)...);
}
 
} // namespace System