// (C) Copyright Jeremy Siek 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Revision History: // 04 Oct 2001 David Abrahams // Changed name of "bind" to "select" to avoid problems with MSVC. #ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #include <boost/type_traits/conversion_traits.hpp> #include <boost/type_traits/composite_traits.hpp> // for is_reference #if defined(__BORLANDC__) #include <boost/type_traits/ice.hpp> #endif namespace boost { namespace detail { struct default_argument { }; struct dummy_default_gen { template <class Base, class Traits> struct select { typedef default_argument type; }; }; // This class template is a workaround for MSVC. template <class Gen> struct default_generator { typedef detail::dummy_default_gen type; }; template <class T> struct is_default { enum { value = false }; typedef type_traits::no_type type; }; template <> struct is_default<default_argument> { enum { value = true }; typedef type_traits::yes_type type; }; struct choose_default { template <class Arg, class DefaultGen, class Base, class Traits> struct select { typedef typename default_generator<DefaultGen>::type Gen; typedef typename Gen::template select<Base,Traits>::type type; }; }; struct choose_arg { template <class Arg, class DefaultGen, class Base, class Traits> struct select { typedef Arg type; }; }; #if defined(__BORLANDC__) template <class UseDefault> struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default<type_traits::yes_type> { typedef choose_default type; }; #else template <bool UseDefault> struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default<true> { typedef choose_default type; }; #endif template <class Arg, class DefaultGen, class Base, class Traits> class resolve_default { #if defined(__BORLANDC__) typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector; #else // This usually works for Borland, but I'm seeing weird errors in // iterator_adaptor_test.cpp when using this method. enum { is_def = is_default<Arg>::value }; typedef typename choose_arg_or_default<is_def>::type Selector; #endif public: typedef typename Selector ::template select<Arg, DefaultGen, Base, Traits>::type type; }; // To differentiate an unnamed parameter from a traits generator // we use is_convertible<X, iter_traits_gen_base>. struct named_template_param_base { }; template <class X> struct is_named_param_list { enum { value = is_convertible<X, named_template_param_base>::value }; }; struct choose_named_params { template <class Prev> struct select { typedef Prev type; }; }; struct choose_default_arg { template <class Prev> struct select { typedef detail::default_argument type; }; }; template <bool Named> struct choose_default_dispatch_; template <> struct choose_default_dispatch_<true> { typedef choose_named_params type; }; template <> struct choose_default_dispatch_<false> { typedef choose_default_arg type; }; // The use of inheritance here is a Solaris Forte 6 workaround. template <bool Named> struct choose_default_dispatch : public choose_default_dispatch_<Named> { }; template <class PreviousArg> struct choose_default_argument { enum { is_named = is_named_param_list<PreviousArg>::value }; typedef typename choose_default_dispatch<is_named>::type Selector; typedef typename Selector::template select<PreviousArg>::type type; }; // This macro assumes that there is a class named default_##TYPE // defined before the application of the macro. This class should // have a single member class template named "select" with two // template parameters: the type of the class being created (e.g., // the iterator_adaptor type when creating iterator adaptors) and // a traits class. The select class should have a single typedef // named "type" that produces the default for TYPE. See // boost/iterator_adaptors.hpp for an example usage. Also, // applications of this macro must be placed in namespace // boost::detail. #define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \ struct get_##TYPE##_from_named { \ template <class Base, class NamedParams, class Traits> \ struct select { \ typedef typename NamedParams::traits NamedTraits; \ typedef typename NamedTraits::TYPE TYPE; \ typedef typename resolve_default<TYPE, \ default_##TYPE, Base, NamedTraits>::type type; \ }; \ }; \ struct pass_thru_##TYPE { \ template <class Base, class Arg, class Traits> struct select { \ typedef typename resolve_default<Arg, \ default_##TYPE, Base, Traits>::type type; \ };\ }; \ template <int NamedParam> \ struct get_##TYPE##_dispatch { }; \ template <> struct get_##TYPE##_dispatch<1> { \ typedef get_##TYPE##_from_named type; \ }; \ template <> struct get_##TYPE##_dispatch<0> { \ typedef pass_thru_##TYPE type; \ }; \ template <class Base, class X, class Traits> \ class get_##TYPE { \ enum { is_named = is_named_param_list<X>::value }; \ typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \ public: \ typedef typename Selector::template select<Base, X, Traits>::type type; \ }; \ template <> struct default_generator<default_##TYPE> { \ typedef default_##TYPE type; \ } } // namespace detail } // namespace boost #endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP