3rdparty/boost/boost/smart_ptr/make_shared_object.hpp

   1 #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
   2 #define BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
   3
   4 //  make_shared_object.hpp
   5 //
   6 //  Copyright (c) 2007, 2008, 2012 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_forward.hpp>
  18 #include <boost/type_traits/type_with_alignment.hpp>
  19 #include <boost/type_traits/alignment_of.hpp>
  20 #include <cstddef>
  21 #include <new>
  22
  23 namespace boost
  24 {
  25
  26 namespace detail
  27 {
  28
  29 template< std::size_t N, std::size_t A > struct sp_aligned_storage
  30 {
  31     union type
  32     {
  33         char data_[ N ];
  34         typename boost::type_with_alignment< A >::type align_;
  35     };
  36 };
  37
  38 template< class T > class sp_ms_deleter
  39 {
  40 private:
  41
  42     typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
  43
  44     bool initialized_;
  45     storage_type storage_;
  46
  47 private:
  48
  49     void destroy()
  50     {
  51         if( initialized_ )
  52         {
  53 #if defined( __GNUC__ )
  54
  55             // fixes incorrect aliasing warning
  56             T * p = reinterpret_cast< T* >( storage_.data_ );
  57             p->~T();
  58
  59 #else
  60
  61             reinterpret_cast< T* >( storage_.data_ )->~T();
  62
  63 #endif
  64
  65             initialized_ = false;
  66         }
  67     }
  68
  69 public:
  70
  71     sp_ms_deleter() BOOST_NOEXCEPT : initialized_( false )
  72     {
  73     }
  74
  75     template<class A> explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false )
  76     {
  77     }
  78
  79     // optimization: do not copy storage_
  80     sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
  81     {
  82     }
  83
  84     ~sp_ms_deleter()
  85     {
  86         destroy();
  87     }
  88
  89     void operator()( T * )
  90     {
  91         destroy();
  92     }
  93
  94     static void operator_fn( T* ) // operator() can't be static
  95     {
  96     }
  97
  98     void * address() BOOST_NOEXCEPT
  99     {
 100         return storage_.data_;
 101     }
 102
 103     void set_initialized() BOOST_NOEXCEPT
 104     {
 105         initialized_ = true;
 106     }
 107 };
 108
 109 template< class T, class A > class sp_as_deleter
 110 {
 111 private:
 112
 113     typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
 114
 115     storage_type storage_;
 116     A a_;
 117     bool initialized_;
 118
 119 private:
 120
 121     void destroy()
 122     {
 123         if( initialized_ )
 124         {
 125             T * p = reinterpret_cast< T* >( storage_.data_ );
 126
 127 #if !defined( BOOST_NO_CXX11_ALLOCATOR )
 128
 129             std::allocator_traits<A>::destroy( a_, p );
 130
 131 #else
 132
 133             p->~T();
 134
 135 #endif
 136
 137             initialized_ = false;
 138         }
 139     }
 140
 141 public:
 142
 143     sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false )
 144     {
 145     }
 146
 147     // optimization: do not copy storage_
 148     sp_as_deleter( sp_as_deleter const & r ) BOOST_NOEXCEPT : a_( r.a_), initialized_( false )
 149     {
 150     }
 151
 152     ~sp_as_deleter()
 153     {
 154         destroy();
 155     }
 156
 157     void operator()( T * )
 158     {
 159         destroy();
 160     }
 161
 162     static void operator_fn( T* ) // operator() can't be static
 163     {
 164     }
 165
 166     void * address() BOOST_NOEXCEPT
 167     {
 168         return storage_.data_;
 169     }
 170
 171     void set_initialized() BOOST_NOEXCEPT
 172     {
 173         initialized_ = true;
 174     }
 175 };
 176
 177 template< class T > struct sp_if_not_array
 178 {
 179     typedef boost::shared_ptr< T > type;
 180 };
 181
 182 #if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 183
 184 template< class T > struct sp_if_not_array< T[] >
 185 {
 186 };
 187
 188 #if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
 189
 190 template< class T, std::size_t N > struct sp_if_not_array< T[N] >
 191 {
 192 };
 193
 194 #endif
 195
 196 #endif
 197
 198 } // namespace detail
 199
 200 #if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
 201 # define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
 202 #else
 203 # define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
 204 #endif
 205
 206 // _noinit versions
 207
 208 template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
 209 {
 210     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 211
 212     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 213
 214     void * pv = pd->address();
 215
 216     ::new( pv ) T;
 217     pd->set_initialized();
 218
 219     T * pt2 = static_cast< T* >( pv );
 220
 221     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 222     return boost::shared_ptr< T >( pt, pt2 );
 223 }
 224
 225 template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
 226 {
 227     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 228
 229     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 230
 231     void * pv = pd->address();
 232
 233     ::new( pv ) T;
 234     pd->set_initialized();
 235
 236     T * pt2 = static_cast< T* >( pv );
 237
 238     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 239     return boost::shared_ptr< T >( pt, pt2 );
 240 }
 241
 242 #if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 243
 244 // Variadic templates, rvalue reference
 245
 246 template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
 247 {
 248     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 249
 250     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 251
 252     void * pv = pd->address();
 253
 254     ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
 255     pd->set_initialized();
 256
 257     T * pt2 = static_cast< T* >( pv );
 258
 259     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 260     return boost::shared_ptr< T >( pt, pt2 );
 261 }
 262
 263 template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
 264 {
 265 #if !defined( BOOST_NO_CXX11_ALLOCATOR )
 266
 267     typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
 268     A2 a2( a );
 269
 270     typedef boost::detail::sp_as_deleter< T, A2 > D;
 271
 272     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
 273
 274 #else
 275
 276     typedef boost::detail::sp_ms_deleter< T > D;
 277
 278     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
 279
 280 #endif
 281
 282     D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
 283     void * pv = pd->address();
 284
 285 #if !defined( BOOST_NO_CXX11_ALLOCATOR )
 286
 287     std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
 288
 289 #else
 290
 291     ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
 292
 293 #endif
 294
 295     pd->set_initialized();
 296
 297     T * pt2 = static_cast< T* >( pv );
 298
 299     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 300     return boost::shared_ptr< T >( pt, pt2 );
 301 }
 302
 303 #else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 304
 305 // Common zero-argument versions
 306
 307 template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
 308 {
 309     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 310
 311     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 312
 313     void * pv = pd->address();
 314
 315     ::new( pv ) T();
 316     pd->set_initialized();
 317
 318     T * pt2 = static_cast< T* >( pv );
 319
 320     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 321     return boost::shared_ptr< T >( pt, pt2 );
 322 }
 323
 324 template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
 325 {
 326     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 327
 328     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 329
 330     void * pv = pd->address();
 331
 332     ::new( pv ) T();
 333     pd->set_initialized();
 334
 335     T * pt2 = static_cast< T* >( pv );
 336
 337     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 338     return boost::shared_ptr< T >( pt, pt2 );
 339 }
 340
 341 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 342
 343 // For example MSVC 10.0
 344
 345 template< class T, class A1 >
 346 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1 )
 347 {
 348     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 349
 350     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 351
 352     void * pv = pd->address();
 353
 354     ::new( pv ) T(
 355         boost::detail::sp_forward<A1>( a1 )
 356         );
 357
 358     pd->set_initialized();
 359
 360     T * pt2 = static_cast< T* >( pv );
 361
 362     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 363     return boost::shared_ptr< T >( pt, pt2 );
 364 }
 365
 366 template< class T, class A, class A1 >
 367 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1 )
 368 {
 369     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 370
 371     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 372
 373     void * pv = pd->address();
 374
 375     ::new( pv ) T(
 376         boost::detail::sp_forward<A1>( a1 )
 377         );
 378
 379     pd->set_initialized();
 380
 381     T * pt2 = static_cast< T* >( pv );
 382
 383     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 384     return boost::shared_ptr< T >( pt, pt2 );
 385 }
 386
 387 template< class T, class A1, class A2 >
 388 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2 )
 389 {
 390     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 391
 392     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 393
 394     void * pv = pd->address();
 395
 396     ::new( pv ) T(
 397         boost::detail::sp_forward<A1>( a1 ),
 398         boost::detail::sp_forward<A2>( a2 )
 399         );
 400
 401     pd->set_initialized();
 402
 403     T * pt2 = static_cast< T* >( pv );
 404
 405     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 406     return boost::shared_ptr< T >( pt, pt2 );
 407 }
 408
 409 template< class T, class A, class A1, class A2 >
 410 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2 )
 411 {
 412     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 413
 414     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 415
 416     void * pv = pd->address();
 417
 418     ::new( pv ) T(
 419         boost::detail::sp_forward<A1>( a1 ),
 420         boost::detail::sp_forward<A2>( a2 )
 421         );
 422
 423     pd->set_initialized();
 424
 425     T * pt2 = static_cast< T* >( pv );
 426
 427     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 428     return boost::shared_ptr< T >( pt, pt2 );
 429 }
 430
 431 template< class T, class A1, class A2, class A3 >
 432 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3 )
 433 {
 434     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 435
 436     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 437
 438     void * pv = pd->address();
 439
 440     ::new( pv ) T(
 441         boost::detail::sp_forward<A1>( a1 ),
 442         boost::detail::sp_forward<A2>( a2 ),
 443         boost::detail::sp_forward<A3>( a3 )
 444         );
 445
 446     pd->set_initialized();
 447
 448     T * pt2 = static_cast< T* >( pv );
 449
 450     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 451     return boost::shared_ptr< T >( pt, pt2 );
 452 }
 453
 454 template< class T, class A, class A1, class A2, class A3 >
 455 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
 456 {
 457     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 458
 459     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 460
 461     void * pv = pd->address();
 462
 463     ::new( pv ) T(
 464         boost::detail::sp_forward<A1>( a1 ),
 465         boost::detail::sp_forward<A2>( a2 ),
 466         boost::detail::sp_forward<A3>( a3 )
 467         );
 468
 469     pd->set_initialized();
 470
 471     T * pt2 = static_cast< T* >( pv );
 472
 473     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 474     return boost::shared_ptr< T >( pt, pt2 );
 475 }
 476
 477 template< class T, class A1, class A2, class A3, class A4 >
 478 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
 479 {
 480     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 481
 482     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 483
 484     void * pv = pd->address();
 485
 486     ::new( pv ) T(
 487         boost::detail::sp_forward<A1>( a1 ),
 488         boost::detail::sp_forward<A2>( a2 ),
 489         boost::detail::sp_forward<A3>( a3 ),
 490         boost::detail::sp_forward<A4>( a4 )
 491         );
 492
 493     pd->set_initialized();
 494
 495     T * pt2 = static_cast< T* >( pv );
 496
 497     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 498     return boost::shared_ptr< T >( pt, pt2 );
 499 }
 500
 501 template< class T, class A, class A1, class A2, class A3, class A4 >
 502 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
 503 {
 504     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 505
 506     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 507
 508     void * pv = pd->address();
 509
 510     ::new( pv ) T(
 511         boost::detail::sp_forward<A1>( a1 ),
 512         boost::detail::sp_forward<A2>( a2 ),
 513         boost::detail::sp_forward<A3>( a3 ),
 514         boost::detail::sp_forward<A4>( a4 )
 515         );
 516
 517     pd->set_initialized();
 518
 519     T * pt2 = static_cast< T* >( pv );
 520
 521     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 522     return boost::shared_ptr< T >( pt, pt2 );
 523 }
 524
 525 template< class T, class A1, class A2, class A3, class A4, class A5 >
 526 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
 527 {
 528     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 529
 530     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 531
 532     void * pv = pd->address();
 533
 534     ::new( pv ) T(
 535         boost::detail::sp_forward<A1>( a1 ),
 536         boost::detail::sp_forward<A2>( a2 ),
 537         boost::detail::sp_forward<A3>( a3 ),
 538         boost::detail::sp_forward<A4>( a4 ),
 539         boost::detail::sp_forward<A5>( a5 )
 540         );
 541
 542     pd->set_initialized();
 543
 544     T * pt2 = static_cast< T* >( pv );
 545
 546     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 547     return boost::shared_ptr< T >( pt, pt2 );
 548 }
 549
 550 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
 551 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
 552 {
 553     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 554
 555     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 556
 557     void * pv = pd->address();
 558
 559     ::new( pv ) T(
 560         boost::detail::sp_forward<A1>( a1 ),
 561         boost::detail::sp_forward<A2>( a2 ),
 562         boost::detail::sp_forward<A3>( a3 ),
 563         boost::detail::sp_forward<A4>( a4 ),
 564         boost::detail::sp_forward<A5>( a5 )
 565         );
 566
 567     pd->set_initialized();
 568
 569     T * pt2 = static_cast< T* >( pv );
 570
 571     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 572     return boost::shared_ptr< T >( pt, pt2 );
 573 }
 574
 575 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 576 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
 577 {
 578     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 579
 580     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 581
 582     void * pv = pd->address();
 583
 584     ::new( pv ) T(
 585         boost::detail::sp_forward<A1>( a1 ),
 586         boost::detail::sp_forward<A2>( a2 ),
 587         boost::detail::sp_forward<A3>( a3 ),
 588         boost::detail::sp_forward<A4>( a4 ),
 589         boost::detail::sp_forward<A5>( a5 ),
 590         boost::detail::sp_forward<A6>( a6 )
 591         );
 592
 593     pd->set_initialized();
 594
 595     T * pt2 = static_cast< T* >( pv );
 596
 597     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 598     return boost::shared_ptr< T >( pt, pt2 );
 599 }
 600
 601 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
 602 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
 603 {
 604     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 605
 606     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 607
 608     void * pv = pd->address();
 609
 610     ::new( pv ) T(
 611         boost::detail::sp_forward<A1>( a1 ),
 612         boost::detail::sp_forward<A2>( a2 ),
 613         boost::detail::sp_forward<A3>( a3 ),
 614         boost::detail::sp_forward<A4>( a4 ),
 615         boost::detail::sp_forward<A5>( a5 ),
 616         boost::detail::sp_forward<A6>( a6 )
 617         );
 618
 619     pd->set_initialized();
 620
 621     T * pt2 = static_cast< T* >( pv );
 622
 623     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 624     return boost::shared_ptr< T >( pt, pt2 );
 625 }
 626
 627 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 628 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
 629 {
 630     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 631
 632     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 633
 634     void * pv = pd->address();
 635
 636     ::new( pv ) T(
 637         boost::detail::sp_forward<A1>( a1 ),
 638         boost::detail::sp_forward<A2>( a2 ),
 639         boost::detail::sp_forward<A3>( a3 ),
 640         boost::detail::sp_forward<A4>( a4 ),
 641         boost::detail::sp_forward<A5>( a5 ),
 642         boost::detail::sp_forward<A6>( a6 ),
 643         boost::detail::sp_forward<A7>( a7 )
 644         );
 645
 646     pd->set_initialized();
 647
 648     T * pt2 = static_cast< T* >( pv );
 649
 650     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 651     return boost::shared_ptr< T >( pt, pt2 );
 652 }
 653
 654 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 655 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
 656 {
 657     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 658
 659     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 660
 661     void * pv = pd->address();
 662
 663     ::new( pv ) T(
 664         boost::detail::sp_forward<A1>( a1 ),
 665         boost::detail::sp_forward<A2>( a2 ),
 666         boost::detail::sp_forward<A3>( a3 ),
 667         boost::detail::sp_forward<A4>( a4 ),
 668         boost::detail::sp_forward<A5>( a5 ),
 669         boost::detail::sp_forward<A6>( a6 ),
 670         boost::detail::sp_forward<A7>( a7 )
 671         );
 672
 673     pd->set_initialized();
 674
 675     T * pt2 = static_cast< T* >( pv );
 676
 677     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 678     return boost::shared_ptr< T >( pt, pt2 );
 679 }
 680
 681 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 682 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
 683 {
 684     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 685
 686     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 687
 688     void * pv = pd->address();
 689
 690     ::new( pv ) T(
 691         boost::detail::sp_forward<A1>( a1 ),
 692         boost::detail::sp_forward<A2>( a2 ),
 693         boost::detail::sp_forward<A3>( a3 ),
 694         boost::detail::sp_forward<A4>( a4 ),
 695         boost::detail::sp_forward<A5>( a5 ),
 696         boost::detail::sp_forward<A6>( a6 ),
 697         boost::detail::sp_forward<A7>( a7 ),
 698         boost::detail::sp_forward<A8>( a8 )
 699         );
 700
 701     pd->set_initialized();
 702
 703     T * pt2 = static_cast< T* >( pv );
 704
 705     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 706     return boost::shared_ptr< T >( pt, pt2 );
 707 }
 708
 709 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 710 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
 711 {
 712     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 713
 714     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 715
 716     void * pv = pd->address();
 717
 718     ::new( pv ) T(
 719         boost::detail::sp_forward<A1>( a1 ),
 720         boost::detail::sp_forward<A2>( a2 ),
 721         boost::detail::sp_forward<A3>( a3 ),
 722         boost::detail::sp_forward<A4>( a4 ),
 723         boost::detail::sp_forward<A5>( a5 ),
 724         boost::detail::sp_forward<A6>( a6 ),
 725         boost::detail::sp_forward<A7>( a7 ),
 726         boost::detail::sp_forward<A8>( a8 )
 727         );
 728
 729     pd->set_initialized();
 730
 731     T * pt2 = static_cast< T* >( pv );
 732
 733     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 734     return boost::shared_ptr< T >( pt, pt2 );
 735 }
 736
 737 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 738 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
 739 {
 740     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 741
 742     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 743
 744     void * pv = pd->address();
 745
 746     ::new( pv ) T(
 747         boost::detail::sp_forward<A1>( a1 ),
 748         boost::detail::sp_forward<A2>( a2 ),
 749         boost::detail::sp_forward<A3>( a3 ),
 750         boost::detail::sp_forward<A4>( a4 ),
 751         boost::detail::sp_forward<A5>( a5 ),
 752         boost::detail::sp_forward<A6>( a6 ),
 753         boost::detail::sp_forward<A7>( a7 ),
 754         boost::detail::sp_forward<A8>( a8 ),
 755         boost::detail::sp_forward<A9>( a9 )
 756         );
 757
 758     pd->set_initialized();
 759
 760     T * pt2 = static_cast< T* >( pv );
 761
 762     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 763     return boost::shared_ptr< T >( pt, pt2 );
 764 }
 765
 766 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 767 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
 768 {
 769     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 770
 771     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 772
 773     void * pv = pd->address();
 774
 775     ::new( pv ) T(
 776         boost::detail::sp_forward<A1>( a1 ),
 777         boost::detail::sp_forward<A2>( a2 ),
 778         boost::detail::sp_forward<A3>( a3 ),
 779         boost::detail::sp_forward<A4>( a4 ),
 780         boost::detail::sp_forward<A5>( a5 ),
 781         boost::detail::sp_forward<A6>( a6 ),
 782         boost::detail::sp_forward<A7>( a7 ),
 783         boost::detail::sp_forward<A8>( a8 ),
 784         boost::detail::sp_forward<A9>( a9 )
 785         );
 786
 787     pd->set_initialized();
 788
 789     T * pt2 = static_cast< T* >( pv );
 790
 791     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 792     return boost::shared_ptr< T >( pt, pt2 );
 793 }
 794
 795 #else // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 796
 797 // C++03 version
 798
 799 template< class T, class A1 >
 800 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
 801 {
 802     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 803
 804     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 805
 806     void * pv = pd->address();
 807
 808     ::new( pv ) T( a1 );
 809     pd->set_initialized();
 810
 811     T * pt2 = static_cast< T* >( pv );
 812
 813     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 814     return boost::shared_ptr< T >( pt, pt2 );
 815 }
 816
 817 template< class T, class A, class A1 >
 818 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1 )
 819 {
 820     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 821
 822     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 823
 824     void * pv = pd->address();
 825
 826     ::new( pv ) T( a1 );
 827     pd->set_initialized();
 828
 829     T * pt2 = static_cast< T* >( pv );
 830
 831     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 832     return boost::shared_ptr< T >( pt, pt2 );
 833 }
 834
 835 template< class T, class A1, class A2 >
 836 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2 )
 837 {
 838     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 839
 840     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 841
 842     void * pv = pd->address();
 843
 844     ::new( pv ) T( a1, a2 );
 845     pd->set_initialized();
 846
 847     T * pt2 = static_cast< T* >( pv );
 848
 849     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 850     return boost::shared_ptr< T >( pt, pt2 );
 851 }
 852
 853 template< class T, class A, class A1, class A2 >
 854 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
 855 {
 856     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 857
 858     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 859
 860     void * pv = pd->address();
 861
 862     ::new( pv ) T( a1, a2 );
 863     pd->set_initialized();
 864
 865     T * pt2 = static_cast< T* >( pv );
 866
 867     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 868     return boost::shared_ptr< T >( pt, pt2 );
 869 }
 870
 871 template< class T, class A1, class A2, class A3 >
 872 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
 873 {
 874     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 875
 876     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 877
 878     void * pv = pd->address();
 879
 880     ::new( pv ) T( a1, a2, a3 );
 881     pd->set_initialized();
 882
 883     T * pt2 = static_cast< T* >( pv );
 884
 885     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 886     return boost::shared_ptr< T >( pt, pt2 );
 887 }
 888
 889 template< class T, class A, class A1, class A2, class A3 >
 890 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
 891 {
 892     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 893
 894     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 895
 896     void * pv = pd->address();
 897
 898     ::new( pv ) T( a1, a2, a3 );
 899     pd->set_initialized();
 900
 901     T * pt2 = static_cast< T* >( pv );
 902
 903     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 904     return boost::shared_ptr< T >( pt, pt2 );
 905 }
 906
 907 template< class T, class A1, class A2, class A3, class A4 >
 908 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 909 {
 910     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 911
 912     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 913
 914     void * pv = pd->address();
 915
 916     ::new( pv ) T( a1, a2, a3, a4 );
 917     pd->set_initialized();
 918
 919     T * pt2 = static_cast< T* >( pv );
 920
 921     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 922     return boost::shared_ptr< T >( pt, pt2 );
 923 }
 924
 925 template< class T, class A, class A1, class A2, class A3, class A4 >
 926 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 927 {
 928     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 929
 930     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 931
 932     void * pv = pd->address();
 933
 934     ::new( pv ) T( a1, a2, a3, a4 );
 935     pd->set_initialized();
 936
 937     T * pt2 = static_cast< T* >( pv );
 938
 939     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 940     return boost::shared_ptr< T >( pt, pt2 );
 941 }
 942
 943 template< class T, class A1, class A2, class A3, class A4, class A5 >
 944 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 945 {
 946     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 947
 948     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 949
 950     void * pv = pd->address();
 951
 952     ::new( pv ) T( a1, a2, a3, a4, a5 );
 953     pd->set_initialized();
 954
 955     T * pt2 = static_cast< T* >( pv );
 956
 957     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 958     return boost::shared_ptr< T >( pt, pt2 );
 959 }
 960
 961 template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
 962 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 963 {
 964     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
 965
 966     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 967
 968     void * pv = pd->address();
 969
 970     ::new( pv ) T( a1, a2, a3, a4, a5 );
 971     pd->set_initialized();
 972
 973     T * pt2 = static_cast< T* >( pv );
 974
 975     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 976     return boost::shared_ptr< T >( pt, pt2 );
 977 }
 978
 979 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 980 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 981 {
 982     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
 983
 984     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
 985
 986     void * pv = pd->address();
 987
 988     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
 989     pd->set_initialized();
 990
 991     T * pt2 = static_cast< T* >( pv );
 992
 993     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
 994     return boost::shared_ptr< T >( pt, pt2 );
 995 }
 996
 997 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
 998 typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 999 {
1000     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
1001
1002     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1003
1004     void * pv = pd->address();
1005
1006     ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
1007     pd->set_initialized();
1008
1009     T * pt2 = static_cast< T* >( pv );
1010
1011     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1012     return boost::shared_ptr< T >( pt, pt2 );
1013 }
1014
1015 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
1016 typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
1017 {
1018     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
1019
1020     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1021
1022     void * pv = pd->address();
1023
1024     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
1025     pd->set_initialized();
1026
1027     T * pt2 = static_cast< T* >( pv );
1028
1029     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1030     return boost::shared_ptr< T >( pt, pt2 );
1031 }
1032
1033 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
1034 typename boost::detail::sp_if_not_array< T >::type 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 )
1035 {
1036     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
1037
1038     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1039
1040     void * pv = pd->address();
1041
1042     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
1043     pd->set_initialized();
1044
1045     T * pt2 = static_cast< T* >( pv );
1046
1047     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1048     return boost::shared_ptr< T >( pt, pt2 );
1049 }
1050
1051 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
1052 typename boost::detail::sp_if_not_array< T >::type 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 )
1053 {
1054     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
1055
1056     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1057
1058     void * pv = pd->address();
1059
1060     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
1061     pd->set_initialized();
1062
1063     T * pt2 = static_cast< T* >( pv );
1064
1065     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1066     return boost::shared_ptr< T >( pt, pt2 );
1067 }
1068
1069 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
1070 typename boost::detail::sp_if_not_array< T >::type 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 )
1071 {
1072     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
1073
1074     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1075
1076     void * pv = pd->address();
1077
1078     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
1079     pd->set_initialized();
1080
1081     T * pt2 = static_cast< T* >( pv );
1082
1083     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1084     return boost::shared_ptr< T >( pt, pt2 );
1085 }
1086
1087 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
1088 typename boost::detail::sp_if_not_array< T >::type 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 )
1089 {
1090     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
1091
1092     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1093
1094     void * pv = pd->address();
1095
1096     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1097     pd->set_initialized();
1098
1099     T * pt2 = static_cast< T* >( pv );
1100
1101     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1102     return boost::shared_ptr< T >( pt, pt2 );
1103 }
1104
1105 template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
1106 typename boost::detail::sp_if_not_array< T >::type 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 )
1107 {
1108     boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
1109
1110     boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
1111
1112     void * pv = pd->address();
1113
1114     ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
1115     pd->set_initialized();
1116
1117     T * pt2 = static_cast< T* >( pv );
1118
1119     boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
1120     return boost::shared_ptr< T >( pt, pt2 );
1121 }
1122
1123 #endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
1124
1125 #endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
1126
1127 #undef BOOST_SP_MSD
1128
1129 } // namespace boost
1130
1131 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED