BindingCastHelper.h

#pragma once
 
#include "Variant.h"
 
namespace sw
{
    template <typename TSource, typename TTarget, typename = void>
    struct BindingCastHelper : std::false_type {
    };
 
    template <typename TSource, typename TTarget>
    struct BindingCastHelper<
        TSource, TTarget,
        typename std::enable_if<
            std::is_same<TSource, TTarget>::value>::type>
        : std::true_type //
    {
        static TTarget Convert(const TSource &value)
        {
            return value;
        }
 
        static TTarget Convert(TSource &&value)
        {
            return std::move(value);
        }
 
        static TSource ConvertBack(const TTarget &value)
        {
            return value;
        }
 
        static TSource ConvertBack(TTarget &&value)
        {
            return std::move(value);
        }
    };
 
    template <typename TSource, typename TTarget>
    struct BindingCastHelper<
        TSource, TTarget,
        typename std::enable_if<
            !std::is_same<TSource, TTarget>::value &&
            _IsStaticCastable<TSource, TTarget>::value &&
            _IsStaticCastable<TTarget, TSource>::value>::type>
        : std::true_type //
    {
        static TTarget Convert(const TSource &value)
        {
            return static_cast<TTarget>(value);
        }
 
        static TTarget Convert(TSource &&value)
        {
            return static_cast<TTarget>(std::move(value));
        }
 
        static TSource ConvertBack(const TTarget &value)
        {
            return static_cast<TSource>(value);
        }
 
        static TSource ConvertBack(TTarget &&value)
        {
            return static_cast<TSource>(std::move(value));
        }
    };
 
    template <typename TSource>
    struct BindingCastHelper<
        TSource, Variant,
        typename std::enable_if<!std::is_same<TSource, Variant>::value>::type> : std::true_type //
    {
        static Variant Convert(const TSource &value)
        {
            return Variant{value};
        }
 
        static Variant Convert(TSource &&value)
        {
            return Variant{std::move(value)};
        }
 
        static TSource ConvertBack(const Variant &value)
        {
            return value.DynamicCast<TSource>();
        }
    };
 
    template <typename TTarget>
    struct BindingCastHelper<
        Variant, TTarget,
        typename std::enable_if<!std::is_same<TTarget, Variant>::value>::type> : std::true_type //
    {
        static TTarget Convert(const Variant &value)
        {
            return value.DynamicCast<TTarget>();
        }
 
        static Variant ConvertBack(const TTarget &value)
        {
            return Variant{value};
        }
 
        static Variant ConvertBack(TTarget &&value)
        {
            return Variant{std::move(value)};
        }
    };
}