EVOLUTION-MANAGER

Edit File: function_cast.hpp

// Copyright Daniel Wallin 2006.
// Copyright Cromwell D. Enage 2017.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_CAST_HPP
#define BOOST_PARAMETER_AUX_PREPROCESSOR_IMPL_FUNCTION_CAST_HPP

#include <boost/parameter/config.hpp>

#if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING)

namespace boost { namespace parameter { namespace aux {

// Handles possible implicit casts. Used by preprocessor.hpp
 // to normalize user input.
 //
 // cast<void*>::execute() is identity
 // cast<void*(X)>::execute() is identity
 // cast<void(X)>::execute() casts to X
 //
 // preprocessor.hpp uses this like this:
 //
 // #define X(value, predicate)
 // cast<void predicate>::execute(value)
 //
 // X(something, *)
 // X(something, *(predicate))
 // X(something, (int))
 template <typename VoidExpr, typename Args>
 struct cast;
}}} // namespace boost::parameter::aux

#include <boost/parameter/aux_/use_default_tag.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename T, typename B>
 inline ::boost::parameter::aux::use_default_tag
 forward(::boost::parameter::aux::use_default_tag)
 {
 return ::boost::parameter::aux::use_default_tag();
 }
}}} // namespace boost::parameter::aux

#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>

#if defined(BOOST_PARAMETER_CAN_USE_MP11)
#include <boost/mp11/integral.hpp>
#include <boost/mp11/utility.hpp>
#endif

namespace boost { namespace parameter { namespace aux {

template <typename Args>
 struct cast<void*,Args>
 {
 template <typename T, typename B>
 struct apply
 {
 typedef typename ::boost::mpl
 ::if_<B,T,::boost::mpl::true_>::type type;
 };

#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 template <typename T, typename B>
 using fn = ::boost::mp11::mp_if<B,T,::boost::mp11::mp_true>;
#endif
 };
}}} // namespace boost::parameter::aux

#include <boost/parameter/aux_/void.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Predicate, typename Args>
 struct cast<void*(Predicate),Args>
 : ::boost::parameter::aux::cast<void*,Args>
 {
 };
}}} // namespace boost::parameter::aux

#include <boost/mpl/placeholders.hpp>

namespace boost { namespace parameter { namespace aux {

// This is a hack used in cast<> to turn the user supplied type,
 // which may or may not be a placeholder expression, into one,
 // so that it will be properly evaluated by mpl::apply.
 template <typename T, typename Dummy = ::boost::mpl::_1>
 struct as_placeholder_expr
 {
 typedef T type;
 };
}}} // namespace boost::parameter::aux

#if defined(BOOST_PARAMETER_CAN_USE_MP11)
#include <boost/mp11/list.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Target, typename Source, typename Args>
 struct apply_target_fn
 {
 using type = ::boost::mp11
 ::mp_apply_q<Target,::boost::mp11::mp_list<Source,Args> >;
 };
}}} // namespace boost::parameter::aux

#endif

#include <boost/mpl/apply.hpp>

#if defined(BOOST_PARAMETER_CAN_USE_MP11)
#include <boost/parameter/aux_/has_nested_template_fn.hpp>
#include <type_traits>
#else
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#endif

namespace boost { namespace parameter { namespace aux {

template <typename Target, typename Source, typename Args>
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 using is_target_same_as_source = ::std::is_same<
 typename ::std::remove_const<
 typename ::std::remove_reference<
 typename ::boost::mp11::mp_if<
 ::boost::parameter::aux::has_nested_template_fn<Target>
 , ::boost::parameter::aux
 ::apply_target_fn<Target,Source,Args>
 , ::boost::mpl::apply2<
 ::boost::parameter::aux::as_placeholder_expr<Target>
 , Source
 , Args
 >
 >::type
 >::type
 >::type
 , typename ::std::remove_const<Source>::type
 >;
#else // !defined(BOOST_PARAMETER_CAN_USE_MP11)
 struct is_target_same_as_source
 : ::boost::mpl::if_<
 ::boost::is_same<
 typename ::boost::remove_const<
 typename ::boost::remove_reference<
 typename ::boost::mpl::apply2<
 ::boost::parameter::aux
 ::as_placeholder_expr<Target>
 , Source
 , Args
 >::type
 >::type
 >::type
 , typename ::boost::remove_const<Source>::type
 >
 , ::boost::mpl::true_
 , ::boost::mpl::false_
 >::type
 {
 };
#endif // BOOST_PARAMETER_CAN_USE_MP11
}}} // namespace boost::parameter::aux

#if !defined(BOOST_PARAMETER_CAN_USE_MP11)
#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/is_const.hpp>
#endif

namespace boost { namespace parameter { namespace aux {

// Covers the case where is_convertible<Source,Target> but not
 // is_same<Source,Target>. Use cases are covered
 // by test/normalize_argument_types.cpp
 template <typename Source, typename Target>
 class cast_convert
 {
 typedef ::boost::parameter::aux::cast_convert<Source,Target> _self;

public:
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 using type = typename ::boost::mp11::mp_if<
 ::std::is_const<Source>
 , ::std::add_const<Target>
 , ::std::remove_const<Target>
 >::type;
#else
 typedef typename boost::mpl::eval_if<
 ::boost::is_const<Source>
 , ::boost::add_const<Target>
 , ::boost::remove_const<Target>
 >::type type;
#endif

private:
 inline static typename _self::type
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 _copy(typename ::std::remove_const<Target>::type value)
#else
 _copy(typename ::boost::remove_const<Target>::type value)
#endif
 {
 return value;
 }

public:
        inline static typename _self::type evaluate(Source&& source)
        {
            return _self::_copy(source);
        }
    };

template <typename Target, typename Source, typename Args>
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 using cast_impl = ::std::remove_reference<
 typename ::boost::mp11::mp_if<
 ::boost::parameter::aux::has_nested_template_fn<Target>
 , ::boost::parameter::aux
 ::is_target_same_as_source<Target,Source,Args>
 , ::boost::mpl::apply2<
 ::boost::parameter::aux::as_placeholder_expr<Target>
 , Source
 , Args
 >
 >::type
 >;
#else
 struct cast_impl
 : ::boost::remove_reference<
 typename ::boost::mpl::apply2<
 ::boost::parameter::aux::as_placeholder_expr<Target>
 , Source
 , Args
 >::type
 >
 {
 };
#endif // BOOST_PARAMETER_CAN_USE_MP11
}}} // namespace boost::parameter::aux

#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Target, typename Args>
 struct cast<void(Target),Args>
 {
 template <typename T, typename B>
 struct apply
 {
 typedef typename ::boost::mpl::eval_if
 , ::boost::mpl::identity<T>
 , ::boost::parameter::aux::cast_impl<Target,T,Args>
 >
 , ::boost::parameter::aux
 ::is_target_same_as_source<Target,T,Args>
 >::type type;
 };

#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 template <typename T, typename B>
 using fn = typename ::boost::mp11::mp_if
 , ::boost::mp11::mp_identity<T>
 , ::boost::parameter::aux::cast_impl<Target,T,Args>
 >
 , ::boost::parameter::aux
 ::is_target_same_as_source<Target,T,Args>
 >::type;
#endif
 };
}}} // namespace boost::parameter::aux

#include <boost/parameter/value_type.hpp>

#if !defined(BOOST_PARAMETER_CAN_USE_MP11)
#include <boost/mpl/apply_wrap.hpp>
#endif

// Expands to the target type of the argument as indicated by the predicate.
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \
 ::boost::mp11::mp_apply_q< \
 ::boost::parameter::aux::cast<void predicate, args> \
 , ::boost::mp11::mp_list< \
 typename ::boost::parameter::value_type< \
 args \
 , tag \
 , ::boost::parameter::aux::use_default_tag \
 >::type \
 , ::boost::mp11::mp_true \
 > \
 >
/**/
#else // !defined(BOOST_PARAMETER_CAN_USE_MP11)
#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \
 typename ::boost::mpl::apply_wrap2< \
 ::boost::parameter::aux::cast<void predicate, args> \
 , typename ::boost::parameter::value_type< \
 args \
 , tag \
 , ::boost::parameter::aux::use_default_tag \
 >::type \
 , ::boost::mpl::true_ \
 >::type
/**/
#endif // BOOST_PARAMETER_CAN_USE_MP11

// Expands to boost::mpl::true_ if and only if the argument's source and
// target types are the same.
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
#define BOOST_PARAMETER_FUNCTION_CAST_B(tag, predicate, args) \
 ::boost::mp11::mp_apply_q< \
 ::boost::parameter::aux::cast<void predicate, args> \
 , ::boost::mp11::mp_list< \
 typename ::boost::parameter::value_type< \
 args \
 , tag \
 , ::boost::parameter::aux::use_default_tag \
 >::type \
 , ::boost::mp11::mp_false \
 > \
 >
/**/
#else // !defined(BOOST_PARAMETER_CAN_USE_MP11)
#define BOOST_PARAMETER_FUNCTION_CAST_B(tag, predicate, args) \
 typename ::boost::mpl::apply_wrap2< \
 ::boost::parameter::aux::cast<void predicate, args> \
 , typename ::boost::parameter::value_type< \
 args \
 , tag \
 , ::boost::parameter::aux::use_default_tag \
 >::type \
 , ::boost::mpl::false_ \
 >::type
/**/
#endif // BOOST_PARAMETER_CAN_USE_MP11

#include <boost/core/enable_if.hpp>
#include <utility>

namespace boost { namespace parameter { namespace aux {

// If the source and target types are not the same,
 // then perform an implicit conversion.
 template <typename Target, typename B, typename Source>
 inline typename ::boost::lazy_disable_if
 >::type
 forward(Source&& source)
 {
 return ::boost::parameter::aux::cast_convert<Source,Target>
 ::evaluate(::std::forward<Source>(source));
 }

// If the source and target types are the same,
 // then simply forward the argument.
 // However, treat rvalue references to scalars as const lvalue references.
 template <typename T, typename B>
 inline typename ::boost::enable_if<B,T const&>::type forward(T const& t)
 {
 return t;
 }

template <typename T, typename B>
 inline typename ::boost::enable_if<
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 ::boost::mp11::mp_if
 , ::boost::mp11::mp_false
 , ::boost::mp11::mp_true
 >
 , ::boost::mp11::mp_false
 >
#else
 typename ::boost::mpl::eval_if
 , ::boost::mpl::false_
 , ::boost::mpl::true_
 >
 , ::boost::mpl::false_
 >::type
#endif // BOOST_PARAMETER_CAN_USE_MP11
 , T&
 >::type
 forward(T& t)
 {
 return t;
 }
}}} // namespace boost::parameter::aux

#include <boost/type_traits/is_scalar.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename T, typename B>
 inline typename ::boost::enable_if<
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 ::boost::mp11::mp_if
 , ::boost::mp11::mp_false
 , ::boost::mp11::mp_true
 >
 , ::boost::mp11::mp_false
 >
#else
 typename ::boost::mpl::eval_if
 , ::boost::mpl::false_
 , ::boost::mpl::true_
 >
 , ::boost::mpl::false_
 >::type
#endif // BOOST_PARAMETER_CAN_USE_MP11
 , T const&&
 >::type
 forward(T const&& t)
 {
 return static_cast<T const&&>(t);
 }

template <typename T, typename B>
 inline typename ::boost::enable_if<
#if defined(BOOST_PARAMETER_CAN_USE_MP11)
 ::boost::mp11::mp_if
 , ::boost::mp11::mp_false
 , ::boost::mp11::mp_true
 >
 , ::boost::mp11::mp_false
 >
#else
 typename ::boost::mpl::eval_if
 , ::boost::mpl::false_
 , ::boost::mpl::true_
 >
 , ::boost::mpl::false_
 >::type
#endif // BOOST_PARAMETER_CAN_USE_MP11
 , T&&
 >::type
 forward(T&& t)
 {
 return ::std::forward<T>(t);
 }
}}} // namespace boost::parameter::aux

#elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
#define BOOST_PARAMETER_FUNCTION_CAST_T(value_t, predicate, args) value_t
#define BOOST_PARAMETER_FUNCTION_CAST_B(value, predicate, args) value
#else   // no perfect forwarding support and no Borland workarounds needed

namespace boost { namespace parameter { namespace aux {

#include <boost/parameter/aux_/use_default_tag.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Args>
 struct cast<void*,Args>
 {
 template <typename T>
 struct apply
 {
 typedef T& type;
 };

inline static ::boost::parameter::aux::use_default_tag
            execute(::boost::parameter::aux::use_default_tag)
        {
            return ::boost::parameter::aux::use_default_tag();
        }

template <typename U>
 inline static U& execute(U& value)
 {
 return value;
 }
 };
}}} // namespace boost::parameter::aux

#include <boost/parameter/aux_/void.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Predicate, typename Args>
#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x580))
 struct cast< ::boost::parameter::aux::voidstar(Predicate),Args>
#else
 struct cast<void*(Predicate),Args>
#endif
 : ::boost::parameter::aux::cast<void*,Args>
 {
 };
}}} // namespace boost::parameter::aux

#include <boost/mpl/placeholders.hpp>

namespace boost { namespace parameter { namespace aux {

#include <boost/mpl/apply.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Target, typename Source, typename Args>
 struct is_target_same_as_source
 : ::boost::mpl::if_<
 ::boost::is_same<
 typename ::boost::remove_const<
 typename ::boost::remove_reference<
 typename ::boost::mpl::apply2<
 ::boost::parameter::aux
 ::as_placeholder_expr<Target>
 , Source
 , Args
 >::type
 >::type
 >::type
 , typename ::boost::remove_const<Source>::type
 >
 , ::boost::mpl::true_
 , ::boost::mpl::false_
 >::type
 {
 };

template <
 typename Target
 , typename Source
 , typename Args
 , typename Enable = ::boost::parameter::aux
 ::is_target_same_as_source<Target,Source,Args>
 >
 struct cast_impl
 {
 typedef Source& type;

inline static Source& evaluate(Source& value)
        {
            return value;
        }
    };
}}} // namespace boost::parameter::aux

#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/add_lvalue_reference.hpp>

namespace boost { namespace parameter { namespace aux {

public:
 typedef typename ::boost::add_lvalue_reference<
 typename ::boost::add_const<Target>::type
 >::type type;

private:
 template <typename U>
 inline static typename _self::type _mod_const(U const& u)
 {
 return u;
 }

inline static Target _copy(Target value)
        {
            return value;
        }

public:
        inline static typename _self::type evaluate(Source& source)
        {
            return _self::_mod_const(_self::_copy(source));
        }
    };

template <typename Target, typename Source, typename Args>
 struct cast_impl<Target,Source,Args,::boost::mpl::false_>
 : ::boost::parameter::aux::cast_convert<
 Source,
 typename ::boost::mpl::apply2<
 ::boost::parameter::aux::as_placeholder_expr<Target>
 , Source
 , Args
 >::type
 >
 {
 };
}}} // namespace boost::parameter::aux

#include <boost/mpl/eval_if.hpp>

namespace boost { namespace parameter { namespace aux {

template <typename Target, typename Args>
 struct cast<void(Target),Args>
 {
 template <typename T>
 struct apply
 {
 typedef typename ::boost::mpl::eval_if<
 ::boost::parameter::aux
 ::is_target_same_as_source<Target,T,Args>
 , ::boost::add_lvalue_reference<T>
 , ::boost::parameter::aux::cast_impl<
 Target
 , T
 , Args
 , ::boost::mpl::false_
 >
 >::type type;
 };

inline static ::boost::parameter::aux::use_default_tag
            execute(::boost::parameter::aux::use_default_tag)
        {
            return ::boost::parameter::aux::use_default_tag();
        }

template <typename U>
 inline static typename ::boost::parameter::aux
 ::cast_impl<Target,U const,Args>::type
 execute(U const& value)
 {
 return ::boost::parameter::aux
 ::cast_impl<Target,U const,Args>::evaluate(value);
 }

template <typename U>
 inline static typename ::boost::parameter::aux
 ::cast_impl<Target,U,Args>::type
 execute(U& value)
 {
 return ::boost::parameter::aux
 ::cast_impl<Target,U,Args>::evaluate(value);
 }
 };
}}} // namespace boost::parameter::aux

#include <boost/mpl/apply_wrap.hpp>
#include <boost/parameter/value_type.hpp>

// Expands to the reference-qualified target type of the argument
// as indicated by the predicate.
#define BOOST_PARAMETER_FUNCTION_CAST_T(tag, predicate, args) \
 typename ::boost::mpl::apply_wrap1< \
 ::boost::parameter::aux::cast<void predicate, args> \
 , typename ::boost::parameter::value_type< \
 args \
 , tag \
 , ::boost::parameter::aux::use_default_tag \
 >::type \
 >::type
/**/

// Expands to the converted or passed-through value
// as indicated by the predicate.
#define BOOST_PARAMETER_FUNCTION_CAST_B(value, predicate, args) \
 ::boost::parameter::aux::cast<void predicate, args>::execute(value)
/**/

#endif  // perfect forwarding support, or Borland workarounds needed
#endif  // include guard