boost/parameter/aux_/tagged_argument.hpp
// 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