Symaptic: os/ossrv/ossrv_pub/boost_apis/boost/parameter/parameters.hpp@260cb5ec6c19

     1 // Copyright David Abrahams, Daniel Wallin 2003. Use, modification and

     2 // distribution is subject to the Boost Software License, Version 1.0.

     3 // (See accompanying file LICENSE_1_0.txt or copy at

     4 // http://www.boost.org/LICENSE_1_0.txt)

     6 #ifndef BOOST_PARAMETERS_031014_HPP

     7 #define BOOST_PARAMETERS_031014_HPP

     9 #include <boost/detail/is_xxx.hpp>

    11 #include <boost/type_traits/is_const.hpp>

    13 #include <boost/mpl/lambda.hpp>

    14 #include <boost/mpl/apply.hpp>

    15 #include <boost/mpl/always.hpp>

    16 #include <boost/mpl/and.hpp>

    17 #include <boost/mpl/or.hpp>

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

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

    20 #include <boost/mpl/not.hpp>

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

    22 #include <boost/mpl/pair.hpp>

    24 #include <boost/type_traits/is_same.hpp>

    25 #include <boost/type_traits/remove_reference.hpp>

    27 #include <boost/preprocessor/repetition/enum.hpp>

    28 #include <boost/preprocessor/repetition/enum_params.hpp>

    29 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>

    30 #include <boost/preprocessor/arithmetic/sub.hpp>

    31 #include <boost/preprocessor/repetition/repeat.hpp>

    32 #include <boost/preprocessor/repetition/enum_shifted.hpp>

    33 #include <boost/preprocessor/repetition/enum_binary_params.hpp>

    34 #include <boost/preprocessor/repetition/enum_shifted_params.hpp>

    35 #include <boost/preprocessor/seq/elem.hpp>

    36 #include <boost/preprocessor/iteration/iterate.hpp>

    37 #include <boost/preprocessor/facilities/intercept.hpp>

    38 #include <boost/preprocessor/cat.hpp>

    40 #include <boost/parameter/aux_/arg_list.hpp>

    41 #include <boost/parameter/aux_/yesno.hpp>

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

    43 #include <boost/parameter/aux_/default.hpp>

    44 #include <boost/parameter/aux_/unwrap_cv_reference.hpp>

    45 #include <boost/parameter/aux_/tagged_argument.hpp>

    46 #include <boost/parameter/aux_/tag.hpp>

    47 #include <boost/parameter/aux_/template_keyword.hpp>

    48 #include <boost/parameter/aux_/set.hpp>

    49 #include <boost/parameter/config.hpp>

    51 namespace parameter_

    52 {

    53   template <class T>

    54   struct unmatched_argument

    55   {

    56       BOOST_MPL_ASSERT((boost::is_same<T,void>));

    57       typedef int type;

    58   };

    59 } // namespace parameter_

    61 namespace boost {

    63 template<class T> class reference_wrapper;

    65 namespace parameter {

    67 namespace aux { struct use_default {}; }

    69 // These templates can be used to describe the treatment of particular

    70 // named parameters for the purposes of overload elimination with

    71 // SFINAE, by placing specializations in the parameters<...> list.  In

    72 // order for a treated function to participate in overload resolution:

    73 //

    74 //   - all keyword tags wrapped in required<...> must have a matching

    75 //     actual argument

    76 //

    77 //   - The actual argument type matched by every keyword tag

    78 //     associated with a predicate must satisfy that predicate

    79 //

    80 // If a keyword k is specified without an optional<...> or

    81 // required<...>, wrapper, it is treated as though optional<k> were

    82 // specified.

    83 //

    84 // If a keyword k is specified with deduced<...>, that keyword

    85 // will be automatically deduced from the argument list.

    86 //

    87 template <class Tag, class Predicate = aux::use_default>

    88 struct required

    89 {

    90     typedef Tag key_type;

    91     typedef Predicate predicate;

    92 };

    94 template <class Tag, class Predicate = aux::use_default>

    95 struct optional

    96 {

    97     typedef Tag key_type;

    98     typedef Predicate predicate;

    99 };

   101 template <class Tag>

   102 struct deduced

   103 {

   104     typedef Tag key_type;

   105 };

   107 namespace aux

   108 {

   109   // Defines metafunctions, is_required and is_optional, that

   110   // identify required<...>, optional<...> and deduced<...> specializations.

   111   BOOST_DETAIL_IS_XXX_DEF(required, required, 2)

   112   BOOST_DETAIL_IS_XXX_DEF(optional, optional, 2)

   113   BOOST_DETAIL_IS_XXX_DEF(deduced_aux, deduced, 1)

   115   template <class S>

   116   struct is_deduced0

   117     : is_deduced_aux<

   118           typename S::key_type

   119       >::type

   120   {};

   122   template <class S>

   123   struct is_deduced

   124     : mpl::eval_if<

   125           mpl::or_<

   126               is_optional<S>, is_required<S>

   127           >

   128         , is_deduced0<S>

   129         , mpl::false_

   130       >::type

   131   {};

   133   //

   134   // key_type, has_default, and predicate --

   135   //

   136   // These metafunctions accept a ParameterSpec and extract the

   137   // keyword tag, whether or not a default is supplied for the

   138   // parameter, and the predicate that the corresponding actual

   139   // argument type is required match.

   140   //

   141   // a ParameterSpec is a specialization of either keyword<...>,

   142   // required<...>, optional<...>

   143   //

   145   // helper for key_type<...>, below.

   146   template <class T>

   147   struct get_tag_type0

   148   {

   149       typedef typename T::key_type type;

   150   };

   152   template <class T>

   153   struct get_tag_type

   154     : mpl::eval_if<

   155           is_deduced_aux<typename T::key_type>

   156         , get_tag_type0<typename T::key_type>

   157         , mpl::identity<typename T::key_type>

   158       >

   159   {};

   161   template <class T>

   162   struct tag_type

   163     : mpl::eval_if<

   164           mpl::or_<

   165               is_optional<T>

   166             , is_required<T>

   167           >

   168         , get_tag_type<T>

   169         , mpl::identity<T>

   170       >

   171   {};

   173   template <class T>

   174   struct has_default

   175     : mpl::not_<is_required<T> >

   176   {};

   178   // helper for get_predicate<...>, below

   179   template <class T>

   180   struct get_predicate_or_default

   181   {

   182       typedef T type;

   183   };

   185   template <>

   186   struct get_predicate_or_default<use_default>

   187   {

   188       typedef mpl::always<mpl::true_> type;

   189   };

   191   // helper for predicate<...>, below

   192   template <class T>

   193   struct get_predicate

   194   {

   195       typedef typename

   196           get_predicate_or_default<typename T::predicate>::type

   197       type;

   198   };

   200   template <class T>

   201   struct predicate

   202     : mpl::eval_if<

   203          mpl::or_<

   204               is_optional<T>

   205             , is_required<T>

   206           >

   207         , get_predicate<T>

   208         , mpl::identity<mpl::always<mpl::true_> >

   209       >

   210   {

   211   };

   214   // Converts a ParameterSpec into a specialization of

   215   // parameter_requirements.  We need to do this in order to get the

   216   // tag_type into the type in a way that can be conveniently matched

   217   // by a satisfies(...) member function in arg_list.

   218   template <class ParameterSpec>

   219   struct as_parameter_requirements

   220   {

   221       typedef parameter_requirements<

   222           typename tag_type<ParameterSpec>::type

   223         , typename predicate<ParameterSpec>::type

   224         , typename has_default<ParameterSpec>::type

   225       > type;

   226   };

   228   template <class T>

   229   struct is_named_argument

   230     : mpl::or_<

   231           is_template_keyword<T>

   232         , is_tagged_argument<T>

   233       >

   234   {};

   236   // Returns mpl::true_ iff the given ParameterRequirements are

   237   // satisfied by ArgList.

   238   template <class ArgList, class ParameterRequirements>

   239   struct satisfies

   240   {

   241 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)

   242       // VC7.1 can't handle the sizeof() implementation below,

   243       // so we use this instead.

   244       typedef typename mpl::apply_wrap3<

   245           typename ArgList::binding

   246         , typename ParameterRequirements::keyword

   247         , void_

   248         , mpl::false_

   249       >::type bound;

   251       typedef typename mpl::eval_if<

   252           is_same<bound, void_>

   253         , typename ParameterRequirements::has_default

   254         , mpl::apply_wrap2<

   255               typename mpl::lambda<

   256                   typename ParameterRequirements::predicate, lambda_tag

   257               >::type

   258             , bound

   259             , ArgList

   260           >

   261       >::type type;

   262 #else

   263       BOOST_STATIC_CONSTANT(

   264           bool, value = (

   265               sizeof(

   266                   aux::to_yesno(

   267                       ArgList::satisfies((ParameterRequirements*)0, (ArgList*)0)

   268                   )

   269               ) == sizeof(yes_tag)

   270           )

   271       );

   273       typedef mpl::bool_<satisfies::value> type;

   274 #endif

   275   };

   277   // Returns mpl::true_ if the requirements of the given ParameterSpec

   278   // are satisfied by ArgList.

   279   template <class ArgList, class ParameterSpec>

   280   struct satisfies_requirements_of

   281     : satisfies<

   282           ArgList

   283         , typename as_parameter_requirements<ParameterSpec>::type

   284       >

   285   {};

   287   // Tags a deduced argument Arg with the keyword tag of Spec using TagFn.

   288   // Returns the tagged argument and the mpl::set<> UsedArgs with the

   289   // tag of Spec inserted.

   290   template <class UsedArgs, class Spec, class Arg, class TagFn>

   291   struct tag_deduced

   292   {

   293       typedef mpl::pair<

   294           typename mpl::apply_wrap2<TagFn, typename tag_type<Spec>::type, Arg>::type

   295         , typename aux::insert_<UsedArgs, typename tag_type<Spec>::type>::type

   296       > type;

   297   };

   299   template <

   300       class Argument

   301     , class ArgumentPack

   302     , class DeducedArgs

   303     , class UsedArgs

   304     , class TagFn

   305   >

   306   struct deduce_tag;

   308   // Tag type passed to MPL lambda.

   309   struct lambda_tag;

   311   // Helper for deduce_tag<> below.

   312   template <

   313       class Argument

   314     , class ArgumentPack

   315     , class DeducedArgs

   316     , class UsedArgs

   317     , class TagFn

   318   >

   319   struct deduce_tag0

   320   {

   321       typedef typename DeducedArgs::spec spec;

   323       typedef typename mpl::apply_wrap2<

   324           typename mpl::lambda<

   325               typename spec::predicate, lambda_tag

   326           >::type

   327         , Argument

   328         , ArgumentPack

   329       >::type condition;

   331       // Deduced parameter matches several arguments.

   333       BOOST_MPL_ASSERT((

   334           mpl::not_<mpl::and_<

   335               condition

   336             , aux::has_key_<UsedArgs, typename tag_type<spec>::type>

   337           > >

   338       ));

   340       typedef typename mpl::eval_if<

   341           condition

   342         , tag_deduced<UsedArgs, spec, Argument, TagFn>

   343         , deduce_tag<Argument, ArgumentPack, typename DeducedArgs::tail, UsedArgs, TagFn>

   344       >::type type;

   345   };

   347   // Tries to deduced a keyword tag for a given Argument.

   348   // Returns an mpl::pair<> consisting of the tagged_argument<>,

   349   // and an mpl::set<> where the new tag has been inserted.

   350   //

   351   //  Argument: The argument type to be tagged.

   352   //

   353   //  ArgumentPack: The ArgumentPack built so far.

   354   //

   355   //  DeducedArgs: A specialization of deduced_item<> (see below).

   356   //               A list containing only the deduced ParameterSpecs.

   357   //

   358   //  UsedArgs: An mpl::set<> containing the keyword tags used so far.

   359   //

   360   //  TagFn: A metafunction class used to tag positional or deduced

   361   //         arguments with a keyword tag.

   363   template <

   364       class Argument

   365     , class ArgumentPack

   366     , class DeducedArgs

   367     , class UsedArgs

   368     , class TagFn

   369   >

   370   struct deduce_tag

   371   {

   372       typedef typename mpl::eval_if<

   373           is_same<DeducedArgs, void_>

   374         , mpl::pair<void_, UsedArgs>

   375         , deduce_tag0<Argument, ArgumentPack, DeducedArgs, UsedArgs, TagFn>

   376       >::type type;

   377   };

   379   template <

   380       class List

   381     , class DeducedArgs

   382     , class TagFn

   383     , class Positional

   384     , class UsedArgs

   385     , class ArgumentPack

   386     , class Error

   387   >

   388   struct make_arg_list_aux;

   390   // Inserts Tagged::key_type into the UserArgs set.

   391   // Extra indirection to lazily evaluate Tagged::key_type.

   392   template <class UsedArgs, class Tagged>

   393   struct insert_tagged

   394   {

   395       typedef typename aux::insert_<

   396           UsedArgs, typename Tagged::key_type

   397       >::type type;

   398   };

   400   // Borland needs the insane extra-indirection workaround below

   401   // so that it doesn't magically drop the const qualifier from

   402   // the argument type.

   404   template <

   405       class List

   406     , class DeducedArgs

   407     , class TagFn

   408     , class Positional

   409     , class UsedArgs

   410     , class ArgumentPack

   411 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   412     , class argument

   413 #endif

   414     , class Error

   415   >

   416 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   417   struct make_arg_list00

   418 #else

   419   struct make_arg_list0

   420 #endif

   421   {

   422 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   423       typedef typename List::arg argument;

   424 #endif

   425       typedef typename List::spec parameter_spec;

   426       typedef typename tag_type<parameter_spec>::type tag_;

   428       typedef is_named_argument<argument> is_tagged;

   430       // If this argument is either explicitly tagged or a deduced

   431       // parameter, we turn off positional matching.

   432       typedef mpl::and_<

   433           mpl::not_<

   434               mpl::or_<is_deduced<parameter_spec>, is_tagged>

   435           >

   436         , Positional

   437       > positional;

   439       // If this parameter is explicitly tagged we add it to the

   440       // used-parmeters set. We only really need to add parameters

   441       // that are deduced, but we would need a way to check if

   442       // a given tag corresponds to a deduced parameter spec.

   443       typedef typename mpl::eval_if<

   444           is_tagged

   445         , insert_tagged<UsedArgs, argument>

   446         , mpl::identity<UsedArgs>

   447       >::type used_args;

   449       // If this parameter is neither explicitly tagged, nor

   450       // positionally matched; deduce the tag from the deduced

   451       // parameter specs.

   452       typedef typename mpl::eval_if<

   453           mpl::or_<is_tagged, positional>

   454         , mpl::pair<void_, used_args>

   455         , deduce_tag<argument, ArgumentPack, DeducedArgs, used_args, TagFn>

   456       >::type deduced_data;

   458       // If this parameter is explicitly tagged..

   459       typedef typename mpl::eval_if<

   460           is_tagged

   461         , mpl::identity<argument>                        // .. just use it

   462         , mpl::eval_if<                                  // .. else, if positional matching is turned on..

   463                 positional

   464               , mpl::apply_wrap2<TagFn, tag_, argument>  // .. tag it positionally

   465               , mpl::first<deduced_data>                 // .. else, use the deduced tag

   466           >

   467       >::type tagged;

   469       // We build the arg_list incrementally as we go, prepending new

   470       // nodes.

   472       typedef typename mpl::if_<

   473           mpl::and_<

   474               is_same<Error, void_>

   475             , is_same<tagged, void_>

   476           >

   477         , parameter_::unmatched_argument<argument>

   478         , void_

   479       >::type error;

   481       typedef typename mpl::if_<

   482           is_same<tagged, void_>

   483         , ArgumentPack

   484         , arg_list<tagged, ArgumentPack>

   485       >::type argument_pack;

   487       typedef typename make_arg_list_aux<

   488           typename List::tail

   489         , DeducedArgs

   490         , TagFn

   491         , positional

   492         , typename deduced_data::second

   493         , argument_pack

   494         , error

   495       >::type type;

   496   };

   498 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   499   template <

   500       class List

   501     , class DeducedArgs

   502     , class TagFn

   503     , class Positional

   504     , class UsedArgs

   505     , class ArgumentPack

   506     , class Error

   507   >

   508   struct make_arg_list0

   509   {

   510       typedef typename mpl::eval_if<

   511           typename List::is_arg_const

   512         , make_arg_list00<

   513               List

   514             , DeducedArgs

   515             , TagFn

   516             , Positional

   517             , UsedArgs

   518             , ArgumentPack

   519             , typename List::arg const

   520             , Error

   521           >

   522         , make_arg_list00<

   523               List

   524             , DeducedArgs

   525             , TagFn

   526             , Positional

   527             , UsedArgs

   528             , ArgumentPack

   529             , typename List::arg

   530             , Error

   531           >

   532       >::type type;

   533   };

   534 #endif

   536   // Returns an ArgumentPack where the list of arguments has

   537   // been tagged with keyword tags.

   538   //

   539   //   List: A specialization of item<> (see below). Contains

   540   //         both the ordered ParameterSpecs, and the given arguments.

   541   //

   542   //   DeducedArgs: A specialization of deduced_item<> (see below).

   543   //                A list containing only the deduced ParameterSpecs.

   544   //

   545   //   TagFn: A metafunction class used to tag positional or deduced

   546   //          arguments with a keyword tag.

   547   //

   548   //   Position: An mpl::bool_<> specialization indicating if positional

   549   //             matching is to be performed.

   550   //

   551   //   DeducedSet: An mpl::set<> containing the keyword tags used so far.

   552   //

   553   //   ArgumentPack: The ArgumentPack built so far. This is initially an

   554   //                 empty_arg_list and is built incrementally.

   555   //

   557   template <

   558       class List

   559     , class DeducedArgs

   560     , class TagFn

   561     , class Positional

   562     , class DeducedSet

   563     , class ArgumentPack

   564     , class Error

   565   >

   566   struct make_arg_list_aux

   567   {

   568       typedef typename mpl::eval_if<

   569           is_same<List, void_>

   570         , mpl::identity<mpl::pair<ArgumentPack, Error> >

   571         , make_arg_list0<List, DeducedArgs, TagFn, Positional, DeducedSet, ArgumentPack, Error>

   572       >::type type;

   573   };

   575   // VC6.5 was choking on the default parameters for make_arg_list_aux, so

   576   // this just forwards to that adding in the defaults.

   577   template <

   578       class List

   579     , class DeducedArgs

   580     , class TagFn

   581     , class EmitErrors = mpl::true_

   582   >

   583   struct make_arg_list

   584   {

   585       typedef typename make_arg_list_aux<

   586           List, DeducedArgs, TagFn, mpl::true_, aux::set0, empty_arg_list, void_

   587       >::type type;

   588   };

   590   // A parameter spec item typelist.

   591   template <class Spec, class Arg, class Tail = void_>

   592   struct item

   593   {

   594       typedef Spec spec;

   596 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   597       typedef is_const<Arg> is_arg_const;

   598 #endif

   600       typedef Arg arg;

   601       typedef Tail tail;

   602   };

   604   template <class Spec, class Arg, class Tail>

   605   struct make_item

   606   {

   607       typedef item<Spec, Arg, typename Tail::type> type;

   608   };

   610   // Creates a item typelist.

   611   template <class Spec, class Arg, class Tail>

   612   struct make_items

   613   {

   614       typedef typename mpl::eval_if<

   615           is_same<Arg, void_>

   616         , mpl::identity<void_>

   617         , make_item<Spec, Arg, Tail>

   618       >::type type;

   619   };

   621   // A typelist that stored deduced parameter specs.

   622   template <class ParameterSpec, class Tail = void_>

   623   struct deduced_item

   624   {

   625       typedef ParameterSpec spec;

   626       typedef Tail tail;

   627   };

   629   // Evaluate Tail and construct deduced_item list.

   630   template <class Spec, class Tail>

   631   struct make_deduced_item

   632   {

   633       typedef deduced_item<Spec, typename Tail::type> type;

   634   };

   636   template <class Spec, class Tail>

   637   struct make_deduced_items

   638   {

   639       typedef typename mpl::eval_if<

   640           is_same<Spec, void_>

   641         , mpl::identity<void_>

   642         , mpl::eval_if<

   643               is_deduced<Spec>

   644             , make_deduced_item<Spec, Tail>

   645             , Tail

   646           >

   647       >::type type;

   648   };

   650   // Generates:

   651   //

   652   //   make<

   653   //       parameter_spec#0, argument_type#0

   654   //     , make<

   655   //           parameter_spec#1, argument_type#1

   656   //         , ... mpl::identity<aux::empty_arg_list>

   657   //    ...>

   658   //   >

   659 #define BOOST_PARAMETER_make_arg_list(z, n, names)      \

   660       BOOST_PP_SEQ_ELEM(0,names)<                       \

   661           BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),  \

   662           BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(2,names), n),

   664 #define BOOST_PARAMETER_right_angle(z, n, text) >

   666 #define BOOST_PARAMETER_build_arg_list(n, make, parameter_spec, argument_type)      \

   667   BOOST_PP_REPEAT(                                                                  \

   668       n, BOOST_PARAMETER_make_arg_list, (make)(parameter_spec)(argument_type))      \

   669       mpl::identity<void_>                                                          \

   670   BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)

   672 #define BOOST_PARAMETER_make_deduced_list(z, n, names)  \

   673       BOOST_PP_SEQ_ELEM(0,names)<                       \

   674           BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names), n),

   676 #define BOOST_PARAMETER_build_deduced_list(n, make, parameter_spec)                 \

   677   BOOST_PP_REPEAT(                                                                  \

   678       n, BOOST_PARAMETER_make_deduced_list, (make)(parameter_spec))                 \

   679   mpl::identity<void_>                                                              \

   680   BOOST_PP_REPEAT(n, BOOST_PARAMETER_right_angle, _)

   682   struct tag_keyword_arg

   683   {

   684       template <class K, class T>

   685       struct apply

   686         : tag<K,T>

   687       {};

   688   };

   690   struct tag_template_keyword_arg

   691   {

   692       template <class K, class T>

   693       struct apply

   694       {

   695           typedef template_keyword<K,T> type;

   696       };

   697   };

   699 } // namespace aux

   701 #define BOOST_PARAMETER_FORWARD_TYPEDEF(z, i, names) \

   702     typedef BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(0,names),i) BOOST_PP_CAT(BOOST_PP_SEQ_ELEM(1,names),i);

   704 #define BOOST_PARAMETER_FORWARD_TYPEDEFS(n, src, dest) \

   705     BOOST_PP_REPEAT(n, BOOST_PARAMETER_FORWARD_TYPEDEF, (src)(dest))

   708 #define BOOST_PARAMETER_TEMPLATE_ARGS(z, n, text) class BOOST_PP_CAT(PS, n) = void_

   710 template<

   711      class PS0

   712    , BOOST_PP_ENUM_SHIFTED(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_TEMPLATE_ARGS, _)

   713 >

   714 struct parameters

   715 {

   716 #undef BOOST_PARAMETER_TEMPLATE_ARGS

   718     typedef typename BOOST_PARAMETER_build_deduced_list(

   719         BOOST_PARAMETER_MAX_ARITY, aux::make_deduced_items, PS

   720     )::type deduced_list;

   722     // if the elements of NamedList match the criteria of overload

   723     // resolution, returns a type which can be constructed from

   724     // parameters.  Otherwise, this is not a valid metafunction (no nested

   725     // ::type).

   728 #ifndef BOOST_NO_SFINAE

   729     // If NamedList satisfies the PS0, PS1, ..., this is a

   730     // metafunction returning parameters.  Otherwise it

   731     // has no nested ::type.

   732     template <class ArgumentPackAndError>

   733     struct match_base

   734       : mpl::if_<

   735             // mpl::and_<

   736             //    aux::satisfies_requirements_of<NamedList,PS0>

   737             //  , mpl::and_<

   738             //       aux::satisfies_requirements_of<NamedList,PS1>...

   739             //           ..., mpl::true_

   740             // ...> >

   742 # define BOOST_PARAMETER_satisfies(z, n, text)                                      \

   743             mpl::and_<                                                              \

   744                 aux::satisfies_requirements_of<                                     \

   745                     typename mpl::first<ArgumentPackAndError>::type                 \

   746                   , BOOST_PP_CAT(PS, n)>                                            \

   747                   ,

   748             mpl::and_<

   749                 is_same<typename mpl::second<ArgumentPackAndError>::type, void_>

   750               , BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_satisfies, _)

   751                 mpl::true_

   752                 BOOST_PP_REPEAT(BOOST_PARAMETER_MAX_ARITY, BOOST_PARAMETER_right_angle, _)

   753             >

   755 # undef BOOST_PARAMETER_satisfies

   757           , mpl::identity<parameters>

   758           , void_

   759         >

   760     {};

   761 #endif

   763     // Specializations are to be used as an optional argument to

   764     // eliminate overloads via SFINAE

   765     template<

   766 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   767         // Borland simply can't handle default arguments in member

   768         // class templates.  People wishing to write portable code can

   769         // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments

   770         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)

   771 #else

   772         BOOST_PP_ENUM_BINARY_PARAMS(

   773             BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT

   774         )

   775 #endif

   776     >

   777     struct match

   778 # ifndef BOOST_NO_SFINAE

   779       : match_base<

   780             typename aux::make_arg_list<

   781                 typename BOOST_PARAMETER_build_arg_list(

   782                     BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A

   783                 )::type

   784               , deduced_list

   785               , aux::tag_keyword_arg

   786               , mpl::false_ // Don't emit errors when doing SFINAE

   787             >::type

   788         >::type

   789     {};

   790 # else

   791     {

   792         typedef parameters<

   793             BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, PS)

   794         > type;

   795     };

   796 # endif

   798     // Metafunction that returns an ArgumentPack.

   800     // TODO, bind has to instantiate the error type in the result

   801     // of make_arg_list.

   803     template <

   804 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))

   805         // Borland simply can't handle default arguments in member

   806         // class templates.  People wishing to write portable code can

   807         // explicitly specify BOOST_PARAMETER_MAX_ARITY arguments

   808         BOOST_PP_ENUM_PARAMS(BOOST_PARAMETER_MAX_ARITY, class A)

   809 #else

   810         BOOST_PP_ENUM_BINARY_PARAMS(

   811             BOOST_PARAMETER_MAX_ARITY, class A, = void_ BOOST_PP_INTERCEPT

   812         )

   813 #endif

   814     >

   815     struct bind

   816     {

   817         typedef typename aux::make_arg_list<

   818             typename BOOST_PARAMETER_build_arg_list(

   819                 BOOST_PARAMETER_MAX_ARITY, aux::make_items, PS, A

   820             )::type

   821           , deduced_list

   822           , aux::tag_template_keyword_arg

   823         >::type result;

   825         typedef typename mpl::first<result>::type type;

   826     };

   828     BOOST_PARAMETER_FORWARD_TYPEDEFS(BOOST_PARAMETER_MAX_ARITY, PS, parameter_spec)

   830     //

   831     // The function call operator is used to build an arg_list that

   832     // labels the positional parameters and maintains whatever other

   833     // tags may have been specified by the caller.

   834     //

   835     // !!!NOTE!!!

   836     //

   837     // The make_arg_list<> produces a reversed arg_list, so

   838     // we need to pass the arguments to it's constructor

   839     // reversed.

   840     //

   841     aux::empty_arg_list operator()() const

   842     {

   843        return aux::empty_arg_list();

   844     }

   846     template<class A0>

   847     typename mpl::first<

   848         typename aux::make_arg_list<

   849             aux::item<

   850                 PS0,A0

   851             >

   852           , deduced_list

   853           , aux::tag_keyword_arg

   854         >::type

   855     >::type

   856     operator()(A0& a0) const

   857     {

   858         typedef typename aux::make_arg_list<

   859             aux::item<

   860                 PS0,A0

   861             >

   862           , deduced_list

   863           , aux::tag_keyword_arg

   864         >::type result;

   866         typedef typename mpl::first<result>::type result_type;

   867         typedef typename mpl::second<result>::type error;

   868         error();

   870         return result_type(

   871             a0

   872             // , void_(), void_(), void_() ...

   873             BOOST_PP_ENUM_TRAILING_PARAMS(

   874                 BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 1)

   875               , aux::void_reference() BOOST_PP_INTERCEPT)

   876         );

   877     }

   879     template<class A0, class A1>

   880     typename mpl::first<

   881         typename aux::make_arg_list<

   882             aux::item<

   883                 PS0,A0

   884               , aux::item<

   885                     PS1,A1

   886                 >

   887             >

   888           , deduced_list

   889           , aux::tag_keyword_arg

   890         >::type

   891     >::type

   892     operator()(A0& a0, A1& a1) const

   893     {

   894         typedef typename aux::make_arg_list<

   895             aux::item<

   896                 PS0,A0

   897               , aux::item<

   898                     PS1,A1

   899                 >

   900             >

   901           , deduced_list

   902           , aux::tag_keyword_arg

   903         >::type result;

   905         typedef typename mpl::first<result>::type result_type;

   906         typedef typename mpl::second<result>::type error;

   907         error();

   909         return result_type(

   910             a1,a0

   911             // , void_(), void_() ...

   912             BOOST_PP_ENUM_TRAILING_PARAMS(

   913                 BOOST_PP_SUB(BOOST_PARAMETER_MAX_ARITY, 2)

   914               , aux::void_reference() BOOST_PP_INTERCEPT)

   915         );

   916     }

   918     // Higher arities are handled by the preprocessor

   919 #define BOOST_PP_ITERATION_PARAMS_1 (3,( \

   920         3,BOOST_PARAMETER_MAX_ARITY,<boost/parameter/aux_/overloads.hpp> \

   921     ))

   922 #include BOOST_PP_ITERATE()

   924 };

   926 } // namespace parameter

   928 } // namespace boost

   930 #endif // BOOST_PARAMETERS_031014_HPP

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--