Ticket #6829: make_shared.hpp

File make_shared.hpp, 31.8 KB (added by ierceg@…, 10 years ago)

Updated smart_ptr\make_shared.hpp file to look more like the original implementation and with sp_enable_shared_from_this calls that were missing in the patch.

Line 
1#ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
2#define BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED
3
4// make_shared.hpp
5//
6// Copyright (c) 2007, 2008 Peter Dimov
7//
8// Distributed under the Boost Software License, Version 1.0.
9// See accompanying file LICENSE_1_0.txt or copy at
10// http://www.boost.org/LICENSE_1_0.txt
11//
12// See http://www.boost.org/libs/smart_ptr/make_shared.html
13// for documentation.
14
15#include <boost/config.hpp>
16#include <boost/smart_ptr/shared_ptr.hpp>
17#include <boost/smart_ptr/detail/sp_counted_impl_ms.hpp>
18#include <boost/throw_exception.hpp>
19#include <boost/noncopyable.hpp>
20#include <boost/config/no_tr1/memory.hpp> // std::auto_ptr
21#include <exception> // std::bad_alloc
22
23#include <new>
24
25namespace boost
26{
27
28namespace detail
29{
30
31#if defined( BOOST_HAS_RVALUE_REFS )
32
33template< class T > T&& sp_forward( T & t )
34{
35 return static_cast< T&& >( t );
36}
37
38#endif
39
40#ifdef BOOST_NO_EXCEPTIONS
41
42template <class T>
43void verify_allocation(T*) {}
44
45#else
46
47template <class T>
48void verify_allocation(T* p)
49{
50 if (!p)
51 {
52 boost::throw_exception(std::bad_alloc());
53 }
54}
55
56#endif // #ifdef BOOST_NO_EXCEPTIONS
57
58// scoped holder of sp counter object allocated with custom allocator
59template <class SpCounter, class Alloc>
60class scoped_sp_counter : private boost::noncopyable
61{
62 typedef typename Alloc::template rebind<SpCounter>::other sp_counter_alloc_t;
63
64public:
65 scoped_sp_counter(const Alloc& a) : a_(a)
66 {
67 p_ = a_.allocate(1, NULL);
68 boost::detail::verify_allocation(p_);
69 new (p_) SpCounter(a); // nothrow if a's copy ctor doesn't throw
70 }
71
72 ~scoped_sp_counter()
73 {
74 if (p_)
75 {
76 p_->~SpCounter();
77 a_.deallocate(p_, 1);
78 }
79 }
80
81 SpCounter* operator->() const { return p_; }
82 SpCounter* release() { SpCounter* released = p_; p_ = NULL; return released; }
83
84private:
85 SpCounter* p_;
86 sp_counter_alloc_t a_;
87};
88
89} // namespace detail
90
91// Zero-argument versions
92//
93// Used even when variadic templates are available because of the new T() vs new T issue
94
95template< class T > boost::shared_ptr< T > make_shared()
96{
97 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
98 boost::detail::verify_allocation( counter.get() );
99
100 void * pv = counter->get_pointer();
101
102 ::new ( pv ) T();
103
104 T * pt2 = static_cast< T* >( pv );
105
106 boost::detail::sp_counted_base_ms<T>* c = counter.release();
107
108 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
109
110 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
111 return pt;
112}
113
114template< class T, class A > boost::shared_ptr< T > allocate_shared( A const & a )
115{
116 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
117
118 void * pv = counter->get_pointer();
119
120 ::new ( pv ) T();
121
122 T * pt2 = static_cast< T* >( pv );
123
124 boost::detail::sp_counted_base_ms<T>* c = counter.release();
125
126 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
127
128 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
129 return pt;
130}
131
132#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
133
134// Variadic templates, rvalue reference
135
136template< class T, class Arg1, class... Args > boost::shared_ptr< T > make_shared( Arg1 && arg1, Args && ... args )
137{
138 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
139 boost::detail::verify_allocation( counter.get() );
140
141 void * pv = counter->get_pointer();
142
143 ::new ( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
144
145 T* pt2 = static_cast< T* >( pv );
146
147 boost::detail::sp_counted_base_ms<T>* c = counter.release();
148
149 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
150
151 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
152 return pt;
153}
154
155template< class T, class A, class Arg1, class... Args > boost::shared_ptr< T > allocate_shared( A const & a, Arg1 && arg1, Args && ... args )
156{
157 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
158
159 void * pv = counter->get_pointer();
160
161 ::new( pv ) T( boost::detail::sp_forward<Arg1>( arg1 ), boost::detail::sp_forward<Args>( args )... );
162
163 T * pt2 = static_cast< T* >( pv );
164
165 boost::detail::sp_counted_base_ms<T>* c = counter.release();
166
167 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
168
169 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
170 return pt;
171}
172
173#elif defined( BOOST_HAS_RVALUE_REFS )
174
175// For example MSVC 10.0
176
177template< class T, class A1 >
178boost::shared_ptr< T > make_shared( A1 && a1 )
179{
180 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
181 boost::detail::verify_allocation( counter.get() );
182
183 void * pv = counter->get_pointer();
184
185 ::new( pv ) T(
186 boost::detail::sp_forward<A1>( a1 )
187 );
188
189 T* pt2 = static_cast< T* >( pv );
190
191 boost::detail::sp_counted_base_ms<T>* c = counter.release();
192
193 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
194
195 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
196 return pt;
197}
198
199template< class T, class A, class A1 >
200boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1 )
201{
202 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
203
204 void * pv = counter->get_pointer();
205
206 ::new ( pv ) T(
207 boost::detail::sp_forward<A1>( a1 )
208 );
209
210 T * pt2 = static_cast< T* >( pv );
211
212 boost::detail::sp_counted_base_ms<T>* c = counter.release();
213
214 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
215
216 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
217 return pt;
218}
219
220template< class T, class A1, class A2 >
221boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2 )
222{
223 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
224 boost::detail::verify_allocation( counter.get() );
225
226 void * pv = counter->get_pointer();
227
228 ::new( pv ) T(
229 boost::detail::sp_forward<A1>( a1 ),
230 boost::detail::sp_forward<A2>( a2 )
231 );
232
233 T* pt2 = static_cast< T* >( pv );
234
235 boost::detail::sp_counted_base_ms<T>* c = counter.release();
236
237 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
238
239 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
240 return pt;
241}
242
243template< class T, class A, class A1, class A2 >
244boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2 )
245{
246 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
247
248 void * pv = counter->get_pointer();
249
250 ::new ( pv ) T(
251 boost::detail::sp_forward<A1>( a1 ),
252 boost::detail::sp_forward<A2>( a2 )
253 );
254
255 T * pt2 = static_cast< T* >( pv );
256
257 boost::detail::sp_counted_base_ms<T>* c = counter.release();
258
259 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
260
261 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
262 return pt;
263}
264
265template< class T, class A1, class A2, class A3 >
266boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3 )
267{
268 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
269 boost::detail::verify_allocation( counter.get() );
270
271 void * pv = counter->get_pointer();
272
273 ::new( pv ) T(
274 boost::detail::sp_forward<A1>( a1 ),
275 boost::detail::sp_forward<A2>( a2 ),
276 boost::detail::sp_forward<A3>( a3 )
277 );
278
279 T* pt2 = static_cast< T* >( pv );
280
281 boost::detail::sp_counted_base_ms<T>* c = counter.release();
282
283 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
284
285 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
286 return pt;
287}
288
289template< class T, class A, class A1, class A2, class A3 >
290boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
291{
292 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
293
294 void * pv = counter->get_pointer();
295
296 ::new ( pv ) T(
297 boost::detail::sp_forward<A1>( a1 ),
298 boost::detail::sp_forward<A2>( a2 ),
299 boost::detail::sp_forward<A3>( a3 )
300 );
301
302 T * pt2 = static_cast< T* >( pv );
303
304 boost::detail::sp_counted_base_ms<T>* c = counter.release();
305
306 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
307
308 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
309 return pt;
310}
311
312template< class T, class A1, class A2, class A3, class A4 >
313boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
314{
315 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
316 boost::detail::verify_allocation( counter.get() );
317
318 void * pv = counter->get_pointer();
319
320 ::new( pv ) T(
321 boost::detail::sp_forward<A1>( a1 ),
322 boost::detail::sp_forward<A2>( a2 ),
323 boost::detail::sp_forward<A3>( a3 ),
324 boost::detail::sp_forward<A4>( a4 )
325 );
326
327 T* pt2 = static_cast< T* >( pv );
328
329 boost::detail::sp_counted_base_ms<T>* c = counter.release();
330
331 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
332
333 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
334 return pt;
335}
336
337template< class T, class A, class A1, class A2, class A3, class A4 >
338boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
339{
340 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
341
342 void * pv = counter->get_pointer();
343
344 ::new ( pv ) T(
345 boost::detail::sp_forward<A1>( a1 ),
346 boost::detail::sp_forward<A2>( a2 ),
347 boost::detail::sp_forward<A3>( a3 ),
348 boost::detail::sp_forward<A4>( a4 )
349 );
350
351 T * pt2 = static_cast< T* >( pv );
352
353 boost::detail::sp_counted_base_ms<T>* c = counter.release();
354
355 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
356
357 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
358 return pt;
359}
360
361template< class T, class A1, class A2, class A3, class A4, class A5 >
362boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
363{
364 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
365 boost::detail::verify_allocation( counter.get() );
366
367 void * pv = counter->get_pointer();
368
369 ::new( pv ) T(
370 boost::detail::sp_forward<A1>( a1 ),
371 boost::detail::sp_forward<A2>( a2 ),
372 boost::detail::sp_forward<A3>( a3 ),
373 boost::detail::sp_forward<A4>( a4 ),
374 boost::detail::sp_forward<A5>( a5 )
375 );
376
377 T* pt2 = static_cast< T* >( pv );
378
379 boost::detail::sp_counted_base_ms<T>* c = counter.release();
380
381 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
382
383 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
384 return pt;
385}
386
387template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
388boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
389{
390 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
391
392 void * pv = counter->get_pointer();
393
394 ::new ( pv ) T(
395 boost::detail::sp_forward<A1>( a1 ),
396 boost::detail::sp_forward<A2>( a2 ),
397 boost::detail::sp_forward<A3>( a3 ),
398 boost::detail::sp_forward<A4>( a4 ),
399 boost::detail::sp_forward<A5>( a5 )
400 );
401
402 T * pt2 = static_cast< T* >( pv );
403
404 boost::detail::sp_counted_base_ms<T>* c = counter.release();
405
406 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
407
408 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
409 return pt;
410}
411
412template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
413boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
414{
415 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
416 boost::detail::verify_allocation( counter.get() );
417
418 void * pv = counter->get_pointer();
419
420 ::new( pv ) T(
421 boost::detail::sp_forward<A1>( a1 ),
422 boost::detail::sp_forward<A2>( a2 ),
423 boost::detail::sp_forward<A3>( a3 ),
424 boost::detail::sp_forward<A4>( a4 ),
425 boost::detail::sp_forward<A5>( a5 ),
426 boost::detail::sp_forward<A6>( a6 )
427 );
428
429 T* pt2 = static_cast< T* >( pv );
430
431 boost::detail::sp_counted_base_ms<T>* c = counter.release();
432
433 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
434
435 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
436 return pt;
437}
438
439template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
440boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
441{
442 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
443
444 void * pv = counter->get_pointer();
445
446 ::new ( pv ) T(
447 boost::detail::sp_forward<A1>( a1 ),
448 boost::detail::sp_forward<A2>( a2 ),
449 boost::detail::sp_forward<A3>( a3 ),
450 boost::detail::sp_forward<A4>( a4 ),
451 boost::detail::sp_forward<A5>( a5 ),
452 boost::detail::sp_forward<A6>( a6 )
453 );
454
455 T * pt2 = static_cast< T* >( pv );
456
457 boost::detail::sp_counted_base_ms<T>* c = counter.release();
458
459 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
460
461 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
462 return pt;
463}
464
465template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
466boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
467{
468 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
469 boost::detail::verify_allocation( counter.get() );
470
471 void * pv = counter->get_pointer();
472
473 ::new( pv ) T(
474 boost::detail::sp_forward<A1>( a1 ),
475 boost::detail::sp_forward<A2>( a2 ),
476 boost::detail::sp_forward<A3>( a3 ),
477 boost::detail::sp_forward<A4>( a4 ),
478 boost::detail::sp_forward<A5>( a5 ),
479 boost::detail::sp_forward<A6>( a6 ),
480 boost::detail::sp_forward<A7>( a7 )
481 );
482
483 T* pt2 = static_cast< T* >( pv );
484
485 boost::detail::sp_counted_base_ms<T>* c = counter.release();
486
487 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
488
489 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
490 return pt;
491}
492
493template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
494boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
495{
496 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
497
498 void * pv = counter->get_pointer();
499
500 ::new ( pv ) T(
501 boost::detail::sp_forward<A1>( a1 ),
502 boost::detail::sp_forward<A2>( a2 ),
503 boost::detail::sp_forward<A3>( a3 ),
504 boost::detail::sp_forward<A4>( a4 ),
505 boost::detail::sp_forward<A5>( a5 ),
506 boost::detail::sp_forward<A6>( a6 ),
507 boost::detail::sp_forward<A7>( a7 )
508 );
509
510 T * pt2 = static_cast< T* >( pv );
511
512 boost::detail::sp_counted_base_ms<T>* c = counter.release();
513
514 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
515
516 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
517 return pt;
518}
519
520template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
521boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
522{
523 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
524 boost::detail::verify_allocation( counter.get() );
525
526 void * pv = counter->get_pointer();
527
528 ::new( pv ) T(
529 boost::detail::sp_forward<A1>( a1 ),
530 boost::detail::sp_forward<A2>( a2 ),
531 boost::detail::sp_forward<A3>( a3 ),
532 boost::detail::sp_forward<A4>( a4 ),
533 boost::detail::sp_forward<A5>( a5 ),
534 boost::detail::sp_forward<A6>( a6 ),
535 boost::detail::sp_forward<A7>( a7 ),
536 boost::detail::sp_forward<A8>( a8 )
537 );
538
539 T* pt2 = static_cast< T* >( pv );
540
541 boost::detail::sp_counted_base_ms<T>* c = counter.release();
542
543 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
544
545 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
546 return pt;
547}
548
549template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
550boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
551{
552 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
553
554 void * pv = counter->get_pointer();
555
556 ::new ( pv ) T(
557 boost::detail::sp_forward<A1>( a1 ),
558 boost::detail::sp_forward<A2>( a2 ),
559 boost::detail::sp_forward<A3>( a3 ),
560 boost::detail::sp_forward<A4>( a4 ),
561 boost::detail::sp_forward<A5>( a5 ),
562 boost::detail::sp_forward<A6>( a6 ),
563 boost::detail::sp_forward<A7>( a7 ),
564 boost::detail::sp_forward<A8>( a8 )
565 );
566
567 T * pt2 = static_cast< T* >( pv );
568
569 boost::detail::sp_counted_base_ms<T>* c = counter.release();
570
571 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
572
573 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
574 return pt;
575}
576
577template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
578boost::shared_ptr< T > make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
579{
580 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
581 boost::detail::verify_allocation( counter.get() );
582
583 void * pv = counter->get_pointer();
584
585 ::new( pv ) T(
586 boost::detail::sp_forward<A1>( a1 ),
587 boost::detail::sp_forward<A2>( a2 ),
588 boost::detail::sp_forward<A3>( a3 ),
589 boost::detail::sp_forward<A4>( a4 ),
590 boost::detail::sp_forward<A5>( a5 ),
591 boost::detail::sp_forward<A6>( a6 ),
592 boost::detail::sp_forward<A7>( a7 ),
593 boost::detail::sp_forward<A8>( a8 ),
594 boost::detail::sp_forward<A9>( a9 )
595 );
596
597 T* pt2 = static_cast< T* >( pv );
598
599 boost::detail::sp_counted_base_ms<T>* c = counter.release();
600
601 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
602
603 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
604 return pt;
605}
606
607template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
608boost::shared_ptr< T > allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
609{
610 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
611
612 void * pv = counter->get_pointer();
613
614 ::new ( pv ) T(
615 boost::detail::sp_forward<A1>( a1 ),
616 boost::detail::sp_forward<A2>( a2 ),
617 boost::detail::sp_forward<A3>( a3 ),
618 boost::detail::sp_forward<A4>( a4 ),
619 boost::detail::sp_forward<A5>( a5 ),
620 boost::detail::sp_forward<A6>( a6 ),
621 boost::detail::sp_forward<A7>( a7 ),
622 boost::detail::sp_forward<A8>( a8 ),
623 boost::detail::sp_forward<A9>( a9 )
624 );
625
626 T * pt2 = static_cast< T* >( pv );
627
628 boost::detail::sp_counted_base_ms<T>* c = counter.release();
629
630 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
631
632 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
633 return pt;
634}
635
636#else
637
638// C++03 version
639
640template< class T, class A1 >
641boost::shared_ptr< T > make_shared( A1 const & a1 )
642{
643 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
644 boost::detail::verify_allocation( counter.get() );
645
646 void * pv = counter->get_pointer();
647
648 ::new( pv ) T( a1 );
649
650 T * pt2 = static_cast< T* >( pv );
651
652 boost::detail::sp_counted_base_ms<T>* c = counter.release();
653
654 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
655
656 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
657 return pt;
658}
659
660template< class T, class A, class A1 >
661boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1 )
662{
663 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
664
665 void * pv = counter->get_pointer();
666
667 ::new( pv ) T( a1 );
668
669 T * pt2 = static_cast< T* >( pv );
670
671 boost::detail::sp_counted_base_ms<T>* c = counter.release();
672
673 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
674
675 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
676 return pt;
677}
678
679template< class T, class A1, class A2 >
680boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2 )
681{
682 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
683 boost::detail::verify_allocation( counter.get() );
684
685 void * pv = counter->get_pointer();
686
687 ::new( pv ) T( a1, a2 );
688
689 T * pt2 = static_cast< T* >( pv );
690
691 boost::detail::sp_counted_base_ms<T>* c = counter.release();
692
693 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
694
695 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
696 return pt;
697}
698
699template< class T, class A, class A1, class A2 >
700boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
701{
702 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
703
704 void * pv = counter->get_pointer();
705
706 ::new( pv ) T( a1, a2 );
707
708 T * pt2 = static_cast< T* >( pv );
709
710 boost::detail::sp_counted_base_ms<T>* c = counter.release();
711
712 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
713
714 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
715 return pt;
716}
717
718template< class T, class A1, class A2, class A3 >
719boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
720{
721 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
722 boost::detail::verify_allocation( counter.get() );
723
724 void * pv = counter->get_pointer();
725
726 ::new( pv ) T( a1, a2, a3 );
727
728 T * pt2 = static_cast< T* >( pv );
729
730 boost::detail::sp_counted_base_ms<T>* c = counter.release();
731
732 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
733
734 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
735 return pt;
736}
737
738template< class T, class A, class A1, class A2, class A3 >
739boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
740{
741 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
742
743 void * pv = counter->get_pointer();
744
745 ::new( pv ) T( a1, a2, a3 );
746
747 T * pt2 = static_cast< T* >( pv );
748
749 boost::detail::sp_counted_base_ms<T>* c = counter.release();
750
751 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
752
753 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
754 return pt;
755}
756
757template< class T, class A1, class A2, class A3, class A4 >
758boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
759{
760 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
761 boost::detail::verify_allocation( counter.get() );
762
763 void * pv = counter->get_pointer();
764
765 ::new( pv ) T( a1, a2, a3, a4 );
766
767 T * pt2 = static_cast< T* >( pv );
768
769 boost::detail::sp_counted_base_ms<T>* c = counter.release();
770
771 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
772
773 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
774 return pt;
775}
776
777template< class T, class A, class A1, class A2, class A3, class A4 >
778boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
779{
780 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
781
782 void * pv = counter->get_pointer();
783
784 ::new( pv ) T( a1, a2, a3, a4 );
785
786 T * pt2 = static_cast< T* >( pv );
787
788 boost::detail::sp_counted_base_ms<T>* c = counter.release();
789
790 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
791
792 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
793 return pt;
794}
795
796template< class T, class A1, class A2, class A3, class A4, class A5 >
797boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
798{
799 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
800 boost::detail::verify_allocation( counter.get() );
801
802 void * pv = counter->get_pointer();
803
804 ::new( pv ) T( a1, a2, a3, a4, a5 );
805
806 T * pt2 = static_cast< T* >( pv );
807
808 boost::detail::sp_counted_base_ms<T>* c = counter.release();
809
810 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
811
812 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
813 return pt;
814}
815
816template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
817boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
818{
819 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
820
821 void * pv = counter->get_pointer();
822
823 ::new( pv ) T( a1, a2, a3, a4, a5 );
824
825 T * pt2 = static_cast< T* >( pv );
826
827 boost::detail::sp_counted_base_ms<T>* c = counter.release();
828
829 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
830
831 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
832 return pt;
833}
834
835template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
836boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
837{
838 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
839 boost::detail::verify_allocation( counter.get() );
840
841 void * pv = counter->get_pointer();
842
843 ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
844
845 T * pt2 = static_cast< T* >( pv );
846
847 boost::detail::sp_counted_base_ms<T>* c = counter.release();
848
849 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
850
851 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
852 return pt;
853}
854
855template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
856boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
857{
858 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
859
860 void * pv = counter->get_pointer();
861
862 ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
863
864 T * pt2 = static_cast< T* >( pv );
865
866 boost::detail::sp_counted_base_ms<T>* c = counter.release();
867
868 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
869
870 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
871 return pt;
872}
873
874template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
875boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
876{
877 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
878 boost::detail::verify_allocation( counter.get() );
879
880 void * pv = counter->get_pointer();
881
882 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
883
884 T * pt2 = static_cast< T* >( pv );
885
886 boost::detail::sp_counted_base_ms<T>* c = counter.release();
887
888 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
889
890 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
891 return pt;
892}
893
894template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
895boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
896{
897 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
898
899 void * pv = counter->get_pointer();
900
901 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
902
903 T * pt2 = static_cast< T* >( pv );
904
905 boost::detail::sp_counted_base_ms<T>* c = counter.release();
906
907 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
908
909 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
910 return pt;
911}
912
913template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
914boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
915{
916 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
917 boost::detail::verify_allocation( counter.get() );
918
919 void * pv = counter->get_pointer();
920
921 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
922
923 T * pt2 = static_cast< T* >( pv );
924
925 boost::detail::sp_counted_base_ms<T>* c = counter.release();
926
927 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
928
929 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
930 return pt;
931}
932
933template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
934boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
935{
936 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
937
938 void * pv = counter->get_pointer();
939
940 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
941
942 T * pt2 = static_cast< T* >( pv );
943
944 boost::detail::sp_counted_base_ms<T>* c = counter.release();
945
946 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
947
948 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
949 return pt;
950}
951
952template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
953boost::shared_ptr< T > make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
954{
955 std::auto_ptr< boost::detail::sp_counted_impl_ms<T> > counter( new boost::detail::sp_counted_impl_ms<T>() );
956 boost::detail::verify_allocation( counter.get() );
957
958 void * pv = counter->get_pointer();
959
960 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
961
962 T * pt2 = static_cast< T* >( pv );
963
964 boost::detail::sp_counted_base_ms<T>* c = counter.release();
965
966 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
967
968 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
969 return pt;
970}
971
972template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
973boost::shared_ptr< T > allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
974{
975 boost::detail::scoped_sp_counter< boost::detail::sp_counted_impl_ms_a<T, A>, A > counter( a );
976
977 void * pv = counter->get_pointer();
978
979 ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
980
981 T * pt2 = static_cast< T* >( pv );
982
983 boost::detail::sp_counted_base_ms<T>* c = counter.release();
984
985 boost::shared_ptr<T> pt( c->get_pointer(), static_cast< boost::detail::sp_counted_base* >( c ) );
986
987 boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
988 return pt;
989}
990
991#endif
992
993} // namespace boost
994
995#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED