detail.h

 
#pragma once
 
#include <type_traits>
#include <utility>
#include <ostream>
 
namespace System { namespace detail {
 
template <class From, class To, class = decltype(static_cast<To*>((From*)nullptr))>
std::true_type IsStaticCastable_Internal(int);
template <class From, class To>
std::false_type IsStaticCastable_Internal(...);
 
template <class From, class To>
using is_static_castable = decltype(IsStaticCastable_Internal<From, To>(0));
 
template <typename From, typename To, bool convertible = is_static_castable<From, To>::value>
struct cast_statically_or_dynamically
{
    static To* cast(From *pointer) { return dynamic_cast<To*>(pointer); }
};
 
template <typename From, typename To>
struct cast_statically_or_dynamically<From, To, true>
{
    static To* cast(From *pointer) { return static_cast<To*>(pointer); }
};
 
 
template <template <class ...T> class TypeToBe>
struct Is_A_Internal
{
    static std::false_type Invoke(...);
    template <typename ...P>
    static std::true_type Invoke(const TypeToBe<P...>*);
 
    template <typename Tested>
    using type = decltype(Invoke((Tested*)nullptr));
};
 
template <typename Tested, template <class ...T> class TypeToBe>
struct is_a : public Is_A_Internal<TypeToBe>::template type<Tested> {};
template <typename Tested, template <class ...T> class TypeToBe>
struct is_a<Tested&, TypeToBe> : public Is_A_Internal<TypeToBe>::template type<Tested> {};
template <typename Tested, template <class ...T> class TypeToBe>
struct is_a<Tested&&, TypeToBe> : public Is_A_Internal<TypeToBe>::template type<Tested> {};
 
 
template<typename T, typename Sfinae = void>
struct has_operator_less : std::false_type {};
template<typename T>
struct has_operator_less<
    T
    , decltype((void)(std::declval<T&>() < std::declval<T&>()))
> : std::true_type{};
 
 
template <class T>
struct has_operator_equal_impl
{
    template <class U>
    static auto test(U*) -> decltype(std::declval<U>() == std::declval<U>());
    template <typename>
    static auto test(...) -> std::false_type;
 
    using type = typename std::is_same<bool, decltype(test<T>(0))>::type;
};
 
template <class T>
struct has_operator_equal : has_operator_equal_impl<T>::type {};
 
template <class T, class U>
struct has_no_operator_equal : std::integral_constant<bool, !has_operator_equal<T>::value && !has_operator_equal<U>::value> {};
 
template<typename T, typename Sfinae = void>
struct has_method_equals : std::false_type {};
template<typename T>
struct has_method_equals<
    T
    , decltype((void)(std::declval<T&>().Equals(std::declval<T&>())))
> : std::true_type{};
 
 
template<typename T>
using has_only_method_equals = std::integral_constant<bool, has_method_equals<T>::value && !has_operator_equal<T>::value>;
 
 
template<typename T, typename Sfinae = void>
struct has_method_gethashcode : std::false_type {};
template<typename T>
struct has_method_gethashcode<
    T
    , decltype((void)(std::declval<T&>().GetHashCode()))
> : std::true_type {};
 
 
template<typename T, typename Sfinae = void>
struct has_ref_method_gethashcode : std::false_type {};
template<typename T>
struct has_ref_method_gethashcode<
    T
    , decltype((void)(std::declval<T&>()->GetHashCode()))
> : std::true_type {};
 
 
template<typename T, typename Sfinae = void>
struct has_method_compareto_via_dot : std::false_type {};
template<typename T>
struct has_method_compareto_via_dot<
    T
    , decltype((void)(std::declval<T&>().CompareTo(*static_cast<T*>(nullptr))))
> : std::true_type {};
 
 
template<typename T, typename Sfinae = void>
struct has_method_compareto_via_arrow : std::false_type {};
template<typename T>
struct has_method_compareto_via_arrow<
    T
    , decltype((void)(std::declval<T&>()->CompareTo(*static_cast<T*>(nullptr))))
> : std::true_type {};
 
template<typename T, typename Sfinae = void>
struct has_method_get_Count : std::false_type {};
template<typename T>
struct has_method_get_Count<
    T
    , decltype((void)(std::declval<T&>()->get_Count()))
> : std::true_type {};
 
template<typename T, typename Sfinae = void>
struct has_print_to_function : std::false_type {};
template<typename T>
struct has_print_to_function<
    T
    , decltype((void)(PrintTo(std::declval<T&>(), std::declval<std::ostream*>())))
> : std::true_type{};
 
template<typename T, typename Sfinae = void>
struct has_method_is_null : std::false_type {};
template<typename T>
struct has_method_is_null<
    T
    , decltype((void)(std::declval<T&>().IsNull()))
> : std::true_type {};
 
template <typename from, typename to>
struct is_pointer_convertible
{
    static std::true_type check(to*);
    static std::false_type check(...);
    using type = decltype(check(std::declval<from*>()));
};
 
}} //namespace System::detail