| // Copyright David Abrahams, Daniel Wallin 2003. Use, modification and | |
| // distribution is subject to 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_PARAMETERS_031014_HPP | |
| #define BOOST_PARAMETERS_031014_HPP | |
| #include <boost/detail/is_xxx.hpp> | |
| #include <boost/type_traits/is_const.hpp> | |
| #include <boost/mpl/lambda.hpp> | |
| #include <boost/mpl/apply.hpp> | |
| #include <boost/mpl/always.hpp> | |
| #include <boost/mpl/and.hpp> | |
| #include <boost/mpl/or.hpp> | |
| #include <boost/mpl/if.hpp> | |
| #include <boost/mpl/identity.hpp> | |
| #include <boost/mpl/not.hpp> | |
| #include <boost/mpl/eval_if.hpp> | |
| #include <boost/mpl/pair.hpp> | |
| #include <boost/type_traits/is_same.hpp> | |
| #include <boost/type_traits/remove_reference.hpp> | |
| #include <boost/preprocessor/repetition/enum.hpp> | |
| #include <boost/preprocessor/repetition/enum_params.hpp> | |
| #include <boost/preprocessor/repetition/enum_trailing_params.hpp> | |
| #include <boost/preprocessor/arithmetic/sub.hpp> | |
| #include <boost/preprocessor/repetition/repeat.hpp> | |
| #include <boost/preprocessor/repetition/enum_shifted.hpp> | |
| #include <boost/preprocessor/repetition/enum_binary_params.hpp> | |
| #include <boost/preprocessor/repetition/enum_shifted_params.hpp> | |
| #include <boost/preprocessor/seq/elem.hpp> | |
| #include <boost/preprocessor/iteration/iterate.hpp> | |
| #include <boost/preprocessor/facilities/intercept.hpp> | |
| #include <boost/preprocessor/cat.hpp> | |
| #include <boost/parameter/aux_/arg_list.hpp> | |
| #include <boost/parameter/aux_/yesno.hpp> | |
| #include <boost/parameter/aux_/void.hpp> | |
| #include <boost/parameter/aux_/default.hpp> | |
| #include <boost/parameter/aux_/unwrap_cv_reference.hpp> | |
| #include <boost/parameter/aux_/tagged_argument.hpp> | |
| #include <boost/parameter/aux_/tag.hpp> | |
| #include <boost/parameter/aux_/template_keyword.hpp> | |
| #include <boost/parameter/aux_/set.hpp> | |
| #include <boost/parameter/config.hpp> | |
| namespace parameter_ | |
| { | |
| template <class T> | |
| struct unmatched_argument | |
| { | |
| BOOST_MPL_ASSERT((boost::is_same<T,void>)); | |
| typedef int type; | |
| }; | |
| } // namespace parameter_ | |
| namespace boost { | |
| template<class T> class reference_wrapper; | |
| namespace parameter { | |
| namespace aux { struct use_default {}; } | |
| // These templates can be used to describe the treatment of particular | |
| // named parameters for the purposes of overload elimination with | |
| // SFINAE, by placing specializations in the parameters<...> list. In | |
| // order for a treated function to participate in overload resolution: | |
| // | |
| // - all keyword tags wrapped in required<...> must have a matching | |
| // actual argument | |
| // | |
| // - The actual argument type matched by every keyword tag | |
| // associated with a predicate must satisfy that predicate | |
| // | |
| // If a keyword k is specified without an optional<...> or | |
| // required<...>, wrapper, it is treated as though optional<k> were | |
| // specified. | |
| // | |
| // If a keyword k is specified with deduced<...>, that keyword | |
| // will be automatically deduced from the argument list. | |
| // | |
| template <class Tag, class Predicate = aux::use_default> | |
| struct required | |
| { | |
| typedef Tag key_type; | |
| typedef Predicate predicate; | |
| }; | |
| template <class Tag, class Predicate = aux::use_default> | |
| struct optional | |
| { | |
| typedef Tag key_type; | |
| typedef Predicate predicate; | |
| }; | |
| template <class Tag> | |
| struct deduced | |
| { | |
| typedef Tag key_type; | |
| }; | |
| namespace aux | |
| { | |
| // Defines metafunctions, is_required and is_optional, that | |
| // identify required<...>, optional<...> and deduced<...> specializations. | |
| BOOST_DETAIL_IS_XXX_DEF(required, required, 2) | |
| BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2) | |
| BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1) | |
| template <class S> | |
| struct is_deduced0 | |
| : is_deduced_aux< | |
| typename S::key_type | |
| >::type | |
| {}; | |
| template <class S> | |
| struct is_deduced | |
| : mpl::eval_if< | |
| mpl::or_< | |
| is_optional<S>, is_required<S> | |
| > | |
| , is_deduced0<S> | |
| , mpl::false_ | |
| >::type | |
| {}; | |
| // | |
| // key_type, has_default, and predicate -- | |
| // | |
| // These metafunctions accept a ParameterSpec and extract the | |
| // keyword tag, whether or not a default is supplied for the | |
| // parameter, and the predicate that the corresponding actual | |
| // argument type is required match. | |
| // | |
| // a ParameterSpec is a specialization of either keyword<...>, | |
| // required<...>, optional<...> | |
| // | |
| // helper for key_type<...>, below. | |
| template <class T> | |
| struct get_tag_type0 | |
| { | |
| typedef typename T::key_type type; | |
| }; | |
| template <class T> | |
| struct get_tag_type | |
| : mpl::eval_if< | |
| is_deduced_aux<typename T::key_type> | |
| , get_tag_type0<typename T::key_type> | |
| , mpl::identity<typename T::key_type> | |
| > | |
| {}; | |
| template <class T> | |
| struct tag_type | |
| : mpl::eval_if< | |
| mpl::or_< | |
| is_optional<T> | |
| , is_required<T> | |
| > | |
| , get_tag_type<T> | |
| , mpl::identity<T> | |
| > | |
| {}; | |
| template <class T> | |
| struct has_default | |
| : mpl::not_<is_required<T> > | |
| {}; | |
| // helper for get_predicate<...>, below | |
| template <class T> | |
| struct get_predicate_or_default | |
| { | |
| typedef T type; | |
| }; | |
| template <> | |
| struct get_predicate_or_default<use_default> | |
| { | |
| typedef mpl::always<mpl::true_> type; | |
| }; | |
| // helper for predicate<...>, below | |
| template <class T> | |
| struct get_predicate | |
| { | |
| typedef typename | |
| get_predicate_or_default<typename T::predicate>::type | |
| type; | |
| }; | |
| template <class T> | |
| struct predicate | |
| : mpl::eval_if< | |
| mpl::or_< | |
| is_optional<T> | |
| , is_required<T> | |
| > | |
| , get_predicate<T> | |
| , mpl::identity<mpl::always<mpl::true_> > | |
| > | |
| { | |
| }; | |
| // Converts a ParameterSpec into a specialization of | |
| // parameter_requirements. We need to do this in order to get the | |
| // tag_type into the type in a way that can be conveniently matched | |
| // by a satisfies(...) member function in arg_list. | |
| template <class ParameterSpec> | |
| struct as_parameter_requirements | |
| { | |
| typedef parameter_requirements< | |
| typename tag_type<ParameterSpec>::type | |
| , typename predicate<ParameterSpec>::type | |
| , typename has_default<ParameterSpec>::type | |
| > type; | |
| }; | |
| template <class T> | |
| struct is_named_argument | |
| : mpl::or_< | |
| is_template_keyword<T> | |
| , is_tagged_argument<T> | |
| > | |
| {}; | |
| // Returns mpl::true_ iff the given ParameterRequirements are | |
| // satisfied by ArgList. | |
| template <class ArgList, class ParameterRequirements> | |
| struct satisfies | |
| { | |
| #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) | |
| // VC7.1 can't handle the sizeof() implementation below, | |
| // so we use this instead. | |
| typedef typename mpl::apply_wrap3< | |
| typename ArgList::binding | |
| , typename ParameterRequirements::keyword | |
| , void_ | |
| , mpl::false_ | |
| >::type bound; | |
| typedef typename mpl::eval_if< | |
| is_same<bound, void_> | |
| , typename ParameterRequirements::has_default | |
| , mpl::apply_wrap2< | |
| typename mpl::lambda< | |
| typename ParameterRequirements::predicate, lambda_tag | |
| >::type | |
| , bound | |
| , ArgList | |
| > | |
| >::type type; | |
| #else | |
| BOOST_STATIC_CONSTANT( | |
| bool, value = ( | |
| sizeof( | |
| aux::to_yesno( | |
| ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0) | |
| ) | |
| ) == sizeof(yes_tag) | |
| ) | |
| ); | |
| typedef mpl::bool_<satisfies::value> type; | |
| #endif | |
| }; | |
| // Returns mpl::true_ if the requirements of the given ParameterSpec | |
| // are satisfied by ArgList. | |
| template <class ArgList, class ParameterSpec> | |
| struct satisfies_requirements_of | |
| : satisfies< | |
| ArgList | |
| , typename as_parameter_requirements<ParameterSpec>::type | |
| > | |
| {}; | |
| // Tags a deduced argument Arg with the keyword tag of Spec using TagFn. | |
| // Returns the tagged argument and the mpl::set<> UsedArgs with the | |
| // tag of Spec inserted. | |
| template <class UsedArgs, class Spec, class Arg, class TagFn> | |
| struct tag_deduced | |
| { | |
| typedef mpl::pair< | |
| typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type | |
| , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type | |
| > type; | |
| }; | |
| template < | |
| class Argument | |
| , class ArgumentPack | |
| , class DeducedArgs | |
| , class UsedArgs | |
| , class TagFn | |
| > | |
| struct deduce_tag; | |
| // Tag type passed to MPL lambda. | |
| struct lambda_tag; | |
| // Helper for deduce_tag<> below. | |
| template < | |
| class Argument | |
| , class ArgumentPack | |
| , class DeducedArgs | |
| , class UsedArgs | |
| , class TagFn | |
| > | |
| struct deduce_tag0 | |
| { | |
| typedef typename DeducedArgs::spec spec; | |
| typedef typename mpl::apply_wrap2< | |
| typename mpl::lambda< | |
| typename spec::predicate, lambda_tag | |
| >::type | |
| , Argument | |
| , ArgumentPack | |
| >::type condition; | |
| // Deduced parameter matches several arguments. | |
| BOOST_MPL_ASSERT(( | |
| mpl::not_<mpl::and_< | |
| condition | |
| , aux::has_key_<UsedArgs, typename tag_type<spec>::type> | |
| > > | |
| )); | |
| typedef typename mpl::eval_if< | |
| condition | |
| , tag_deduced<UsedArgs, spec, Argument, TagFn> | |
| , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn> | |
| >::type type; | |
| }; | |
| // Tries to deduced a keyword tag for a given Argument. | |
| // Returns an mpl::pair<> consisting of the tagged_argument<>, | |
| // and an mpl::set<> where the new tag has been inserted. | |
| // | |
| // Argument: The argument type to be tagged. | |
| // | |
| // ArgumentPack: The ArgumentPack built so far. | |
| // | |
| // DeducedArgs: A specialization of deduced_item<> (see below). | |
| // A list containing only the deduced ParameterSpecs. | |
| // | |
| // UsedArgs: An mpl::set<> containing the keyword tags used so far. | |
| // | |
| // TagFn: A metafunction class used to tag positional or deduced | |
| // arguments with a keyword tag. | |
| template < | |
| class Argument | |
| , class ArgumentPack | |
| , class DeducedArgs | |
| , class UsedArgs | |
| , class TagFn | |
| > | |
| struct deduce_tag | |
| { | |
| typedef typename mpl::eval_if< | |
| is_same<DeducedArgs, void_> | |
| , mpl::pair<void_, UsedArgs> | |
| , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn> | |
| >::type type; | |
| }; | |
| template < | |
| class List | |
| , class DeducedArgs | |
| , class TagFn | |
| , class Positional | |
| , class UsedArgs | |
| , class ArgumentPack | |
| , class Error | |
| > | |
| struct make_arg_list_aux; | |
| // Inserts Tagged::key_type into the UserArgs set. | |
| // Extra indirection to lazily evaluate Tagged::key_type. | |
| template <class UsedArgs, class Tagged> | |
| struct insert_tagged | |
| { | |
| typedef typename aux::insert_< | |
| UsedArgs, typename Tagged::key_type | |
| >::type type; | |
| }; | |
| // Borland needs the insane extra-indirection workaround below | |
| // so that it doesn't magically drop the const qualifier from | |
| // the argument type. | |
| template < | |
| class List | |
| , class DeducedArgs | |
| , class TagFn | |
| , class Positional | |
| , class UsedArgs | |
| , class ArgumentPack | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| , class argument | |
| #endif | |
| , class Error | |
| > | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| struct make_arg_list00 | |
| #else | |
| struct make_arg_list0 | |
| #endif | |
| { | |
| #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| typedef typename List::arg argument; | |
| #endif | |
| typedef typename List::spec parameter_spec; | |
| typedef typename tag_type<parameter_spec>::type tag_; | |
| typedef is_named_argument<argument> is_tagged; | |
| // If this argument is either explicitly tagged or a deduced | |
| // parameter, we turn off positional matching. | |
| typedef mpl::and_< | |
| mpl::not_< | |
| mpl::or_<is_deduced<parameter_spec>, is_tagged> | |
| > | |
| , Positional | |
| > positional; | |
| // If this parameter is explicitly tagged we add it to the | |
| // used-parmeters set. We only really need to add parameters | |
| // that are deduced, but we would need a way to check if | |
| // a given tag corresponds to a deduced parameter spec. | |
| typedef typename mpl::eval_if< | |
| is_tagged | |
| , insert_tagged<UsedArgs, argument> | |
| , mpl::identity<UsedArgs> | |
| >::type used_args; | |
| // If this parameter is neither explicitly tagged, nor | |
| // positionally matched; deduce the tag from the deduced | |
| // parameter specs. | |
| typedef typename mpl::eval_if< | |
| mpl::or_<is_tagged, positional> | |
| , mpl::pair<void_, used_args> | |
| , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn> | |
| >::type deduced_data; | |
| // If this parameter is explicitly tagged.. | |
| typedef typename mpl::eval_if< | |
| is_tagged | |
| , mpl::identity<argument> // .. just use it | |
| , mpl::eval_if< // .. else, if positional matching is turned on.. | |
| positional | |
| , mpl::apply_wrap2<TagFn, tag_, argument> // .. tag it positionally | |
| , mpl::first<deduced_data> // .. else, use the deduced tag | |
| > | |
| >::type tagged; | |
| // We build the arg_list incrementally as we go, prepending new | |
| // nodes. | |
| typedef typename mpl::if_< | |
| mpl::and_< | |
| is_same<Error, void_> | |
| , is_same<tagged, void_> | |
| > | |
| , parameter_::unmatched_argument<argument> | |
| , void_ | |
| >::type error; | |
| typedef typename mpl::if_< | |
| is_same<tagged, void_> | |
| , ArgumentPack | |
| , arg_list<tagged, ArgumentPack> | |
| >::type argument_pack; | |
| typedef typename make_arg_list_aux< | |
| typename List::tail | |
| , DeducedArgs | |
| , TagFn | |
| , positional | |
| , typename deduced_data::second | |
| , argument_pack | |
| , error | |
| >::type type; | |
| }; | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| template < | |
| class List | |
| , class DeducedArgs | |
| , class TagFn | |
| , class Positional | |
| , class UsedArgs | |
| , class ArgumentPack | |
| , class Error | |
| > | |
| struct make_arg_list0 | |
| { | |
| typedef typename mpl::eval_if< | |
| typename List::is_arg_const | |
| , make_arg_list00< | |
| List | |
| , DeducedArgs | |
| , TagFn | |
| , Positional | |
| , UsedArgs | |
| , ArgumentPack | |
| , typename List::arg const | |
| , Error | |
| > | |
| , make_arg_list00< | |
| List | |
| , DeducedArgs | |
| , TagFn | |
| , Positional | |
| , UsedArgs | |
| , ArgumentPack | |
| , typename List::arg | |
| , Error | |
| > | |
| >::type type; | |
| }; | |
| #endif | |
| // Returns an ArgumentPack where the list of arguments has | |
| // been tagged with keyword tags. | |
| // | |
| // List: A specialization of item<> (see below). Contains | |
| // both the ordered ParameterSpecs, and the given arguments. | |
| // | |
| // DeducedArgs: A specialization of deduced_item<> (see below). | |
| // A list containing only the deduced ParameterSpecs. | |
| // | |
| // TagFn: A metafunction class used to tag positional or deduced | |
| // arguments with a keyword tag. | |
| // | |
| // Position: An mpl::bool_<> specialization indicating if positional | |
| // matching is to be performed. | |
| // | |
| // DeducedSet: An mpl::set<> containing the keyword tags used so far. | |
| // | |
| // ArgumentPack: The ArgumentPack built so far. This is initially an | |
| // empty_arg_list and is built incrementally. | |
| // | |
| template < | |
| class List | |
| , class DeducedArgs | |
| , class TagFn | |
| , class Positional | |
| , class DeducedSet | |
| , class ArgumentPack | |
| , class Error | |
| > | |
| struct make_arg_list_aux | |
| { | |
| typedef typename mpl::eval_if< | |
| is_same<List, void_> | |
| , mpl::identity<mpl::pair<ArgumentPack, Error> > | |
| , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error> | |
| >::type type; | |
| }; | |
| // VC6.5 was choking on the default parameters for make_arg_list_aux, so | |
| // this just forwards to that adding in the defaults. | |
| template < | |
| class List | |
| , class DeducedArgs | |
| , class TagFn | |
| , class EmitErrors = mpl::true_ | |
| > | |
| struct make_arg_list | |
| { | |
| typedef typename make_arg_list_aux< | |
| List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_ | |
| >::type type; | |
| }; | |
| // A parameter spec item typelist. | |
| template <class Spec, class Arg, class Tail = void_> | |
| struct item | |
| { | |
| typedef Spec spec; | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| typedef is_const<Arg> is_arg_const; | |
| #endif | |
| typedef Arg arg; | |
| typedef Tail tail; | |
| }; | |
| template <class Spec, class Arg, class Tail> | |
| struct make_item | |
| { | |
| typedef item<Spec, Arg, typename Tail::type> type; | |
| }; | |
| // Creates a item typelist. | |
| template <class Spec, class Arg, class Tail> | |
| struct make_items | |
| { | |
| typedef typename mpl::eval_if< | |
| is_same<Arg, void_> | |
| , mpl::identity<void_> | |
| , make_item<Spec, Arg, Tail> | |
| >::type type; | |
| }; | |
| // A typelist that stored deduced parameter specs. | |
| template <class ParameterSpec, class Tail = void_> | |
| struct deduced_item | |
| { | |
| typedef ParameterSpec spec; | |
| typedef Tail tail; | |
| }; | |
| // Evaluate Tail and construct deduced_item list. | |
| template <class Spec, class Tail> | |
| struct make_deduced_item | |
| { | |
| typedef deduced_item<Spec, typename Tail::type> type; | |
| }; | |
| template <class Spec, class Tail> | |
| struct make_deduced_items | |
| { | |
| typedef typename mpl::eval_if< | |
| is_same<Spec, void_> | |
| , mpl::identity<void_> | |
| , mpl::eval_if< | |
| is_deduced<Spec> | |
| , make_deduced_item<Spec, Tail> | |
| , Tail | |
| > | |
| >::type type; | |
| }; | |
| // Generates: | |
| // | |
| // make< | |
| // parameter_spec#0, argument_type#0 | |
| // , make< | |
| // parameter_spec#1, argument_type#1 | |
| // , ... mpl::identity<aux::empty_arg_list> | |
| // ...> | |
| // > | |
| #define BOOST_PARAMETER_make_arg_list(z, n, names) \ | |
| BOOST_PP_SEQ_ELEM(0,names)< \ | |
| BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n), \ | |
| BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n), | |
| #define BOOST_PARAMETER_right_angle(z, n, text) > | |
| #define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type) \ | |
| BOOST_PP_REPEAT( \ | |
| n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type)) \ | |
| mpl::identity<void_> \ | |
| BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) | |
| #define BOOST_PARAMETER_make_deduced_list(z, n, names) \ | |
| BOOST_PP_SEQ_ELEM(0,names)< \ | |
| BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n), | |
| #define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec) \ | |
| BOOST_PP_REPEAT( \ | |
| n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec)) \ | |
| mpl::identity<void_> \ | |
| BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _) | |
| struct tag_keyword_arg | |
| { | |
| template <class K, class T> | |
| struct apply | |
| : tag<K,T> | |
| {}; | |
| }; | |
| struct tag_template_keyword_arg | |
| { | |
| template <class K, class T> | |
| struct apply | |
| { | |
| typedef template_keyword<K,T> type; | |
| }; | |
| }; | |
| } // namespace aux | |
| #define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \ | |
| typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i); | |
| #define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \ | |
| BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest)) | |
| #define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_ | |
| template< | |
| class PS0 | |
| , BOOST_PP_ENUM_SHIFTED(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_TEMPLATE_ARGS, _) | |
| > | |
| struct parameters | |
| { | |
| #undef BOOST_PARAMETER_TEMPLATE_ARGS | |
| typedef typename BOOST_PARAMETER_build_deduced_list( | |
| BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS | |
| )::type deduced_list; | |
| // if the elements of NamedList match the criteria of overload | |
| // resolution, returns a type which can be constructed from | |
| // parameters. Otherwise, this is not a valid metafunction (no nested | |
| // ::type). | |
| #if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
| // If NamedList satisfies the PS0, PS1, ..., this is a | |
| // metafunction returning parameters. Otherwise it | |
| // has no nested ::type. | |
| template <class ArgumentPackAndError> | |
| struct match_base | |
| : mpl::if_< | |
| // mpl::and_< | |
| // aux::satisfies_requirements_of<NamedList,PS0> | |
| // , mpl::and_< | |
| // aux::satisfies_requirements_of<NamedList,PS1>... | |
| // ..., mpl::true_ | |
| // ...> > | |
| # define BOOST_PARAMETER_satisfies(z, n, text) \ | |
| mpl::and_< \ | |
| aux::satisfies_requirements_of< \ | |
| typename mpl::first<ArgumentPackAndError>::type \ | |
| , BOOST_PP_CAT(PS, n)> \ | |
| , | |
| mpl::and_< | |
| is_same<typename mpl::second<ArgumentPackAndError>::type, void_> | |
| , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _) | |
| mpl::true_ | |
| BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _) | |
| > | |
| # undef BOOST_PARAMETER_satisfies | |
| , mpl::identity<parameters> | |
| , void_ | |
| > | |
| {}; | |
| #endif | |
| // Specializations are to be used as an optional argument to | |
| // eliminate overloads via SFINAE | |
| template< | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| // Borland simply can't handle default arguments in member | |
| // class templates. People wishing to write portable code can | |
| // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments | |
| BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A) | |
| #else | |
| BOOST_PP_ENUM_BINARY_PARAMS( | |
| BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT | |
| ) | |
| #endif | |
| > | |
| struct match | |
| # if ! defined(BOOST_NO_SFINAE) && ! BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x592)) | |
| : match_base< | |
| typename aux::make_arg_list< | |
| typename BOOST_PARAMETER_build_arg_list( | |
| BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A | |
| )::type | |
| , deduced_list | |
| , aux::tag_keyword_arg | |
| , mpl::false_ // Don't emit errors when doing SFINAE | |
| >::type | |
| >::type | |
| {}; | |
| # else | |
| { | |
| typedef parameters< | |
| BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS) | |
| > type; | |
| }; | |
| # endif | |
| // Metafunction that returns an ArgumentPack. | |
| // TODO, bind has to instantiate the error type in the result | |
| // of make_arg_list. | |
| template < | |
| #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
| // Borland simply can't handle default arguments in member | |
| // class templates. People wishing to write portable code can | |
| // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments | |
| BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A) | |
| #else | |
| BOOST_PP_ENUM_BINARY_PARAMS( | |
| BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT | |
| ) | |
| #endif | |
| > | |
| struct bind | |
| { | |
| typedef typename aux::make_arg_list< | |
| typename BOOST_PARAMETER_build_arg_list( | |
| BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A | |
| )::type | |
| , deduced_list | |
| , aux::tag_template_keyword_arg | |
| >::type result; | |
| typedef typename mpl::first<result>::type type; | |
| }; | |
| BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec) | |
| // | |
| // The function call operator is used to build an arg_list that | |
| // labels the positional parameters and maintains whatever other | |
| // tags may have been specified by the caller. | |
| // | |
| // !!!NOTE!!! | |
| // | |
| // The make_arg_list<> produces a reversed arg_list, so | |
| // we need to pass the arguments to its constructor | |
| // reversed. | |
| // | |
| aux::empty_arg_list operator()() const | |
| { | |
| return aux::empty_arg_list(); | |
| } | |
| template<class A0> | |
| typename mpl::first< | |
| typename aux::make_arg_list< | |
| aux::item< | |
| PS0,A0 | |
| > | |
| , deduced_list | |
| , aux::tag_keyword_arg | |
| >::type | |
| >::type | |
| operator()(A0& a0) const | |
| { | |
| typedef typename aux::make_arg_list< | |
| aux::item< | |
| PS0,A0 | |
| > | |
| , deduced_list | |
| , aux::tag_keyword_arg | |
| >::type result; | |
| typedef typename mpl::first<result>::type result_type; | |
| typedef typename mpl::second<result>::type error; | |
| error(); | |
| return result_type( | |
| a0 | |
| // , void_(), void_(), void_() ... | |
| BOOST_PP_ENUM_TRAILING_PARAMS( | |
| BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1) | |
| , aux::void_reference() BOOST_PP_INTERCEPT) | |
| ); | |
| } | |
| template<class A0, class A1> | |
| typename mpl::first< | |
| typename aux::make_arg_list< | |
| aux::item< | |
| PS0,A0 | |
| , aux::item< | |
| PS1,A1 | |
| > | |
| > | |
| , deduced_list | |
| , aux::tag_keyword_arg | |
| >::type | |
| >::type | |
| operator()(A0& a0, A1& a1) const | |
| { | |
| typedef typename aux::make_arg_list< | |
| aux::item< | |
| PS0,A0 | |
| , aux::item< | |
| PS1,A1 | |
| > | |
| > | |
| , deduced_list | |
| , aux::tag_keyword_arg | |
| >::type result; | |
| typedef typename mpl::first<result>::type result_type; | |
| typedef typename mpl::second<result>::type error; | |
| error(); | |
| return result_type( | |
| a1,a0 | |
| // , void_(), void_() ... | |
| BOOST_PP_ENUM_TRAILING_PARAMS( | |
| BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2) | |
| , aux::void_reference() BOOST_PP_INTERCEPT) | |
| ); | |
| } | |
| // Higher arities are handled by the preprocessor | |
| #define BOOST_PP_ITERATION_PARAMS_1 (3,( \ | |
| 3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \ | |
| )) | |
| #include BOOST_PP_ITERATE() | |
| }; | |
| } // namespace parameter | |
| } // namespace boost | |
| #endif // BOOST_PARAMETERS_031014_HPP | |