boost/detail/ob_call_traits.hpp

   1 //  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000.
   2 //  Use, modification and distribution are subject to the Boost Software License,
   3 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt).
   5 //
   6 //  See http://www.boost.org/libs/utility for most recent version including documentation.
   7 //
   8 //  Crippled version for crippled compilers:
   9 //  see libs/utility/call_traits.htm
  10 //
  11
  12 /* Release notes:
  13    01st October 2000:
  14       Fixed call_traits on VC6, using "poor man's partial specialisation",
  15       using ideas taken from "Generative programming" by Krzysztof Czarnecki
  16       & Ulrich Eisenecker.
  17 */
  18
  19 #ifndef BOOST_OB_CALL_TRAITS_HPP
  20 #define BOOST_OB_CALL_TRAITS_HPP
  21
  22 #ifndef BOOST_CONFIG_HPP
  23 #include <boost/config.hpp>
  24 #endif
  25
  26 #ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP
  27 #include <boost/type_traits/arithmetic_traits.hpp>
  28 #endif
  29 #ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP
  30 #include <boost/type_traits/composite_traits.hpp>
  31 #endif
  32
  33 namespace boost{
  34
  35 #ifdef BOOST_MSVC6_MEMBER_TEMPLATES
  36 //
  37 // use member templates to emulate
  38 // partial specialisation:
  39 //
  40 namespace detail{
  41
  42 template <class T>
  43 struct standard_call_traits
  44 {
  45    typedef T value_type;
  46    typedef T& reference;
  47    typedef const T& const_reference;
  48    typedef const T& param_type;
  49 };
  50 template <class T>
  51 struct simple_call_traits
  52 {
  53    typedef T value_type;
  54    typedef T& reference;
  55    typedef const T& const_reference;
  56    typedef const T param_type;
  57 };
  58 template <class T>
  59 struct reference_call_traits
  60 {
  61    typedef T value_type;
  62    typedef T reference;
  63    typedef T const_reference;
  64    typedef T param_type;
  65 };
  66
  67 template <bool pointer, bool arithmetic, bool reference>
  68 struct call_traits_chooser
  69 {
  70    template <class T>
  71    struct rebind
  72    {
  73       typedef standard_call_traits<T> type;
  74    };
  75 };
  76
  77 template <>
  78 struct call_traits_chooser<true, false, false>
  79 {
  80    template <class T>
  81    struct rebind
  82    {
  83       typedef simple_call_traits<T> type;
  84    };
  85 };
  86
  87 template <>
  88 struct call_traits_chooser<false, false, true>
  89 {
  90    template <class T>
  91    struct rebind
  92    {
  93       typedef reference_call_traits<T> type;
  94    };
  95 };
  96
  97 template <bool size_is_small>
  98 struct call_traits_sizeof_chooser2
  99 {
 100    template <class T>
 101    struct small_rebind
 102    {
 103       typedef simple_call_traits<T> small_type;
 104    };
 105 };
 106
 107 template<>
 108 struct call_traits_sizeof_chooser2<false>
 109 {
 110    template <class T>
 111    struct small_rebind
 112    {
 113       typedef standard_call_traits<T> small_type;
 114    };
 115 };
 116
 117 template <>
 118 struct call_traits_chooser<false, true, false>
 119 {
 120    template <class T>
 121    struct rebind
 122    {
 123       enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) };
 124       typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser;
 125       typedef typename chooser::template small_rebind<T> bound_type;
 126       typedef typename bound_type::small_type type;
 127    };
 128 };
 129
 130 } // namespace detail
 131 template <typename T>
 132 struct call_traits
 133 {
 134 private:
 135     typedef detail::call_traits_chooser<
 136          ::boost::is_pointer<T>::value,
 137          ::boost::is_arithmetic<T>::value,
 138          ::boost::is_reference<T>::value
 139       > chooser;
 140    typedef typename chooser::template rebind<T> bound_type;
 141    typedef typename bound_type::type call_traits_type;
 142 public:
 143    typedef typename call_traits_type::value_type       value_type;
 144    typedef typename call_traits_type::reference        reference;
 145    typedef typename call_traits_type::const_reference  const_reference;
 146    typedef typename call_traits_type::param_type       param_type;
 147 };
 148
 149 #else
 150 //
 151 // sorry call_traits is completely non-functional
 152 // blame your broken compiler:
 153 //
 154
 155 template <typename T>
 156 struct call_traits
 157 {
 158    typedef T value_type;
 159    typedef T& reference;
 160    typedef const T& const_reference;
 161    typedef const T& param_type;
 162 };
 163
 164 #endif // member templates
 165
 166 }
 167
 168 #endif // BOOST_OB_CALL_TRAITS_HPP