ceph/src/boost/boost/detail/named_template_params.hpp

   1 // (C) Copyright Jeremy Siek 2001.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5
   6 // Revision History:
   7
   8 // 04 Oct 2001   David Abrahams
   9 //      Changed name of "bind" to "select" to avoid problems with MSVC.
  10
  11 #ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
  12 #define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP
  13
  14 #include <boost/type_traits/conversion_traits.hpp>
  15 #include <boost/type_traits/composite_traits.hpp> // for is_reference
  16 #if defined(__BORLANDC__)
  17 #include <boost/type_traits/ice.hpp>
  18 #endif
  19
  20 namespace boost {
  21   namespace detail {
  22
  23     struct default_argument { };
  24
  25     struct dummy_default_gen {
  26       template <class Base, class Traits>
  27       struct select {
  28         typedef default_argument type;
  29       };
  30     };
  31
  32    // This class template is a workaround for MSVC.
  33    template <class Gen> struct default_generator {
  34      typedef detail::dummy_default_gen type;
  35    };
  36
  37     template <class T> struct is_default {
  38       enum { value = false };
  39       typedef type_traits::no_type type;
  40     };
  41     template <> struct is_default<default_argument> {
  42       enum { value = true };
  43       typedef type_traits::yes_type type;
  44     };
  45
  46     struct choose_default {
  47       template <class Arg, class DefaultGen, class Base, class Traits>
  48       struct select {
  49         typedef typename default_generator<DefaultGen>::type Gen;
  50         typedef typename Gen::template select<Base,Traits>::type type;
  51       };
  52     };
  53     struct choose_arg {
  54       template <class Arg, class DefaultGen, class Base, class Traits>
  55       struct select {
  56         typedef Arg type;
  57       };
  58     };
  59
  60 #if defined(__BORLANDC__)
  61     template <class UseDefault>
  62     struct choose_arg_or_default { typedef choose_arg type; };
  63     template <>
  64     struct choose_arg_or_default<type_traits::yes_type> {
  65       typedef choose_default type;
  66     };
  67 #else
  68     template <bool UseDefault>
  69     struct choose_arg_or_default { typedef choose_arg type; };
  70     template <>
  71     struct choose_arg_or_default<true> {
  72       typedef choose_default type;
  73     };
  74 #endif
  75
  76     template <class Arg, class DefaultGen, class Base, class Traits>
  77     class resolve_default {
  78 #if defined(__BORLANDC__)
  79       typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector;
  80 #else
  81       // This usually works for Borland, but I'm seeing weird errors in
  82       // iterator_adaptor_test.cpp when using this method.
  83       enum { is_def = is_default<Arg>::value };
  84       typedef typename choose_arg_or_default<is_def>::type Selector;
  85 #endif
  86     public:
  87       typedef typename Selector
  88         ::template select<Arg, DefaultGen, Base, Traits>::type type;
  89     };
  90
  91     // To differentiate an unnamed parameter from a traits generator
  92     // we use is_convertible<X, iter_traits_gen_base>.
  93     struct named_template_param_base { };
  94
  95     template <class X>
  96     struct is_named_param_list {
  97       enum { value  = is_convertible<X, named_template_param_base>::value };
  98     };
  99
 100     struct choose_named_params {
 101       template <class Prev> struct select { typedef Prev type; };
 102     };
 103     struct choose_default_arg {
 104       template <class Prev> struct select {
 105         typedef detail::default_argument type;
 106       };
 107     };
 108
 109     template <bool Named> struct choose_default_dispatch_;
 110     template <> struct choose_default_dispatch_<true> {
 111       typedef choose_named_params type;
 112     };
 113     template <> struct choose_default_dispatch_<false> {
 114       typedef choose_default_arg type;
 115     };
 116     // The use of inheritance here is a Solaris Forte 6 workaround.
 117     template <bool Named> struct choose_default_dispatch
 118       : public choose_default_dispatch_<Named> { };
 119
 120     template <class PreviousArg>
 121     struct choose_default_argument {
 122       enum { is_named = is_named_param_list<PreviousArg>::value };
 123       typedef typename choose_default_dispatch<is_named>::type Selector;
 124       typedef typename Selector::template select<PreviousArg>::type type;
 125     };
 126
 127     // This macro assumes that there is a class named default_##TYPE
 128     // defined before the application of the macro.  This class should
 129     // have a single member class template named "select" with two
 130     // template parameters: the type of the class being created (e.g.,
 131     // the iterator_adaptor type when creating iterator adaptors) and
 132     // a traits class. The select class should have a single typedef
 133     // named "type" that produces the default for TYPE.  See
 134     // boost/iterator_adaptors.hpp for an example usage.  Also,
 135     // applications of this macro must be placed in namespace
 136     // boost::detail.
 137
 138 #define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \
 139     struct get_##TYPE##_from_named { \
 140       template <class Base, class NamedParams, class Traits> \
 141       struct select { \
 142           typedef typename NamedParams::traits NamedTraits; \
 143           typedef typename NamedTraits::TYPE TYPE; \
 144           typedef typename resolve_default<TYPE, \
 145             default_##TYPE, Base, NamedTraits>::type type; \
 146       }; \
 147     }; \
 148     struct pass_thru_##TYPE { \
 149       template <class Base, class Arg, class Traits> struct select { \
 150           typedef typename resolve_default<Arg, \
 151             default_##TYPE, Base, Traits>::type type; \
 152       };\
 153     }; \
 154     template <int NamedParam> \
 155     struct get_##TYPE##_dispatch { }; \
 156     template <> struct get_##TYPE##_dispatch<1> { \
 157       typedef get_##TYPE##_from_named type; \
 158     }; \
 159     template <> struct get_##TYPE##_dispatch<0> { \
 160       typedef pass_thru_##TYPE type; \
 161     }; \
 162     template <class Base, class X, class Traits>  \
 163     class get_##TYPE { \
 164       enum { is_named = is_named_param_list<X>::value }; \
 165       typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \
 166     public: \
 167       typedef typename Selector::template select<Base, X, Traits>::type type; \
 168     }; \
 169     template <> struct default_generator<default_##TYPE> { \
 170       typedef default_##TYPE type; \
 171     }
 172
 173
 174   } // namespace detail
 175 } // namespace boost
 176
 177 #endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP