1// - construct.hpp -- Lambda Library -------------
2//
3// Copyright (C) 2000 Gary Powell (powellg@amazon.com)
4// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
5//
6// Distributed under the Boost Software License, Version 1.0. (See
7// accompanying file LICENSE_1_0.txt or copy at
8// http://www.boost.org/LICENSE_1_0.txt)
9//
10// For more information, see http://www.boost.org
11//
12// -----------------------------------------------
13
14#if !defined(BOOST_LAMBDA_CONSTRUCT_HPP)
15#define BOOST_LAMBDA_CONSTRUCT_HPP
16
17#include "boost/type_traits/remove_cv.hpp"
18#include "boost/type_traits/is_pointer.hpp"
19#include "boost/config.hpp"
20
21#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
22#include <utility>
23#endif
24
25namespace boost {
26namespace lambda {
27
28 // constructor is used together with bind. constructor<A> creates a bindable
29 // function object that passes its arguments forward to a constructor call
30 // of type A
31
32template<class T> struct constructor {
33
34 template <class U> struct sig { typedef T type; };
35
36#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
37 template <class... Args>
38 T operator()(Args&&... args) const {
39 return T(std::forward<Args>(args)...);
40 }
41#else
42 T operator()() const {
43 return T();
44 }
45
46 template<class A1>
47 T operator()(A1& a1) const {
48 return T(a1);
49 }
50
51 template<class A1, class A2>
52 T operator()(A1& a1, A2& a2) const {
53 return T(a1, a2);
54 }
55
56 template<class A1, class A2, class A3>
57 T operator()(A1& a1, A2& a2, A3& a3) const {
58 return T(a1, a2, a3);
59 }
60
61 template<class A1, class A2, class A3, class A4>
62 T operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
63 return T(a1, a2, a3, a4);
64 }
65
66 template<class A1, class A2, class A3, class A4, class A5>
67 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
68 return T(a1, a2, a3, a4, a5);
69 }
70
71 template<class A1, class A2, class A3, class A4, class A5, class A6>
72 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
73 return T(a1, a2, a3, a4, a5, a6);
74 }
75
76 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
77 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
78 return T(a1, a2, a3, a4, a5, a6, a7);
79 }
80
81 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
82 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
83 return T(a1, a2, a3, a4, a5, a6, a7, a8);
84 }
85
86 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
87 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
88 return T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
89 }
90
91 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
92 T operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
93 return T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
94 }
95#endif
96
97};
98
99
100namespace detail {
101
102// A standard conforming compiler could disambiguate between
103// A1* and A1&, but not all compilers do that, so we need the
104// helpers
105
106
107template <bool IsPointer>
108struct destructor_helper {
109
110 template<class A1>
111 static void exec(A1& a1) {
112 // remove all the qualifiers, not sure whether it is necessary
113 typedef typename boost::remove_cv<A1>::type plainA1;
114 a1.~plainA1();
115 }
116};
117
118template <>
119struct destructor_helper<true> {
120
121 template<class A1>
122 static void exec(A1* a1) {
123 typedef typename boost::remove_cv<A1>::type plainA1;
124 (*a1).~plainA1();
125 }
126};
127
128}
129
130// destructor funtion object
131struct destructor {
132
133 template <class T> struct sig { typedef void type; };
134
135 template<class A1>
136 void operator()(A1& a1) const {
137 typedef typename boost::remove_cv<A1>::type plainA1;
138 detail::destructor_helper<boost::is_pointer<plainA1>::value>::exec(a1);
139 }
140};
141
142
143
144// new_ptr is used together with bind.
145
146 // note: placement new is not supported
147
148template<class T> struct new_ptr {
149
150 template <class U> struct sig { typedef T* type; };
151
152#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
153 template <class... Args>
154 T* operator()(Args&&... args) const {
155 return new T(std::forward<Args>(args)...);
156 }
157#else
158 T* operator()() const {
159 return new T();
160 }
161
162 template<class A1>
163 T* operator()(A1& a1) const {
164 return new T(a1);
165 }
166
167 template<class A1, class A2>
168 T* operator()(A1& a1, A2& a2) const {
169 return new T(a1, a2);
170 }
171
172 template<class A1, class A2, class A3>
173 T* operator()(A1& a1, A2& a2, A3& a3) const {
174 return new T(a1, a2, a3);
175 }
176
177 template<class A1, class A2, class A3, class A4>
178 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4) const {
179 return new T(a1, a2, a3, a4);
180 }
181
182 template<class A1, class A2, class A3, class A4, class A5>
183 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5) const {
184 return new T(a1, a2, a3, a4, a5);
185 }
186
187 template<class A1, class A2, class A3, class A4, class A5, class A6>
188 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6) const {
189 return new T(a1, a2, a3, a4, a5, a6);
190 }
191
192 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
193 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7) const {
194 return new T(a1, a2, a3, a4, a5, a6, a7);
195 }
196
197 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
198 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8) const {
199 return new T(a1, a2, a3, a4, a5, a6, a7, a8);
200 }
201
202 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
203 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9) const {
204 return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9);
205 }
206
207 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
208 T* operator()(A1& a1, A2& a2, A3& a3, A4& a4, A5& a5, A6& a6, A7& a7, A8& a8, A9& a9, A10& a10) const {
209 return new T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
210 }
211#endif
212
213};
214
215// delete_ptr return void
216
217struct delete_ptr {
218
219 template <class U> struct sig { typedef void type; };
220
221 template <class A1>
222 void operator()(A1& a1) const {
223 delete a1;
224 }
225
226};
227
228
229// new_array is used together with bind.
230
231template<class T> struct new_array {
232
233 template <class U> struct sig { typedef T* type; };
234
235 T* operator()(int size) const {
236 return new T[size];
237 }
238};
239
240
241// delete_ptr return void
242
243struct delete_array {
244
245 template <class U> struct sig { typedef void type; };
246
247 template <class A1>
248 void operator()(A1& a1) const {
249 delete[] a1;
250 }
251
252};
253
254
255
256} // namespace lambda
257} // namespace boost
258
259#endif
260

source code of boost/libs/lambda/include/boost/lambda/construct.hpp