1 // Distributed under the Boost Software License, Version 1.0. (See
2 // accompanying file LICENSE_1_0.txt or copy at
3 // http://www.boost.org/LICENSE_1_0.txt)
4 // (C) Copyright 2008 Anthony Williams
5 #ifndef THREAD_HEAP_ALLOC_PTHREAD_HPP
6 #define THREAD_HEAP_ALLOC_PTHREAD_HPP
7 
8 #include <boost/config/abi_prefix.hpp>
9 
10 namespace boost
11 {
12     namespace detail
13     {
14         template<typename T>
heap_new()15         inline T* heap_new()
16         {
17             return new T();
18         }
19 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
20         template<typename T,typename... Args>
heap_new(Args &&...args)21         inline T* heap_new(Args&&... args)
22         {
23             return new T(static_cast<Args&&>(args)...);
24         }
25 #elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
26         template<typename T,typename A1>
heap_new(A1 && a1)27         inline T* heap_new(A1&& a1)
28         {
29             return new T(static_cast<A1&&>(a1));
30         }
31         template<typename T,typename A1,typename A2>
heap_new(A1 && a1,A2 && a2)32         inline T* heap_new(A1&& a1,A2&& a2)
33         {
34             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
35         }
36         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 && a1,A2 && a2,A3 && a3)37         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
38         {
39             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
40                          static_cast<A3&&>(a3));
41         }
42         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 && a1,A2 && a2,A3 && a3,A4 && a4)43         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
44         {
45             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
46                          static_cast<A3&&>(a3),static_cast<A4&&>(a4));
47         }
48 #else
49         template<typename T,typename A1>
heap_new_impl(A1 a1)50         inline T* heap_new_impl(A1 a1)
51         {
52             return new T(a1);
53         }
54         template<typename T,typename A1,typename A2>
heap_new_impl(A1 a1,A2 a2)55         inline T* heap_new_impl(A1 a1,A2 a2)
56         {
57             return new T(a1,a2);
58         }
59         template<typename T,typename A1,typename A2,typename A3>
heap_new_impl(A1 a1,A2 a2,A3 a3)60         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
61         {
62             return new T(a1,a2,a3);
63         }
64         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)65         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
66         {
67             return new T(a1,a2,a3,a4);
68         }
69         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)70         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
71         {
72             return new T(a1,a2,a3,a4,a5);
73         }
74         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)75         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
76         {
77             return new T(a1,a2,a3,a4,a5,a6);
78         }
79         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)80         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
81         {
82             return new T(a1,a2,a3,a4,a5,a6,a7);
83         }
84         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)85         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
86         {
87             return new T(a1,a2,a3,a4,a5,a6,a7,a8);
88         }
89         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)90         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
91         {
92             return new T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
93         }
94 
95         template<typename T,typename A1>
heap_new(A1 const & a1)96         inline T* heap_new(A1 const& a1)
97         {
98             return heap_new_impl<T,A1 const&>(a1);
99         }
100         template<typename T,typename A1>
heap_new(A1 & a1)101         inline T* heap_new(A1& a1)
102         {
103             return heap_new_impl<T,A1&>(a1);
104         }
105 
106         template<typename T,typename A1,typename A2>
heap_new(A1 const & a1,A2 const & a2)107         inline T* heap_new(A1 const& a1,A2 const& a2)
108         {
109             return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
110         }
111         template<typename T,typename A1,typename A2>
heap_new(A1 & a1,A2 const & a2)112         inline T* heap_new(A1& a1,A2 const& a2)
113         {
114             return heap_new_impl<T,A1&,A2 const&>(a1,a2);
115         }
116         template<typename T,typename A1,typename A2>
heap_new(A1 const & a1,A2 & a2)117         inline T* heap_new(A1 const& a1,A2& a2)
118         {
119             return heap_new_impl<T,A1 const&,A2&>(a1,a2);
120         }
121         template<typename T,typename A1,typename A2>
heap_new(A1 & a1,A2 & a2)122         inline T* heap_new(A1& a1,A2& a2)
123         {
124             return heap_new_impl<T,A1&,A2&>(a1,a2);
125         }
126 
127         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 const & a1,A2 const & a2,A3 const & a3)128         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
129         {
130             return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
131         }
132         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 & a1,A2 const & a2,A3 const & a3)133         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
134         {
135             return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
136         }
137         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 const & a1,A2 & a2,A3 const & a3)138         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
139         {
140             return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
141         }
142         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 & a1,A2 & a2,A3 const & a3)143         inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
144         {
145             return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
146         }
147 
148         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 const & a1,A2 const & a2,A3 & a3)149         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
150         {
151             return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
152         }
153         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 & a1,A2 const & a2,A3 & a3)154         inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
155         {
156             return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
157         }
158         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 const & a1,A2 & a2,A3 & a3)159         inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
160         {
161             return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
162         }
163         template<typename T,typename A1,typename A2,typename A3>
heap_new(A1 & a1,A2 & a2,A3 & a3)164         inline T* heap_new(A1& a1,A2& a2,A3& a3)
165         {
166             return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
167         }
168 
169         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 const & a2,A3 const & a3,A4 const & a4)170         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
171         {
172             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
173         }
174         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 const & a2,A3 const & a3,A4 const & a4)175         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
176         {
177             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
178         }
179         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 & a2,A3 const & a3,A4 const & a4)180         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
181         {
182             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
183         }
184         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 & a2,A3 const & a3,A4 const & a4)185         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
186         {
187             return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
188         }
189 
190         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 const & a2,A3 & a3,A4 const & a4)191         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
192         {
193             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
194         }
195         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 const & a2,A3 & a3,A4 const & a4)196         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
197         {
198             return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
199         }
200         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 & a2,A3 & a3,A4 const & a4)201         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
202         {
203             return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
204         }
205         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 & a2,A3 & a3,A4 const & a4)206         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
207         {
208             return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
209         }
210         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 const & a2,A3 const & a3,A4 & a4)211         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
212         {
213             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
214         }
215         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 const & a2,A3 const & a3,A4 & a4)216         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
217         {
218             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
219         }
220         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 & a2,A3 const & a3,A4 & a4)221         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
222         {
223             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
224         }
225         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 & a2,A3 const & a3,A4 & a4)226         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
227         {
228             return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
229         }
230 
231         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 const & a2,A3 & a3,A4 & a4)232         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
233         {
234             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
235         }
236         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 const & a2,A3 & a3,A4 & a4)237         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
238         {
239             return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
240         }
241         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 const & a1,A2 & a2,A3 & a3,A4 & a4)242         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
243         {
244             return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
245         }
246         template<typename T,typename A1,typename A2,typename A3,typename A4>
heap_new(A1 & a1,A2 & a2,A3 & a3,A4 & a4)247         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
248         {
249             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
250         }
251 
252 #endif
253         template<typename T>
heap_delete(T * data)254         inline void heap_delete(T* data)
255         {
256             delete data;
257         }
258 
259         template<typename T>
260         struct do_heap_delete
261         {
operator ()boost::detail::do_heap_delete262             void operator()(T* data) const
263             {
264                 detail::heap_delete(data);
265             }
266         };
267     }
268 }
269 
270 #include <boost/config/abi_suffix.hpp>
271 
272 #endif
273