← Back to branch summary

~ubuntu-branches/ubuntu/saucy/merkaartor/saucy

« back to all changes in this revision

Viewing changes to include/builtin-boost/boost/detail/ob_call_traits.hpp

Tags: upstream-0.15.3+svn20934
Import upstream version 0.15.3+svn20934

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/builtin-boost/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