// 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<
|
B
|
, ::boost::mpl::eval_if<
|
::boost::parameter::aux
|
::is_target_same_as_source<Target,T,Args>
|
, ::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<
|
B
|
, ::boost::mp11::mp_if<
|
::boost::parameter::aux
|
::is_target_same_as_source<Target,T,Args>
|
, ::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<
|
B
|
, ::boost::parameter::aux::cast_convert<Source,Target>
|
>::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<
|
B
|
, ::boost::mp11::mp_if<
|
::std::is_const<T>
|
, ::boost::mp11::mp_false
|
, ::boost::mp11::mp_true
|
>
|
, ::boost::mp11::mp_false
|
>
|
#else
|
typename ::boost::mpl::eval_if<
|
B
|
, ::boost::mpl::if_<
|
::boost::is_const<T>
|
, ::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<
|
B
|
, ::boost::mp11::mp_if<
|
::std::is_scalar<T>
|
, ::boost::mp11::mp_false
|
, ::boost::mp11::mp_true
|
>
|
, ::boost::mp11::mp_false
|
>
|
#else
|
typename ::boost::mpl::eval_if<
|
B
|
, ::boost::mpl::if_<
|
::boost::is_scalar<T>
|
, ::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<
|
B
|
, ::boost::mp11::mp_if<
|
::std::is_scalar<T>
|
, ::boost::mp11::mp_false
|
, ::boost::mp11::mp_true
|
>
|
, ::boost::mp11::mp_false
|
>
|
#else
|
typename ::boost::mpl::eval_if<
|
B
|
, ::boost::mpl::if_<
|
::boost::is_scalar<T>
|
, ::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(BOOST_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 {
|
|
// 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>
|
#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 {
|
|
// 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
|
|
#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 {
|
|
// 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:
|
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
|
