object_ext.h

 
#pragma once
 
#include "defines.h"
#include <system/object_type.h>
#include <system/enum.h>
#include <system/boxed_enum.h>
#include <system/text/string_builder.h>
#include <system/details/pointer_collection_helpers.h>
#include <system/get_hash_code.h>
 
namespace System { namespace Collections { class IList; }
template <typename> class ReadOnlySpan;
}
 
namespace System
{
 
class ObjectExt : public ObjectType
{
public:
    template <typename T>
    static int GetHashCode(const T& obj)
    {
        return System::GetHashCode<T>(obj);
    }
 
    template<typename T, typename T2>
    static typename std::enable_if<IsExceptionWrapper<T>::value, bool>::type Equals(const T& obj, const T2& another)
    {
        if (obj.IsNull())
            System::Detail::SmartPtrCounter::ThrowNullReferenceException();
        return obj.Equals(another);
    }
 
    template<typename T, typename T2>
    static typename std::enable_if<IsSmartPtr<T>::value, bool>::type Equals(const T& obj, const T2& another)
    {
        return obj->Equals(another);
    }
 
    template<typename T, typename T2>
    static typename std::enable_if<!IsExceptionWrapper<T>::value && !IsSmartPtr<T>::value && !std::is_scalar<T>::value, bool>::type Equals(T obj, const T2& another)
    {
        return obj.Equals(another);
    }
 
    template<typename T, typename T2>
    static typename std::enable_if<!IsSmartPtr<T>::value && std::is_scalar<T>::value, bool>::type Equals(const T& obj, const T2& another)
    {
        return (obj == another);
    }
 
    template<size_t N>
    static bool Equals(const char_t (&obj)[N], String another)
    {
        return another == obj;
    }
 
    inline static bool Equals(const System::String& obj, const System::String& another)
    {
        return obj == nullptr && another == nullptr || obj != nullptr && another != nullptr && obj.Equals(another);
    }
 
    static inline String ToString(const char_t * obj)
    {
        return String(obj);
    }
 
    template<typename T>
    static inline String ToString(const Nullable<T> & obj)
    {
        return (obj.IsNull() ? u"" : ToString(obj.get_Value()));
    }
 
    template<typename T>
    static typename std::enable_if<std::is_enum<T>::value, String>::type ToString(const T& obj)
    {
        String str = Enum<T>::GetName(obj);
        return !str.IsNullOrEmpty() ? str : System::Convert::ToString(static_cast<typename std::underlying_type<T>::type>(obj));
    }
 
    template<typename T>
    static typename std::enable_if<IsSmartPtr<T>::value, String>::type ToString(const T& obj)
    {
        return obj->ToString();
    }
 
    template<typename T>
    static typename std::enable_if<IsSmartPtr<T>::value || std::is_pointer<T>::value || IsExceptionWrapper<T>::value, String>::type ToString(T& obj)
    {
        return obj->ToString();
    }
 
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value && std::is_scalar<T>::value && !std::is_enum<T>::value, String>::type ToString(T& obj)
    {
        return System::Convert::ToString(obj);
    }
 
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value && std::is_scalar<T>::value && !std::is_enum<T>::value, String>::type ToString(T&& obj)
    {
        return System::Convert::ToString(obj);
    }
 
    template<typename T>
    static typename std::enable_if<!IsExceptionWrapper<T>::value && !IsSmartPtr<T>::value && !std::is_scalar<T>::value && !IsNullable<T>::value, String>::type ToString(T& obj)
    {
        return obj.ToString();
    }
 
    template <typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value && !std::is_scalar<T>::value && !IsNullable<T>::value, String>::type ToString(const T& obj)
    {
        return obj.ToString();
    }
 
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value && !std::is_scalar<T>::value && !IsNullable<T>::value && !std::is_reference<T>::value, String>::type ToString(T&& obj)
    {
        return obj.ToString();
    }
 
    template<typename T>
    static typename std::enable_if<std::is_enum<T>::value, System::SmartPtr<System::Object>>::type Box(const T& value)
    {
        return System::MakeObject<BoxedEnum<T>>(value);
    }
 
    template<typename T>
    static typename std::enable_if<!std::is_enum<T>::value && !IsNullable<T>::value, System::SmartPtr<System::Object>>::type Box(const T& value)
    {
        return System::MakeObject<BoxedValue<T>>(value);
    }
 
    template<typename T>
    static typename std::enable_if <IsNullable<T>::value, System::SmartPtr<System::Object>>::type Box(const T& value)
    {
        if (value == nullptr)
            return nullptr;
 
        return System::MakeObject<BoxedValue<typename T::ValueType>>(value.get_Value());
    }
 
    template<typename T>
    static typename std::enable_if<std::is_enum<T>::value, T>::type Unbox(const SmartPtr<Object>& obj)
    {
        using UT = typename std::underlying_type<T>::type;
 
        if (obj && obj->Is(BoxedEnum<T>::Type()))
        {
            auto boxed = obj.template Cast<BoxedEnum<T>>();
            return static_cast<T>(boxed->unbox());
        }
        using UT = typename std::underlying_type<T>::type;
        if (obj && obj->Is(ObjectExt::GetType<UT>()))
        {
            auto boxed = obj.Cast<BoxedValue<UT>>();
            return static_cast<T>(boxed->unbox());
        }
 
 
        throw InvalidCastException();
    }
 
    template<class T>
    static typename std::enable_if<!std::is_enum<T>::value && detail::has_operator_equal<T>::value, T>::type Unbox(const SmartPtr<Object>& obj)
    {
        if (obj)
        {
            if (obj->Is(ObjectExt::GetType<T>()))
            {
                auto boxed = obj.template Cast<BoxedValue<T>>();
                return boxed->unbox();
            }
 
            throw InvalidCastException();
        }
        throw NullReferenceException();
    }
 
    template<class T>
    static typename std::enable_if<!std::is_enum<T>::value && !detail::has_operator_equal<T>::value, T>::type Unbox(const SmartPtr<Object>& obj)
    {
            
        if (obj && obj->Is(BoxedValue<T>::Type()))
        {
            auto boxed = obj.template Cast<BoxedValue<T>>();
            return boxed->unbox();
        }
        
        throw InvalidCastException();
    }
 
    template<class T, class E>
    static typename std::enable_if<std::is_enum<E>::value && std::numeric_limits<T>::is_integer, T>::type Unbox(E e)
    {
        return static_cast<T>(e);
    }
 
    template<class T, class E>
    static typename std::enable_if<std::is_enum<E>::value && std::is_enum<T>::value, T>::type Unbox(E e)
    {
        return static_cast<T>(e);
    }
 
    static ASPOSECPP_SHARED_API String UnboxStringSafe(const SmartPtr<Object>& obj);
 
    template<class T>
    static Nullable<T> UnboxToNullable(const SmartPtr<Object>& obj, bool safe = true)
    {
        if (obj)
        {
            if (obj->Is(ObjectExt::GetType<T>()))
            {
                auto boxed = obj.template Cast<BoxedValue<T>>();
                return Nullable<T>(boxed->unbox());
            }
        }
 
        if (!obj || safe)
            return Nullable<T>(nullptr);
 
        throw InvalidCastException();
    }
 
    template <class T>
    static typename std::enable_if<System::IsBoxable<T>::value, bool>::type Is(const T& obj)
    {
        return true;
    }
 
    template<class T, class U>
    static typename std::enable_if<std::is_convertible<T, Object>::value && std::is_final<T>::value &&
                                   !System::IsBoxable<T>::value && System::IsSmartPtr<U>::value,
        bool>::type Is(const U& obj)
    {
        if (obj == nullptr)
            return false;
 
        return typeid(*obj.get()) == typeid(T);
    }
 
    template<class T, class U>
    static typename std::enable_if<std::is_convertible<T, Object>::value&& !std::is_final<T>::value &&
                                   !System::IsBoxable<T>::value && System::IsSmartPtr<U>::value,
        bool>::type Is(const U& obj)
    {
        if (!obj)
            return false;
 
        return dynamic_cast<T*>(obj.get()) != nullptr;
    }
 
    template<class T>
    static typename std::enable_if<std::is_convertible<T, Object>::value,
        bool>::type Is(const Object& obj)
    {
        return obj.Is(T::Type());
    }
 
    template<class T>
    static typename std::enable_if<!std::is_convertible<T, Object>::value,
        bool>::type Is(const Object& obj)
    {
        return false;
    }
 
    template<class T, class U>
    static typename std::enable_if<IsSmartPtr<T>::value, bool>::type Is(const SmartPtr<U>& obj)
    {
        if (!obj)
            return false;
 
        return dynamic_cast<typename T::Pointee_*>(obj.get()) != nullptr;
    }
 
    template<class T, class U>
    static typename std::enable_if<IsExceptionWrapper<T>::value, bool>::type Is(const ExceptionWrapper<U>& obj)
    {
        if (obj == nullptr)
            return false;
 
        return Is<SmartPtr<typename T::ExceptionType>>(obj.Get());
    }
 
    template<class T>
    static typename std::enable_if<IsNullable<T>::value, bool>::type Is(const SmartPtr<Object>& obj)
    {
        if (!obj)
            return false;
 
        if (obj->Is(System::ObjectExt::GetType<typename T::ValueType>()))
            return true;
 
        return false;
    }
 
    template<class T>
    static typename std::enable_if<
        System::IsBoxable<T>::value && !IsNullable<T>::value && !std::is_enum<T>::value && detail::has_operator_equal<T>::value,
        bool
    >::type Is(const SmartPtr<Object>& obj)
    {
        if (!obj)
            return false;
 
        if (obj->Is(System::ObjectExt::GetType<T>()))
        {
            return true;
        }
 
        if (obj->Is(Nullable<T>::Type()))
        {
            auto boxed = obj.Cast<BoxedValue<Nullable<T>>>();
            return !boxed->unbox().IsNull();
        }
 
        return false;
    }
 
    template<class T>
    static typename std::enable_if<
        System::IsBoxable<T>::value && !IsNullable<T>::value && !std::is_enum<T>::value && !detail::has_operator_equal<T>::value,
        bool
    >::type Is(const SmartPtr<Object>& obj)
    {
        if (!obj)
            return false;
 
        if (obj->Is(TypeInfo::BoxedValueType<T>()))
        {
            return true;
        }
 
        return false;
    }
 
    template <class T, class V>
    static typename std::enable_if<
        System::IsBoxable<T>::value && !IsNullable<T>::value && !std::is_enum<T>::value && !std::is_same<V, Object>::value,
        bool>::type Is(const SmartPtr<V>& obj)
    {
        return dynamic_cast<T*>(obj.get()) != nullptr;
    }
 
    template<class T, class U>
    static typename std::enable_if<std::is_enum<T>::value, bool>::type Is(const SmartPtr<U>& obj)
    {
        if (!obj)
            return false;
 
        if (obj->Is(TypeInfo::BoxedValueType<T>()))
            return Enum<T>::IsDefined(Unbox<T>(obj));
 
        return false;
    }
 
    template<class T, class U>
    static typename std::enable_if<std::is_enum<T>::value, bool>::type Is(const WeakPtr<U>& obj)
    {
        if (!obj)
            return false;
 
        if (obj->Is(TypeInfo::BoxedValueType<T>()))
            return Enum<T>::IsDefined(Unbox<T>(obj));
 
        return false;
    }
 
private:
    template<class T, class U>
    static bool IsImpl()
    {
        TypeInfo typeU = ObjectExt::GetType<U>();
        TypeInfo typeT = ObjectExt::GetType<T>();
        return typeU == typeT || typeU.IsSubclassOf(typeT);
    }
 
public:
    template<class T, class U>
    static bool Is(const Nullable<U>& value)
    {
        if (value == nullptr)
            return false;
 
        return IsImpl<T, U>();
    }
 
    template<class T>
    static bool Is(const char16_t* str)
    {
        if (str == nullptr)
            return false;
 
        return IsImpl<T, System::String>();
    }
 
    template<class T>
    static bool Is(int32_t value)
    {
        ASPOSE_UNUSED(value);
 
        return IsImpl<T, System::Int32>();
    }
 
    static ASPOSECPP_SHARED_API bool IsBoxedValue(const SmartPtr<Object>& obj);
 
    template<typename T>
    static typename std::enable_if<IsSmartPtr<T>::value, System::SmartPtr<Object> >::type UnknownToObject(T obj)
    {
        return obj.template Cast<Object>();
    }
 
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value, System::SmartPtr<Object> >::type UnknownToObject(const T& obj)
    {
        return Box<T>(obj);
    }
 
    template<typename T>
    static typename std::enable_if<IsSmartPtr<T>::value, T>::type ObjectToUnknown(SmartPtr<Object> obj)
    {
        return obj.template Cast<typename T::Pointee_>();
    }
 
    template<typename T>
    static typename std::enable_if<!IsSmartPtr<T>::value, T>::type ObjectToUnknown(SmartPtr<Object> obj)
    {
        return System::ObjectExt::Unbox<T>(obj);
    }
        
    template<typename T>
    static typename std::enable_if<!std::is_scalar<T>::value, bool>::type UnknownIsNull(T obj)
    {
        return obj == nullptr;
    }
 
    template<typename T>
    static typename std::enable_if<std::is_scalar<T>::value, bool>::type UnknownIsNull(T obj)
    {
        return false;
    }
    
    template<typename RT1, typename RT2, typename F>
    static typename std::conditional<std::is_convertible<RT2, RT1>::value, RT1, RT2>::type CoalesceInternal(RT1 value, F func)
    {
        return value != nullptr ? value : func();
    }
 
 
    template<typename T0, typename T1>
    static auto Coalesce(T0 value, T1 func)
    {
        using retval_t = System::Details::ResultOf<T1>;
        return CoalesceInternal<T0, retval_t, typename std::function<retval_t()>>(value, func);
    }
 
    template<typename T0, typename T1>
    static T0 Coalesce(System::Nullable<T0> value, T1 func)
    {
        return !value.IsNull() ? value.get_Value() : func();
    }
 
    template <typename T0, typename T1>
    static auto CoalesceAssign(T0& value, T1 func) -> T0&
    {
        if (value == nullptr)
        {
            value = func();
        }
        return value;
    }
 
    template<typename T>
    static SmartPtr<System::BoxedValueBase> BoxEnum(T enumValue)
    {
        return SmartPtr<System::BoxedValueBase>(new System::BoxedEnum<T>(enumValue));
    }
    
    template<typename To, typename ...From>
    static typename std::enable_if<(std::is_fundamental<To>::value), std::array<To, sizeof...(From)>>::type ArrayInitializerCast(From ...args)
    {
        return std::array<To, sizeof...(From)>({ static_cast<To>(args)... });
    }
 
    static ASPOSECPP_SHARED_API SmartPtr<System::Collections::IList> CastToIList(const SmartPtr<Object>& obj);
 
    template<typename T>
    static typename std::enable_if<System::IsBoxable<T>::value, System::SharedPtr<System::Object>>::type ExplicitCastToObject(const T& value)
    {
        return ObjectExt::Box(value);
    }
 
    template<typename T>
    static typename std::enable_if<System::IsSmartPtr<T>::value, System::SharedPtr<System::Object>>::type ExplicitCastToObject(const T& value)
    {
        return value;
    }
};
 
template<>
inline bool ObjectExt::Equals<float, float>(const float& obj, const float& another)
{
    return (std::isnan(obj) && std::isnan(another)) ? true : obj == another;
}
 
template<>
inline bool ObjectExt::Equals<double, double>(const double& obj, const double& another)
{
    return (std::isnan(obj) && std::isnan(another)) ? true : obj == another;
}
 
template<>
inline SmartPtr<Object> ObjectExt::Box<String>(const String& value)
{
    return value.IsNull() ? nullptr : MakeObject<BoxedValue<String>>(value);
}
 
template<>
inline String ObjectExt::Unbox<String>(const SmartPtr<Object>& obj)
{
    if (obj == nullptr)
        return String();
 
    if (obj && obj->Is(String::Type()))
    {
        auto boxed = obj.Cast<BoxedValue<String>>();
        return boxed->unbox();
    }
 
    throw InvalidCastException();
}
 
namespace Details {
 
template<typename T>
struct IsObjectArray : std::false_type {};
template <typename O>
struct IsObjectArray<System::Array<SmartPtr<O>>> : std::is_base_of<System::Object, O> {};
template <>
struct IsObjectArray<System::Array<String>> : std::true_type {};
template <typename A>
struct IsObjectArray<SmartPtr<A>> : IsObjectArray<A> {};
 
 
template <typename Source, typename Result>
struct CastType
{
    static constexpr bool None = std::is_same<Source, Result>::value;
 
    static constexpr bool StaticArithmetic =
        (std::is_enum<Source>::value || std::is_arithmetic<Source>::value) &&
        (std::is_enum<Result>::value || std::is_arithmetic<Result>::value);
    static constexpr bool StaticIntPtr =
        (std::is_same<Source, IntPtr>::value && (std::is_arithmetic<Result>::value || std::is_pointer<Result>::value)) ||
        (std::is_same<Result, IntPtr>::value && (std::is_arithmetic<Source>::value || std::is_pointer<Source>::value));
    static constexpr bool StaticString = std::is_same<Result, String>::value && std::is_constructible<String, Source>::value ||
        std::is_same<Source, String>::value && std::is_same<Result, System::ReadOnlySpan<char16_t>>::value;
    static constexpr bool Static = !None && (StaticArithmetic || StaticIntPtr || StaticString);
 
    static constexpr bool Exception = !None &&
        IsExceptionWrapper<Source>::value && IsExceptionWrapper<Result>::value &&
        (std::is_convertible<Result, Source>::value || std::is_base_of<Result, Source>::value);
    static constexpr bool ObjectToException = !None &&
        std::is_same<SharedPtr<System::Object>, Source>::value && IsExceptionWrapper<Result>::value;
 
    static constexpr bool Array = !None && IsObjectArray<Result>::value && IsObjectArray<Source>::value;
 
    static constexpr bool ToSmartPointer = std::is_base_of<System::Object, Result>::value &&
                                      !IsExceptionWrapper<Result>::value && !IsBoxable<Result>::value;
    static constexpr bool RawPointer = ToSmartPointer && std::is_pointer<Source>::value &&
                                       std::is_base_of<Object, std::remove_pointer_t<Source>>::value;
    static constexpr bool Pointer = !None && !Array && ToSmartPointer && IsSmartPtr<Source>::value;
    static constexpr bool PointerToPointer = !None && !Array && IsSmartPtr<Source>::value && IsSmartPtr<Result>::value;
 
    static constexpr bool UnboxingToNullable =
        (std::is_same<Source, SmartPtr<Object>>::value || std::is_same<Source, std::nullptr_t>::value) &&
        IsNullable<Result>::value;
 
    static constexpr bool InterfaceUnboxingToNullable =
        !std::is_same<Source, SmartPtr<Object>>::value && IsSmartPtr<Source>::value && IsNullable<Result>::value;
 
    static constexpr bool InterfaceUnboxing = !std::is_same<Source, SmartPtr<Object>>::value &&
                                              IsSmartPtr<Source>::value && !IsNullable<Result>::value &&
                                              std::is_base_of<Details::BoxableObjectBase, Result>::value;
 
    static constexpr bool NullableBoxing = !UnboxingToNullable && (std::is_same<Result, Nullable<Source>>::value ||
                                           (IsNullable<Result>::value && std::is_same<Source, std::nullptr_t>::value));
    static constexpr bool NullableUnboxing = std::is_same<Source, Nullable<Result>>::value;
 
    static constexpr bool BoxingCommon = !None && (std::is_base_of<Object, Result>::value || IsSmartPtr<Result>::value);
    static constexpr bool EnumBoxing = BoxingCommon && std::is_enum<Source>::value;
    static constexpr bool HeapifyBoxing = std::is_same<Result, SharedPtr<Source>>::value;
    static constexpr bool InterfaceBoxing = BoxingCommon && !HeapifyBoxing && !std::is_same<Result, Object>::value &&
                                          std::is_base_of<Details::BoxableObjectBase, Source>::value &&
                                            !BoxedValueDetail::ImplementsInterface_v<Source, Result>;
    static constexpr bool Boxing = BoxingCommon && !EnumBoxing && !HeapifyBoxing && !InterfaceBoxing && IsBoxable<Source>::value;
    static constexpr bool StringBoxing = BoxingCommon && !Boxing && !Pointer && !std::is_same<Source, std::nullptr_t>::value &&
        std::is_constructible<String, Source>::value;
 
    static constexpr bool Unboxing =
        !UnboxingToNullable && !InterfaceUnboxing && IsSmartPtr<Source>::value && IsBoxable<Result>::value;
 
    static constexpr bool UnboxingToString = std::is_same<Result, String>::value && std::is_same<Source, SmartPtr<Object>>::value;
 
    static constexpr bool Null = !Static && !UnboxingToNullable && !NullableBoxing &&
                                 std::is_same<Source, std::nullptr_t>::value;
 
    static constexpr bool InvalidUnboxing = Unboxing && !InterfaceUnboxingToNullable && !InterfaceUnboxing && !std::is_same<Source, SmartPtr<Object>>::value;
};
 
} // namespace Details
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::None, Result> ExplicitCast(const Source& value)
{
    return value;
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Static, Result> ExplicitCast(const Source& value)
{
    return Result(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Exception, Result> ExplicitCast(const Source& value)
{
    return value.Get().template Cast<typename Result::ExceptionType, std::true_type>() ? Result(value.Get())
                                                                                       : Result(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::ObjectToException, Result> ExplicitCast(const Source& value)
{
    auto exception_ptr = value.template Cast<typename Result::ExceptionType, std::true_type>();
    return exception_ptr ? Result(exception_ptr.template Cast<System::Details_Exception, std::true_type>())
                         : Result(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Pointer, typename CastResult<Result>::type>
    ExplicitCast(const Source& value)
{
    return value.template Cast<Result, std::true_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::RawPointer, typename CastResult<std::remove_pointer_t<Result>>::type>
    ExplicitCast(Source value)
{
    return ExplicitCast<Result>(SmartPtr<std::remove_pointer_t<Source>>(value));
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::PointerToPointer, Result>
    ExplicitCast(const Source& value)
{
    return ExplicitCast<typename Result::Pointee_>(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::UnboxingToNullable, Result>
    ExplicitCast(const Source& value)
{
    return ObjectExt::UnboxToNullable<typename Result::ValueType>(value, false);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::NullableBoxing, Result> ExplicitCast(const Source& value)
{
    return Result(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::NullableUnboxing, Result> ExplicitCast(const Source& value)
{
    if (value == nullptr)
        throw NullReferenceException(u"Can not unbox null value");
 
    return static_cast<Result>(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::EnumBoxing, SmartPtr<BoxedValueBase>>
    ExplicitCast(const Source& value)
{
    return ObjectExt::BoxEnum(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::HeapifyBoxing, typename CastResult<Result>::type>
    ExplicitCast(const Source& value)
{
    return MakeObject<Source>(value).template Cast<typename Result::Pointee_, std::true_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::InterfaceBoxing, typename CastResult<Result>::type>
    ExplicitCast(const Source& value)
{
    return MakeObject<Source>(value).template Cast<Result, std::true_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Boxing, typename CastResult<Result>::type>
    ExplicitCast(const Source& value)
{
    return ObjectExt::Box(value).template Cast<typename CastResult<Result>::type::Pointee_, std::true_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::StringBoxing, typename CastResult<Result>::type>
    ExplicitCast(const Source& value)
{
    return ObjectExt::Box<String>(value).template Cast<typename CastResult<Result>::type::Pointee_, std::true_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::InterfaceUnboxing, Result> ExplicitCast(const Source& value)
{
    return *(value.template Cast<Result, std::true_type>());
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Unboxing, Result> ExplicitCast(const Source& value)
{
    return ObjectExt::Unbox<Result>(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Null, typename CastResult<Result>::type> ExplicitCast(const Source& value)
{
    return typename CastResult<Result>::type(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Array, typename CastResult<Result>::type> ExplicitCast(const Source& value)
{
    if (!value)
        return nullptr;
 
    auto result = MakeArray<typename Result::ValueType>(value->data().size());
    std::transform(value->data().begin(), value->data().end(), result->data().begin(),
                   [](const auto& value) {return ExplicitCast<typename Result::ValueType>(value);});
 
    return result;
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Static, Result> AsCast(const Source& value)
{
    return Result(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::None, Result> AsCast(const Source& value)
{
    return value;
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Exception, Result> AsCast(const Source& value)
{
    return value.Get().template Cast<typename Result::ExceptionType, std::false_type>() ? Result(value.Get())
                                                                                        : Result(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::ObjectToException, Result> AsCast(const Source& value)
{
    auto exception_ptr = value.template Cast<typename Result::ExceptionType, std::false_type>();
    return exception_ptr ? Result(exception_ptr.template Cast<System::Details_Exception, std::false_type>())
                         : Result(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Pointer, typename CastResult<Result>::type>
    AsCast(const Source& value)
{
    return value.template Cast<Result, std::false_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::PointerToPointer, Result>
    AsCast(const Source& value)
{
    return AsCast<typename Result::Pointee_>(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::UnboxingToNullable, Result>
    AsCast(const Source& value)
{
    return ObjectExt::UnboxToNullable<typename Result::ValueType>(value, true);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::InterfaceUnboxingToNullable, Result> AsCast(const Source& value)
{
    Result result;
    if (ObjectExt::Is<typename Result::ValueType>(value))
    {
        result = *(value.template Cast<typename Result::ValueType, std::false_type>());
    }
    return result;
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::InvalidUnboxing, Result> AsCast(const Source& value)
{
    return Default<Result>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::NullableBoxing, Result> AsCast(const Source& value)
{
    return Result(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::InterfaceBoxing, typename CastResult<Result>::type>
    AsCast(const Source& value)
{
    if (!ObjectExt::Is<Result>(value))
    {
        return nullptr;
    }
 
    return MakeObject<Source>(value).template Cast<Result, std::false_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Boxing, typename CastResult<Result>::type>
    AsCast(const Source& value)
{
    return ObjectExt::Box(value).template Cast<typename CastResult<Result>::type::Pointee_, std::false_type>();
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::UnboxingToString, Result> AsCast(const Source& value)
{
    return ObjectExt::UnboxStringSafe(value);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Null, typename CastResult<Result>::type> AsCast(const Source& value)
{
    return typename CastResult<Result>::type(nullptr);
}
 
template <typename Result, typename Source>
std::enable_if_t<Details::CastType<Source, Result>::Array, typename CastResult<Result>::type> AsCast(const Source& value)
{
    if (!value)
        return nullptr;
 
    auto result = MakeArray<typename Result::ValueType>(value->data().size());
    auto d_it = result->data().begin();
    auto s_it = value->data().begin();
    while (s_it != value->data().end())
    {
        auto& source_element = *(s_it++);
        auto& result_element = *(d_it++);
 
        result_element = AsCast<typename Result::ValueType>(source_element);
 
        // Fail entire cast if any element fails
        if (source_element != nullptr && result_element == nullptr)
            return nullptr;
    }
 
    return result;
}
 
template <typename T0, typename T1>
static auto SafeInvoke(T0&& expr, T1&& func)
{
    // The type which 'func' actually returns
    using retval_t = decltype(func(expr));
 
    // The type which function SafeInvoke will return. Non-nullable types will be wrapped by 'Nullable<>' class template.
    using result_t = typename std::conditional<
        std::is_base_of<Details::BoxableObjectBase, retval_t>::value || std::is_arithmetic<retval_t>::value || std::is_enum<retval_t>::value,
        System::Nullable<retval_t>,
        retval_t>::type;
 
    return expr != nullptr ? result_t(func(expr)) : result_t(nullptr);
}
 
} // namespace System