| // Copyright Daniel Wallin, David Abrahams 2005. |
| // 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_TAGGED_ARGUMENT_050328_HPP |
| #define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP |
| |
| namespace boost { namespace parameter { namespace aux { |
| |
| struct error_const_lvalue_bound_to_out_parameter; |
| struct error_lvalue_bound_to_consume_parameter; |
| struct error_rvalue_bound_to_out_parameter; |
| }}} // namespace boost::parameter::aux |
| |
| #include <boost/parameter/keyword_fwd.hpp> |
| #include <boost/parameter/config.hpp> |
| #include <boost/mpl/eval_if.hpp> |
| #include <boost/type_traits/is_same.hpp> |
| #include <boost/type_traits/remove_const.hpp> |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| #include <boost/mp11/integral.hpp> |
| #include <boost/mp11/utility.hpp> |
| #include <type_traits> |
| #endif |
| |
| namespace boost { namespace parameter { namespace aux { |
| |
| template <typename Keyword, typename Arg> |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using tagged_argument_type = ::boost::mp11::mp_if< |
| ::boost::mp11::mp_if< |
| ::std::is_scalar<Arg> |
| , ::boost::mp11::mp_false |
| , ::std::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::consume_reference |
| > |
| > |
| , ::boost::parameter::aux::error_lvalue_bound_to_consume_parameter |
| , ::boost::mp11::mp_if< |
| ::std::is_const<Arg> |
| , ::boost::mp11::mp_if< |
| ::std::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::out_reference |
| > |
| , ::boost::parameter::aux |
| ::error_const_lvalue_bound_to_out_parameter |
| , ::std::remove_const<Arg> |
| > |
| , ::boost::mp11::mp_identity<Arg> |
| > |
| >; |
| #else // !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| struct tagged_argument_type |
| : ::boost::mpl::eval_if< |
| ::boost::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::out_reference |
| > |
| , ::boost::parameter::aux::error_const_lvalue_bound_to_out_parameter |
| , ::boost::remove_const<Arg> |
| > |
| { |
| }; |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| }}} // namespace boost::parameter::aux |
| |
| #include <boost/parameter/aux_/tagged_argument_fwd.hpp> |
| #include <boost/parameter/aux_/is_tagged_argument.hpp> |
| #include <boost/parameter/aux_/default.hpp> |
| #include <boost/parameter/aux_/void.hpp> |
| #include <boost/parameter/aux_/arg_list.hpp> |
| #include <boost/parameter/aux_/result_of0.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/identity.hpp> |
| #include <boost/mpl/apply_wrap.hpp> |
| #include <boost/type_traits/is_const.hpp> |
| #include <boost/type_traits/is_function.hpp> |
| #include <boost/type_traits/is_scalar.hpp> |
| #include <boost/type_traits/remove_reference.hpp> |
| |
| #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) |
| #include <boost/function.hpp> |
| #else |
| #include <functional> |
| #endif |
| |
| #if defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) |
| #include <boost/core/enable_if.hpp> |
| #include <utility> |
| |
| namespace boost { namespace parameter { namespace aux { |
| |
| // Holds an lvalue reference to an argument of type Arg associated with |
| // keyword Keyword |
| template <typename Keyword, typename Arg> |
| class tagged_argument |
| : public ::boost::parameter::aux::tagged_argument_base |
| { |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using arg_type = typename ::boost::parameter::aux |
| ::tagged_argument_type<Keyword,Arg>::type; |
| #else |
| typedef typename ::boost::mpl::eval_if< |
| typename ::boost::mpl::eval_if< |
| ::boost::is_scalar<Arg> |
| , ::boost::mpl::false_ |
| , ::boost::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::consume_reference |
| > |
| >::type |
| , ::boost::parameter::aux::error_lvalue_bound_to_consume_parameter |
| , ::boost::mpl::eval_if< |
| ::boost::is_const<Arg> |
| , ::boost::parameter::aux::tagged_argument_type<Keyword,Arg> |
| , ::boost::mpl::identity<Arg> |
| > |
| >::type arg_type; |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| |
| public: |
| typedef Keyword key_type; |
| |
| // Wrap plain (non-UDT) function objects in either |
| // a boost::function or a std::function. -- Cromwell D. Enage |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using value_type = ::boost::mp11::mp_if< |
| ::std::is_function<arg_type> |
| , ::std::function<arg_type> |
| , Arg |
| >; |
| #else // !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| typedef typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) |
| , ::boost::function<arg_type> |
| #else |
| , ::std::function<arg_type> |
| #endif |
| , Arg |
| >::type value_type; |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| |
| // If Arg is void_, then this type will evaluate to void_&. If the |
| // supplied argument is a plain function, then this type will evaluate |
| // to a reference-to-const function wrapper type. If the supplied |
| // argument is an lvalue, then Arg will be deduced to the lvalue |
| // reference. -- Cromwell D. Enage |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using reference = ::boost::mp11::mp_if< |
| ::std::is_function<arg_type> |
| , value_type const& |
| , Arg& |
| >; |
| #else |
| typedef typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| , value_type const& |
| , Arg& |
| >::type reference; |
| #endif |
| |
| private: |
| // Store plain functions by value, everything else by reference. |
| // -- Cromwell D. Enage |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| ::boost::mp11::mp_if< |
| ::std::is_function<arg_type> |
| , value_type |
| , reference |
| > value; |
| #else |
| typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| , value_type |
| , reference |
| >::type value; |
| #endif |
| |
| public: |
| inline explicit BOOST_CONSTEXPR tagged_argument(reference x) |
| : value(x) |
| { |
| } |
| |
| inline BOOST_CONSTEXPR tagged_argument(tagged_argument const& copy) |
| : value(copy.value) |
| { |
| } |
| |
| // A metafunction class that, given a keyword and a default type, |
| // returns the appropriate result type for a keyword lookup given |
| // that default. |
| struct binding |
| { |
| template <typename KW, typename Default, typename Reference> |
| struct apply |
| : ::boost::mpl::eval_if< |
| ::boost::is_same<KW,key_type> |
| , ::boost::mpl::if_<Reference,reference,value_type> |
| , ::boost::mpl::identity<Default> |
| > |
| { |
| }; |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| template <typename KW, typename Default, typename Reference> |
| using fn = ::boost::mp11::mp_if< |
| ::std::is_same<KW,key_type> |
| , ::boost::mp11::mp_if<Reference,reference,value_type> |
| , Default |
| >; |
| #endif |
| }; |
| |
| #if !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| // Comma operator to compose argument list without using parameters<>. |
| // Useful for argument lists with undetermined length. |
| template <typename Keyword2, typename Arg2> |
| inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| > |
| operator,( |
| ::boost::parameter::aux |
| ::tagged_argument<Keyword2,Arg2> const& x |
| ) const |
| { |
| return ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| >( |
| *this |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| >(x, ::boost::parameter::aux::empty_arg_list()) |
| ); |
| } |
| |
| template <typename Keyword2, typename Arg2> |
| inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> |
| > |
| > |
| operator,( |
| ::boost::parameter::aux |
| ::tagged_argument_rref<Keyword2,Arg2> const& x |
| ) const |
| { |
| return ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , boost::parameter::aux::arg_list< |
| boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> |
| > |
| >( |
| *this |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux |
| ::tagged_argument_rref<Keyword2,Arg2> |
| >(x, ::boost::parameter::aux::empty_arg_list()) |
| ); |
| } |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| |
| // Accessor interface. |
| inline BOOST_CONSTEXPR reference get_value() const |
| { |
| return this->value; |
| } |
| |
| inline BOOST_CONSTEXPR reference |
| operator[](::boost::parameter::keyword<Keyword> const&) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::default_<key_type,Default> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::default_r_<key_type,Default> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename F> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::lazy_default<key_type,F> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default& |
| operator[]( |
| ::boost::parameter::aux::default_<KW,Default> const& x |
| ) const |
| { |
| return x.value; |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default&& |
| operator[]( |
| ::boost::parameter::aux::default_r_<KW,Default> const& x |
| ) const |
| { |
| return ::std::forward<Default>(x.value); |
| } |
| |
| template <typename KW, typename F> |
| inline BOOST_CONSTEXPR |
| typename ::boost::parameter::aux::result_of0<F>::type |
| operator[]( |
| ::boost::parameter::aux::lazy_default<KW,F> const& x |
| ) const |
| { |
| return x.compute_default(); |
| } |
| |
| template <typename ParameterRequirements> |
| static BOOST_CONSTEXPR typename ParameterRequirements::has_default |
| satisfies(ParameterRequirements*); |
| |
| template <typename HasDefault, typename Predicate> |
| static BOOST_CONSTEXPR |
| typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type |
| satisfies( |
| ::boost::parameter::aux::parameter_requirements< |
| key_type |
| , Predicate |
| , HasDefault |
| >* |
| ); |
| |
| // MPL sequence support |
| // Convenience for users |
| typedef ::boost::parameter::aux::tagged_argument<Keyword,Arg> type; |
| // For the benefit of iterators |
| typedef ::boost::parameter::aux::empty_arg_list tail_type; |
| // For dispatching to sequence intrinsics |
| typedef ::boost::parameter::aux::arg_list_tag tag; |
| }; |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| template <typename Keyword> |
| using tagged_argument_rref_key = ::boost::mp11::mp_if< |
| ::std::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::out_reference |
| > |
| , ::boost::parameter::aux::error_rvalue_bound_to_out_parameter |
| , ::boost::mp11::mp_identity<Keyword> |
| >; |
| #endif |
| |
| // Holds an rvalue reference to an argument of type Arg associated with |
| // keyword Keyword |
| template <typename Keyword, typename Arg> |
| struct tagged_argument_rref |
| : ::boost::parameter::aux::tagged_argument_base |
| { |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| using key_type = typename ::boost::parameter::aux |
| ::tagged_argument_rref_key<Keyword>::type; |
| #else |
| typedef typename ::boost::mpl::eval_if< |
| ::boost::is_same< |
| typename Keyword::qualifier |
| , ::boost::parameter::out_reference |
| > |
| , ::boost::parameter::aux::error_rvalue_bound_to_out_parameter |
| , ::boost::mpl::identity<Keyword> |
| >::type key_type; |
| #endif |
| typedef Arg value_type; |
| typedef Arg&& reference; |
| |
| private: |
| reference value; |
| |
| public: |
| inline explicit BOOST_CONSTEXPR tagged_argument_rref(reference x) |
| : value(::std::forward<Arg>(x)) |
| { |
| } |
| |
| inline BOOST_CONSTEXPR tagged_argument_rref( |
| tagged_argument_rref const& copy |
| ) : value(::std::forward<Arg>(copy.value)) |
| { |
| } |
| |
| // A metafunction class that, given a keyword and a default type, |
| // returns the appropriate result type for a keyword lookup given |
| // that default. |
| struct binding |
| { |
| template <typename KW, typename Default, typename Reference> |
| struct apply |
| { |
| typedef typename ::boost::mpl::eval_if< |
| ::boost::is_same<KW,key_type> |
| , ::boost::mpl::if_<Reference,reference,value_type> |
| , ::boost::mpl::identity<Default> |
| >::type type; |
| }; |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| template <typename KW, typename Default, typename Reference> |
| using fn = ::boost::mp11::mp_if< |
| ::std::is_same<KW,key_type> |
| , ::boost::mp11::mp_if<Reference,reference,value_type> |
| , Default |
| >; |
| #endif |
| }; |
| |
| #if !defined(BOOST_PARAMETER_CAN_USE_MP11) |
| // Comma operator to compose argument list without using parameters<>. |
| // Useful for argument lists with undetermined length. |
| template <typename Keyword2, typename Arg2> |
| inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| > |
| operator,( |
| ::boost::parameter::aux |
| ::tagged_argument<Keyword2,Arg2> const& x |
| ) const |
| { |
| return boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| >( |
| *this |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| >(x, ::boost::parameter::aux::empty_arg_list()) |
| ); |
| } |
| |
| template <typename Keyword2, typename Arg2> |
| inline BOOST_CONSTEXPR ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword2,Arg2> |
| > |
| > |
| operator,( |
| ::boost::parameter::aux |
| ::tagged_argument_rref<Keyword2,Arg2> const& x |
| ) const |
| { |
| return ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux |
| ::tagged_argument_rref<Keyword2,Arg2> |
| > |
| >( |
| *this |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument_rref< |
| Keyword2 |
| , Arg2 |
| > |
| >(x, ::boost::parameter::aux::empty_arg_list()) |
| ); |
| } |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| |
| // Accessor interface. |
| inline BOOST_CONSTEXPR reference get_value() const |
| { |
| return ::std::forward<Arg>(this->value); |
| } |
| |
| inline BOOST_CONSTEXPR reference |
| operator[](::boost::parameter::keyword<Keyword> const&) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::default_<key_type,Default> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::default_r_<key_type,Default> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename F> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::lazy_default<key_type,F> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default& |
| operator[]( |
| ::boost::parameter::aux::default_<KW,Default> const& x |
| ) const |
| { |
| return x.value; |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default&& |
| operator[]( |
| ::boost::parameter::aux::default_r_<KW,Default> const& x |
| ) const |
| { |
| return ::std::forward<Default>(x.value); |
| } |
| |
| template <typename KW, typename F> |
| inline BOOST_CONSTEXPR |
| typename ::boost::parameter::aux::result_of0<F>::type |
| operator[]( |
| ::boost::parameter::aux::lazy_default<KW,F> const& x |
| ) const |
| { |
| return x.compute_default(); |
| } |
| |
| template <typename ParameterRequirements> |
| static BOOST_CONSTEXPR typename ParameterRequirements::has_default |
| satisfies(ParameterRequirements*); |
| |
| template <typename HasDefault, typename Predicate> |
| static BOOST_CONSTEXPR |
| typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type |
| satisfies( |
| ::boost::parameter::aux::parameter_requirements< |
| key_type |
| , Predicate |
| , HasDefault |
| >* |
| ); |
| |
| // MPL sequence support |
| // Convenience for users |
| typedef ::boost::parameter::aux |
| ::tagged_argument_rref<Keyword,Arg> type; |
| // For the benefit of iterators |
| typedef ::boost::parameter::aux::empty_arg_list tail_type; |
| // For dispatching to sequence intrinsics |
| typedef ::boost::parameter::aux::arg_list_tag tag; |
| }; |
| }}} // namespace boost::parameter::aux |
| |
| #else // !defined(BOOST_PARAMETER_HAS_PERFECT_FORWARDING) |
| |
| namespace boost { namespace parameter { namespace aux { |
| |
| // Holds an lvalue reference to an argument of type Arg associated with |
| // keyword Keyword |
| template <typename Keyword, typename Arg> |
| class tagged_argument |
| : public ::boost::parameter::aux::tagged_argument_base |
| { |
| typedef typename ::boost::remove_const<Arg>::type arg_type; |
| |
| public: |
| typedef Keyword key_type; |
| |
| // Wrap plain (non-UDT) function objects in either |
| // a boost::function or a std::function. -- Cromwell D. Enage |
| typedef typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| #if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) |
| , ::boost::function<arg_type> |
| #else |
| , ::std::function<arg_type> |
| #endif |
| , Arg |
| >::type value_type; |
| |
| // If Arg is void_, then this type will evaluate to void_&. If the |
| // supplied argument is a plain function, then this type will evaluate |
| // to a reference-to-const function wrapper type. If the supplied |
| // argument is an lvalue, then Arg will be deduced to the lvalue |
| // reference. -- Cromwell D. Enage |
| typedef typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| , value_type const& |
| , Arg& |
| >::type reference; |
| |
| private: |
| // Store plain functions by value, everything else by reference. |
| // -- Cromwell D. Enage |
| typename ::boost::mpl::if_< |
| ::boost::is_function<arg_type> |
| , value_type |
| , reference |
| >::type value; |
| |
| public: |
| inline explicit BOOST_CONSTEXPR tagged_argument(reference x) |
| : value(x) |
| { |
| } |
| |
| inline BOOST_CONSTEXPR tagged_argument(tagged_argument const& copy) |
| : value(copy.value) |
| { |
| } |
| |
| // A metafunction class that, given a keyword and a default type, |
| // returns the appropriate result type for a keyword lookup given |
| // that default. |
| struct binding |
| { |
| template <typename KW, typename Default, typename Reference> |
| struct apply |
| { |
| typedef typename ::boost::mpl::eval_if< |
| ::boost::is_same<KW,key_type> |
| , ::boost::mpl::if_<Reference,reference,value_type> |
| , ::boost::mpl::identity<Default> |
| >::type type; |
| }; |
| }; |
| |
| // Comma operator to compose argument list without using parameters<>. |
| // Useful for argument lists with undetermined length. |
| template <typename Keyword2, typename Arg2> |
| inline ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| > |
| operator,( |
| ::boost::parameter::aux |
| ::tagged_argument<Keyword2,Arg2> const& x |
| ) const |
| { |
| return ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword,Arg> |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| > |
| >( |
| *this |
| , ::boost::parameter::aux::arg_list< |
| ::boost::parameter::aux::tagged_argument<Keyword2,Arg2> |
| >(x, ::boost::parameter::aux::empty_arg_list()) |
| ); |
| } |
| |
| // Accessor interface. |
| inline BOOST_CONSTEXPR reference get_value() const |
| { |
| return this->value; |
| } |
| |
| inline BOOST_CONSTEXPR reference |
| operator[](::boost::parameter::keyword<Keyword> const&) const |
| { |
| return this->get_value(); |
| } |
| |
| #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || \ |
| BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default& |
| get_with_default( |
| ::boost::parameter::aux::default_<KW,Default> const& x |
| , int |
| ) const |
| { |
| return x.value; |
| } |
| |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| get_with_default( |
| ::boost::parameter::aux::default_<key_type,Default> const& |
| , long |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< |
| binding |
| , KW |
| , Default& |
| , ::boost::mpl::true_ |
| >::type |
| operator[]( |
| ::boost::parameter::aux::default_<KW,Default> const& x |
| ) const |
| { |
| return this->get_with_default(x, 0L); |
| } |
| |
| template <typename KW, typename F> |
| inline BOOST_CONSTEXPR |
| typename ::boost::parameter::aux::result_of0<F>::type |
| get_with_lazy_default( |
| ::boost::parameter::aux::lazy_default<KW,F> const& x |
| , int |
| ) const |
| { |
| return x.compute_default(); |
| } |
| |
| template <typename F> |
| inline BOOST_CONSTEXPR reference |
| get_with_lazy_default( |
| ::boost::parameter::aux::lazy_default<key_type,F> const& |
| , long |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename KW, typename F> |
| inline BOOST_CONSTEXPR typename ::boost::mpl::apply_wrap3< |
| binding |
| , KW |
| , typename ::boost::parameter::aux::result_of0<F>::type |
| , ::boost::mpl::true_ |
| >::type |
| operator[]( |
| ::boost::parameter::aux::lazy_default<KW,F> const& x |
| ) const |
| { |
| return this->get_with_lazy_default(x, 0L); |
| } |
| #else // No function template ordering or Borland workarounds needed. |
| template <typename Default> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::default_<key_type,Default> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename F> |
| inline BOOST_CONSTEXPR reference |
| operator[]( |
| ::boost::parameter::aux::lazy_default<key_type,F> const& |
| ) const |
| { |
| return this->get_value(); |
| } |
| |
| template <typename KW, typename Default> |
| inline BOOST_CONSTEXPR Default& |
| operator[]( |
| ::boost::parameter::aux::default_<KW,Default> const& x |
| ) const |
| { |
| return x.value; |
| } |
| |
| template <typename KW, typename F> |
| inline BOOST_CONSTEXPR |
| typename ::boost::parameter::aux::result_of0<F>::type |
| operator[]( |
| ::boost::parameter::aux::lazy_default<KW,F> const& x |
| ) const |
| { |
| return x.compute_default(); |
| } |
| |
| template <typename ParameterRequirements> |
| static BOOST_CONSTEXPR typename ParameterRequirements::has_default |
| satisfies(ParameterRequirements*); |
| |
| template <typename HasDefault, typename Predicate> |
| static BOOST_CONSTEXPR |
| typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type |
| satisfies( |
| ::boost::parameter::aux::parameter_requirements< |
| key_type |
| , Predicate |
| , HasDefault |
| >* |
| ); |
| #endif // Function template ordering, Borland workarounds needed. |
| |
| // MPL sequence support |
| // Convenience for users |
| typedef ::boost::parameter::aux::tagged_argument<Keyword,Arg> type; |
| // For the benefit of iterators |
| typedef ::boost::parameter::aux::empty_arg_list tail_type; |
| // For dispatching to sequence intrinsics |
| typedef ::boost::parameter::aux::arg_list_tag tag; |
| |
| #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) |
| // warning suppression |
| private: |
| void operator=(type const&); |
| #endif |
| }; |
| }}} // namespace boost::parameter::aux |
| |
| #endif // BOOST_PARAMETER_HAS_PERFECT_FORWARDING |
| |
| #if defined(BOOST_PARAMETER_CAN_USE_MP11) |
| |
| namespace boost { namespace parameter { namespace aux { |
| |
| template <typename TaggedArg> |
| struct tagged_argument_list_of_1 : public TaggedArg |
| { |
| using base_type = TaggedArg; |
| |
| inline explicit BOOST_CONSTEXPR tagged_argument_list_of_1( |
| typename base_type::reference x |
| ) : base_type(static_cast<typename base_type::reference>(x)) |
| { |
| } |
| |
| inline BOOST_CONSTEXPR tagged_argument_list_of_1( |
| tagged_argument_list_of_1 const& copy |
| ) : base_type(static_cast<base_type const&>(copy)) |
| { |
| } |
| |
| using base_type::operator[]; |
| using base_type::satisfies; |
| |
| template <typename TA2> |
| inline BOOST_CONSTEXPR ::boost::parameter::aux::flat_like_arg_list< |
| ::boost::parameter::aux |
| ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg> |
| , ::boost::parameter::aux::flat_like_arg_tuple< |
| typename TA2::base_type::key_type |
| , typename TA2::base_type |
| > |
| > |
| operator,(TA2 const& x) const |
| { |
| return boost::parameter::aux::flat_like_arg_list< |
| ::boost::parameter::aux |
| ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg> |
| , ::boost::parameter::aux::flat_like_arg_tuple< |
| typename TA2::base_type::key_type |
| , typename TA2::base_type |
| > |
| >( |
| static_cast<base_type const&>(*this) |
| , ::boost::parameter::aux::arg_list<typename TA2::base_type>( |
| static_cast<typename TA2::base_type const&>(x) |
| , ::boost::parameter::aux::empty_arg_list() |
| ) |
| ); |
| } |
| }; |
| }}} // namespace boost::parameter::aux |
| |
| #endif // BOOST_PARAMETER_CAN_USE_MP11 |
| #endif // include guard |
| |
