boost/detail/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 // call_traits: defines typedefs for function usage
   9 // (see libs/utility/call_traits.htm)
  10
  11 /* Release notes:
  12    23rd July 2000:
  13       Fixed array specialization. (JM)
  14       Added Borland specific fixes for reference types
  15       (issue raised by Steve Cleary).
  16 */
  17
  18 #ifndef BOOST_DETAIL_CALL_TRAITS_HPP
  19 #define BOOST_DETAIL_CALL_TRAITS_HPP
  20
  21 #ifndef BOOST_CONFIG_HPP
  22 #include <boost/config.hpp>
  23 #endif
  24 #include <cstddef>
  25
  26 #include <boost/type_traits/is_arithmetic.hpp>
  27 #include <boost/type_traits/is_pointer.hpp>
  28 #include <boost/detail/workaround.hpp>
  29
  30 namespace boost{
  31
  32 namespace detail{
  33
  34 template <typename T, bool small_>
  35 struct ct_imp2
  36 {
  37    typedef const T& param_type;
  38 };
  39
  40 template <typename T>
  41 struct ct_imp2<T, true>
  42 {
  43    typedef const T param_type;
  44 };
  45
  46 template <typename T, bool isp, bool b1>
  47 struct ct_imp
  48 {
  49    typedef const T& param_type;
  50 };
  51
  52 template <typename T, bool isp>
  53 struct ct_imp<T, isp, true>
  54 {
  55    typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
  56 };
  57
  58 template <typename T, bool b1>
  59 struct ct_imp<T, true, b1>
  60 {
  61    typedef const T param_type;
  62 };
  63
  64 }
  65
  66 template <typename T>
  67 struct call_traits
  68 {
  69 public:
  70    typedef T value_type;
  71    typedef T& reference;
  72    typedef const T& const_reference;
  73    //
  74    // C++ Builder workaround: we should be able to define a compile time
  75    // constant and pass that as a single template parameter to ct_imp<T,bool>,
  76    // however compiler bugs prevent this - instead pass three bool's to
  77    // ct_imp<T,bool,bool,bool> and add an extra partial specialisation
  78    // of ct_imp to handle the logic. (JM)
  79    typedef typename boost::detail::ct_imp<
  80       T,
  81       ::boost::is_pointer<T>::value,
  82       ::boost::is_arithmetic<T>::value
  83    >::param_type param_type;
  84 };
  85
  86 template <typename T>
  87 struct call_traits<T&>
  88 {
  89    typedef T& value_type;
  90    typedef T& reference;
  91    typedef const T& const_reference;
  92    typedef T& param_type;  // hh removed const
  93 };
  94
  95 #if BOOST_WORKAROUND( __BORLANDC__,  < 0x5A0 )
  96 // these are illegal specialisations; cv-qualifies applied to
  97 // references have no effect according to [8.3.2p1],
  98 // C++ Builder requires them though as it treats cv-qualified
  99 // references as distinct types...
 100 template <typename T>
 101 struct call_traits<T&const>
 102 {
 103    typedef T& value_type;
 104    typedef T& reference;
 105    typedef const T& const_reference;
 106    typedef T& param_type;  // hh removed const
 107 };
 108 template <typename T>
 109 struct call_traits<T&volatile>
 110 {
 111    typedef T& value_type;
 112    typedef T& reference;
 113    typedef const T& const_reference;
 114    typedef T& param_type;  // hh removed const
 115 };
 116 template <typename T>
 117 struct call_traits<T&const volatile>
 118 {
 119    typedef T& value_type;
 120    typedef T& reference;
 121    typedef const T& const_reference;
 122    typedef T& param_type;  // hh removed const
 123 };
 124
 125 template <typename T>
 126 struct call_traits< T * >
 127 {
 128    typedef T * value_type;
 129    typedef T * & reference;
 130    typedef T * const & const_reference;
 131    typedef T * const param_type;  // hh removed const
 132 };
 133 #endif
 134 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 135 template <typename T, std::size_t N>
 136 struct call_traits<T [N]>
 137 {
 138 private:
 139    typedef T array_type[N];
 140 public:
 141    // degrades array to pointer:
 142    typedef const T* value_type;
 143    typedef array_type& reference;
 144    typedef const array_type& const_reference;
 145    typedef const T* const param_type;
 146 };
 147
 148 template <typename T, std::size_t N>
 149 struct call_traits<const T [N]>
 150 {
 151 private:
 152    typedef const T array_type[N];
 153 public:
 154    // degrades array to pointer:
 155    typedef const T* value_type;
 156    typedef array_type& reference;
 157    typedef const array_type& const_reference;
 158    typedef const T* const param_type;
 159 };
 160 #endif
 161
 162 }
 163
 164 #endif // BOOST_DETAIL_CALL_TRAITS_HPP