Internal.h

#pragma once
 
#include <type_traits>
 
namespace sw
{
    template <typename T>
    using _OptimalParamType = typename std::conditional<
        std::is_scalar<typename std::decay<T>::type>::value,
        typename std::decay<T>::type, const typename std::decay<T>::type &>::type;
 
    template <typename TFrom, typename TTo, typename = void>
    struct _IsExplicitlyConvertable : std::false_type {
    };
 
    template <typename TFrom, typename TTo>
    struct _IsExplicitlyConvertable<
        TFrom, TTo, decltype(void(static_cast<TTo>(std::declval<TFrom>())))> : std::true_type {
    };
 
    template <typename TFrom, typename TTo>
    using _IsStaticCastable = _IsExplicitlyConvertable<TFrom, TTo>;
 
    template <typename TFrom, typename TTo, typename = void>
    struct _IsDynamicCastable : std::false_type {
    };
 
    template <typename TFrom, typename TTo>
    struct _IsDynamicCastable<
        TFrom, TTo, decltype(void(dynamic_cast<TTo>(std::declval<TFrom>())))> : std::true_type {
    };
 
    template <typename T, typename = void>
    struct _HasToString : std::false_type {
    };
 
    template <typename T>
    struct _HasToString<
        T, decltype(void(std::declval<T>().ToString()))> : std::true_type {
    };
 
    template <typename TDelegate, typename TFunc, typename = void>
    struct _DelegateCanAddSubtract : std::false_type {
    };
 
    template <typename TDelegate, typename TFunc>
    struct _DelegateCanAddSubtract<
        TDelegate, TFunc,
        decltype(void(std::declval<TDelegate>() += std::declval<TFunc>()),
                 void(std::declval<TDelegate>() -= std::declval<TFunc>()))>
        : std::true_type {
    };
}