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