Ugly, not-to-be-pushed sucking in of all of Boost to get windows to work.
[dyninst.git] / external / boost / detail / allocator_utilities.hpp
1 /* Copyright 2003-2005 Joaquín M López Muñoz.
2  * Distributed under the Boost Software License, Version 1.0.
3  * (See accompanying file LICENSE_1_0.txt or copy at
4  * http://www.boost.org/LICENSE_1_0.txt)
5  *
6  * See Boost website at http://www.boost.org/
7  */
8
9 #ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP
10 #define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP
11
12 #include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */
13 #include <boost/detail/workaround.hpp>
14 #include <boost/mpl/aux_/msvc_never_true.hpp>
15 #include <boost/mpl/eval_if.hpp>
16 #include <boost/type_traits/is_same.hpp>
17 #include <cstddef>
18 #include <memory>
19 #include <new>
20
21 namespace boost{
22
23 namespace detail{
24
25 /* Allocator adaption layer. Some stdlibs provide allocators without rebind
26  * and template ctors. These facilities are simulated with the external
27  * template class rebind_to and the aid of partial_std_allocator_wrapper.
28  */
29
30 namespace allocator{
31
32 /* partial_std_allocator_wrapper inherits the functionality of a std
33  * allocator while providing a templatized ctor.
34  */
35
36 template<typename Type>
37 class partial_std_allocator_wrapper:public std::allocator<Type>
38 {
39 public:
40   partial_std_allocator_wrapper(){};
41
42   template<typename Other>
43   partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}
44
45   partial_std_allocator_wrapper(const std::allocator<Type>& x):
46     std::allocator<Type>(x)
47   {
48   };
49
50 #if defined(BOOST_DINKUMWARE_STDLIB)
51   /* Dinkumware guys didn't provide a means to call allocate() without
52    * supplying a hint, in disagreement with the standard.
53    */
54
55   Type* allocate(std::size_t n,const void* hint=0)
56   {
57     std::allocator<Type>& a=*this;
58     return a.allocate(n,hint);
59   }
60 #endif
61
62 };
63
64 /* Detects whether a given allocator belongs to a defective stdlib not
65  * having the required member templates.
66  * Note that it does not suffice to check the Boost.Config stdlib
67  * macros, as the user might have passed a custom, compliant allocator.
68  * The checks also considers partial_std_allocator_wrapper to be
69  * a standard defective allocator.
70  */
71
72 #if defined(BOOST_NO_STD_ALLOCATOR)&&\
73   (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)||defined(BOOST_DINKUMWARE_STDLIB))
74
75 template<typename Allocator>
76 struct is_partial_std_allocator
77 {
78   BOOST_STATIC_CONSTANT(bool,
79     value=
80       (is_same<
81         std::allocator<BOOST_DEDUCED_TYPENAME Allocator::value_type>,
82         Allocator
83       >::value)||
84       (is_same<
85         partial_std_allocator_wrapper<
86           BOOST_DEDUCED_TYPENAME Allocator::value_type>,
87         Allocator
88       >::value));
89 };
90
91 #else
92
93 template<typename Allocator>
94 struct is_partial_std_allocator
95 {
96   BOOST_STATIC_CONSTANT(bool,value=false);
97 };
98
99 #endif
100
101 /* rebind operations for defective std allocators */
102
103 template<typename Allocator,typename Type>
104 struct partial_std_allocator_rebind_to
105 {
106   typedef partial_std_allocator_wrapper<Type> type;
107 };
108
109 /* rebind operation in all other cases */
110
111 #if BOOST_WORKAROUND(BOOST_MSVC,<1300)
112 /* Workaround for a problem in MSVC with dependent template typedefs
113  * when doing rebinding of allocators.
114  * Modeled after <boost/mpl/aux_/msvc_dtw.hpp> (thanks, Aleksey!)
115  */
116
117 template<typename Allocator>
118 struct rebinder
119 {
120   template<bool> struct fake_allocator:Allocator{};
121   template<> struct fake_allocator<true>
122   {
123     template<typename Type> struct rebind{};
124   };
125
126   template<typename Type>
127   struct result:
128     fake_allocator<mpl::aux::msvc_never_true<Allocator>::value>::
129       template rebind<Type>
130   {
131   };
132 };
133 #else
134 template<typename Allocator>
135 struct rebinder
136 {
137   template<typename Type>
138   struct result
139   {
140       typedef typename Allocator::BOOST_NESTED_TEMPLATE 
141           rebind<Type>::other other;
142   };
143 };
144 #endif
145
146 template<typename Allocator,typename Type>
147 struct compliant_allocator_rebind_to
148 {
149   typedef typename rebinder<Allocator>::
150       BOOST_NESTED_TEMPLATE result<Type>::other type;
151 };
152
153 /* rebind front-end */
154
155 template<typename Allocator,typename Type>
156 struct rebind_to:
157   mpl::eval_if_c<
158     is_partial_std_allocator<Allocator>::value,
159     partial_std_allocator_rebind_to<Allocator,Type>,
160     compliant_allocator_rebind_to<Allocator,Type>
161   >
162 {
163 };
164
165 /* allocator-independent versions of construct and destroy */
166
167 template<typename Type>
168 void construct(void* p,const Type& t)
169 {
170   new (p) Type(t);
171 }
172
173 template<typename Type>
174 void destroy(const Type* p)
175 {
176   p->~Type();
177 }
178
179 } /* namespace boost::detail::allocator */
180
181 } /* namespace boost::detail */
182
183 } /* namespace boost */
184
185 #endif