diff options
Diffstat (limited to '3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp b/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp new file mode 100644 index 0000000..6248be2 --- /dev/null +++ b/3rdParty/Boost/src/boost/parameter/aux_/tagged_argument.hpp @@ -0,0 +1,188 @@ +// Copyright Daniel Wallin, David Abrahams 2005. 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_PARAMETER_TAGGED_ARGUMENT_050328_HPP +# define BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP + +# include <boost/parameter/aux_/void.hpp> +# include <boost/parameter/aux_/arg_list.hpp> +# include <boost/parameter/aux_/result_of0.hpp> +# include <boost/mpl/if.hpp> +# include <boost/mpl/apply_wrap.hpp> +# include <boost/mpl/and.hpp> +# include <boost/mpl/not.hpp> +# include <boost/type_traits/is_same.hpp> +# include <boost/type_traits/is_convertible.hpp> +# include <boost/type_traits/is_reference.hpp> + +namespace boost { namespace parameter { namespace aux { + +struct empty_arg_list; +struct arg_list_tag; + +struct tagged_argument_base {}; + +// Holds a reference to an argument of type Arg associated with +// keyword Keyword + +template <class Keyword, class Arg> +struct tagged_argument : tagged_argument_base +{ + typedef Keyword key_type; + typedef Arg value_type; + typedef Arg& reference; + + tagged_argument(reference x) : value(x) {} + + // A metafunction class that, given a keyword and a default + // type, returns the appropriate result type for a keyword + // lookup given that default + struct binding + { + template <class KW, class Default, class Reference> + struct apply + { + typedef typename mpl::eval_if< + boost::is_same<KW, key_type> + , mpl::if_<Reference, reference, value_type> + , mpl::identity<Default> + >::type type; + }; + }; + + // Comma operator to compose argument list without using parameters<>. + // Useful for argument lists with undetermined length. + template <class Keyword2, class Arg2> + arg_list< + tagged_argument<Keyword, Arg> + , arg_list<tagged_argument<Keyword2, Arg2> > + > + operator,(tagged_argument<Keyword2, Arg2> x) const + { + return arg_list< + tagged_argument<Keyword, Arg> + , arg_list<tagged_argument<Keyword2, Arg2> > + >( + *this + , arg_list<tagged_argument<Keyword2, Arg2> >(x, empty_arg_list()) + ); + } + + reference operator[](keyword<Keyword> const&) const + { + return value; + } + +# if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template <class KW, class Default> + Default& get_with_default(default_<KW,Default> const& x, int) const + { + return x.value; + } + + template <class Default> + reference get_with_default(default_<key_type,Default> const&, long) const + { + return value; + } + + template <class KW, class Default> + typename mpl::apply_wrap3<binding, KW, Default&, mpl::true_>::type + operator[](default_<KW,Default> const& x) const + { + return get_with_default(x, 0L); + } + + template <class KW, class F> + typename result_of0<F>::type + get_with_lazy_default(lazy_default<KW,F> const& x, int) const + { + return x.compute_default(); + } + + template <class F> + reference get_with_lazy_default(lazy_default<key_type,F> const&, long) const + { + return value; + } + + template <class KW, class F> + typename mpl::apply_wrap3< + binding,KW + , typename result_of0<F>::type + , mpl::true_ + >::type + operator[](lazy_default<KW,F> const& x) const + { + return get_with_lazy_default(x, 0L); + } +# else + template <class Default> + reference operator[](default_<key_type,Default> const& x) const + { + return value; + } + + template <class F> + reference operator[](lazy_default<key_type,F> const& x) const + { + return value; + } + + template <class KW, class Default> + Default& operator[](default_<KW,Default> const& x) const + { + return x.value; + } + + template <class KW, class F> + typename result_of0<F>::type operator[](lazy_default<KW,F> const& x) const + { + return x.compute_default(); + } + + template <class ParameterRequirements> + static typename ParameterRequirements::has_default + satisfies(ParameterRequirements*); + + template <class HasDefault, class Predicate> + static typename mpl::apply1<Predicate, value_type>::type + satisfies( + parameter_requirements<key_type,Predicate,HasDefault>* + ); +# endif + + reference value; +# if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310)) + // warning suppression + private: + void operator=(tagged_argument const&); + public: +# endif + // MPL sequence support + typedef tagged_argument type; // Convenience for users + typedef empty_arg_list tail_type; // For the benefit of iterators + typedef arg_list_tag tag; // For dispatching to sequence intrinsics +}; + +// Defines a metafunction, is_tagged_argument, that identifies +// tagged_argument specializations and their derived classes. +template <class T> +struct is_tagged_argument_aux + : is_convertible<T*,tagged_argument_base const*> +{}; + +template <class T> +struct is_tagged_argument + : mpl::and_< + mpl::not_<is_reference<T> > + , is_tagged_argument_aux<T> + > +{}; + +}}} // namespace boost::parameter::aux + +#endif // BOOST_PARAMETER_TAGGED_ARGUMENT_050328_HPP + |