boost/signals2/deconstruct.hpp

   1 #ifndef BOOST_SIGNALS2_DECONSTRUCT_HPP
   2 #define BOOST_SIGNALS2_DECONSTRUCT_HPP
   3
   4 //  deconstruct.hpp
   5 //
   6 // A factory function for creating a shared_ptr which creates
   7 // an object and its owning shared_ptr with one allocation, similar
   8 // to make_shared<T>().  It also supports postconstructors
   9 // and predestructors through unqualified calls of adl_postconstruct() and
  10 // adl_predestruct, relying on argument-dependent
  11 // lookup to find the appropriate postconstructor or predestructor.
  12 // Passing arguments to postconstructors is also supported.
  13 //
  14 //  based on make_shared.hpp and make_shared_access patch from Michael Marcin
  15 //
  16 //  Copyright (c) 2007, 2008 Peter Dimov
  17 //  Copyright (c) 2008 Michael Marcin
  18 //  Copyright (c) 2009 Frank Mori Hess
  19 //
  20 //  Distributed under the Boost Software License, Version 1.0.
  21 //  See accompanying file LICENSE_1_0.txt or copy at
  22 //  http://www.boost.org/LICENSE_1_0.txt
  23 //
  24 //  See http://www.boost.org
  25 //  for more information
  26
  27 #include <boost/config.hpp>
  28 #include <boost/shared_ptr.hpp>
  29 #include <boost/signals2/deconstruct_ptr.hpp>
  30 #include <boost/type_traits/alignment_of.hpp>
  31 #include <boost/type_traits/remove_const.hpp>
  32 #include <boost/type_traits/type_with_alignment.hpp>
  33 #include <cstddef>
  34 #include <new>
  35
  36 namespace boost
  37 {
  38   template<typename T> class enable_shared_from_this;
  39
  40 namespace signals2
  41 {
  42   class deconstruct_access;
  43
  44 namespace detail
  45 {
  46
  47 #if defined( BOOST_HAS_RVALUE_REFS )
  48   template< class T > T&& forward( T &&t )
  49   {
  50       return t;
  51   }
  52 #endif
  53
  54   inline void adl_predestruct(...) {}
  55 } // namespace detail
  56
  57 template<typename T>
  58     class postconstructor_invoker
  59 {
  60 public:
  61     operator const shared_ptr<T> & () const
  62     {
  63         return postconstruct();
  64     }
  65     const shared_ptr<T>& postconstruct() const
  66     {
  67         if(!_postconstructed)
  68         {
  69             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()));
  70             _postconstructed = true;
  71         }
  72         return _sp;
  73     }
  74 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
  75     template<class... Args>
  76       const shared_ptr<T>& postconstruct(Args && ... args)
  77     {
  78         if(!_postconstructed)
  79         {
  80             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
  81                 detail::forward<Args>(args)...);
  82             _postconstructed = true;
  83         }
  84         return _sp;
  85     }
  86 #else
  87     template<typename A1>
  88       const shared_ptr<T>& postconstruct(const A1 &a1) const
  89     {
  90         if(!_postconstructed)
  91         {
  92             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
  93                 a1);
  94             _postconstructed = true;
  95         }
  96         return _sp;
  97     }
  98     template<typename A1, typename A2>
  99       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2) const
 100     {
 101         if(!_postconstructed)
 102         {
 103             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 104                 a1, a2);
 105             _postconstructed = true;
 106         }
 107         return _sp;
 108     }
 109     template<typename A1, typename A2, typename A3>
 110       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3) const
 111     {
 112         if(!_postconstructed)
 113         {
 114             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 115                 a1, a2, a3);
 116             _postconstructed = true;
 117         }
 118         return _sp;
 119     }
 120     template<typename A1, typename A2, typename A3, typename A4>
 121       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
 122     {
 123         if(!_postconstructed)
 124         {
 125             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 126                 a1, a2, a3, a4);
 127             _postconstructed = true;
 128         }
 129         return _sp;
 130     }
 131     template<typename A1, typename A2, typename A3, typename A4, typename A5>
 132       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const
 133     {
 134         if(!_postconstructed)
 135         {
 136             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 137                 a1, a2, a3, a4, a5);
 138             _postconstructed = true;
 139         }
 140         return _sp;
 141     }
 142     template<typename A1, typename A2, typename A3, typename A4, typename A5,
 143       typename A6>
 144       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
 145       const A6 &a6) const
 146     {
 147         if(!_postconstructed)
 148         {
 149             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 150                 a1, a2, a3, a4, a5, a6);
 151             _postconstructed = true;
 152         }
 153         return _sp;
 154     }
 155     template<typename A1, typename A2, typename A3, typename A4, typename A5,
 156       typename A6, typename A7>
 157       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
 158       const A6 &a6, const A7 &a7) const
 159     {
 160         if(!_postconstructed)
 161         {
 162             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 163                 a1, a2, a3, a4, a5, a6, a7);
 164             _postconstructed = true;
 165         }
 166         return _sp;
 167     }
 168     template<typename A1, typename A2, typename A3, typename A4, typename A5,
 169       typename A6, typename A7, typename A8>
 170       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
 171       const A6 &a6, const A7 &a7, const A8 &a8) const
 172     {
 173         if(!_postconstructed)
 174         {
 175             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 176                 a1, a2, a3, a4, a5, a6, a7, a8);
 177             _postconstructed = true;
 178         }
 179         return _sp;
 180     }
 181     template<typename A1, typename A2, typename A3, typename A4, typename A5,
 182       typename A6, typename A7, typename A8, typename A9>
 183       const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
 184       const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9) const
 185     {
 186         if(!_postconstructed)
 187         {
 188             adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
 189                 a1, a2, a3, a4, a5, a6, a7, a8, a9);
 190             _postconstructed = true;
 191         }
 192         return _sp;
 193     }
 194 #endif // else defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
 195 private:
 196     friend class boost::signals2::deconstruct_access;
 197     postconstructor_invoker(const shared_ptr<T> & sp):
 198         _sp(sp), _postconstructed(false)
 199     {}
 200     shared_ptr<T> _sp;
 201     mutable bool _postconstructed;
 202 };
 203
 204 namespace detail
 205 {
 206
 207 template< std::size_t N, std::size_t A > struct sp_aligned_storage
 208 {
 209     union type
 210     {
 211         char data_[ N ];
 212         typename boost::type_with_alignment< A >::type align_;
 213     };
 214 };
 215
 216 template< class T > class deconstruct_deleter
 217 {
 218 private:
 219
 220     typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
 221
 222     bool initialized_;
 223     storage_type storage_;
 224
 225 private:
 226
 227     void destroy()
 228     {
 229         if( initialized_ )
 230         {
 231             T* p = reinterpret_cast< T* >( storage_.data_ );
 232             using boost::signals2::detail::adl_predestruct;
 233             adl_predestruct(const_cast<typename boost::remove_const<T>::type *>(p));
 234             p->~T();
 235             initialized_ = false;
 236         }
 237     }
 238
 239 public:
 240
 241     deconstruct_deleter(): initialized_( false )
 242     {
 243     }
 244
 245     // this copy constructor is an optimization: we don't need to copy the storage_ member,
 246     // and shouldn't be copying anyways after initialized_ becomes true
 247     deconstruct_deleter(const deconstruct_deleter &): initialized_( false )
 248     {
 249     }
 250
 251     ~deconstruct_deleter()
 252     {
 253         destroy();
 254     }
 255
 256     void operator()( T * )
 257     {
 258         destroy();
 259     }
 260
 261     void * address()
 262     {
 263         return storage_.data_;
 264     }
 265
 266     void set_initialized()
 267     {
 268         initialized_ = true;
 269     }
 270 };
 271 }  // namespace detail
 272
 273 class deconstruct_access
 274 {
 275 public:
 276
 277     template< class T >
 278     static postconstructor_invoker<T> deconstruct()
 279     {
 280         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 281
 282         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 283
 284         void * pv = pd->address();
 285
 286         new( pv ) T();
 287         pd->set_initialized();
 288
 289         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 290         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 291         return retval;
 292
 293     }
 294
 295 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
 296
 297     // Variadic templates, rvalue reference
 298
 299     template< class T, class... Args >
 300     static postconstructor_invoker<T> deconstruct( Args && ... args )
 301     {
 302         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 303
 304         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 305
 306         void * pv = pd->address();
 307
 308         new( pv ) T( detail::forward<Args>( args )... );
 309         pd->set_initialized();
 310
 311         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 312         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 313         return retval;
 314     }
 315
 316 #else
 317
 318     template< class T, class A1 >
 319     static postconstructor_invoker<T> deconstruct( A1 const & a1 )
 320     {
 321         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 322
 323         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 324
 325         void * pv = pd->address();
 326
 327         new( pv ) T( a1 );
 328         pd->set_initialized();
 329
 330         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 331         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 332         return retval;
 333     }
 334
 335     template< class T, class A1, class A2 >
 336     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
 337     {
 338         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 339
 340         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 341
 342         void * pv = pd->address();
 343
 344         new( pv ) T( a1, a2 );
 345         pd->set_initialized();
 346
 347         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 348         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 349         return retval;
 350     }
 351
 352     template< class T, class A1, class A2, class A3 >
 353     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
 354     {
 355         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 356
 357         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 358
 359         void * pv = pd->address();
 360
 361         new( pv ) T( a1, a2, a3 );
 362         pd->set_initialized();
 363
 364         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 365         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 366         return retval;
 367     }
 368
 369     template< class T, class A1, class A2, class A3, class A4 >
 370     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 371     {
 372         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 373
 374         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 375
 376         void * pv = pd->address();
 377
 378         new( pv ) T( a1, a2, a3, a4 );
 379         pd->set_initialized();
 380
 381         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 382         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 383         return retval;
 384     }
 385
 386     template< class T, class A1, class A2, class A3, class A4, class A5 >
 387     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 388     {
 389         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 390
 391         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 392
 393         void * pv = pd->address();
 394
 395         new( pv ) T( a1, a2, a3, a4, a5 );
 396         pd->set_initialized();
 397
 398         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 399         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 400         return retval;
 401     }
 402
 403     template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 404     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 405     {
 406         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 407
 408         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 409
 410         void * pv = pd->address();
 411
 412         new( pv ) T( a1, a2, a3, a4, a5, a6 );
 413         pd->set_initialized();
 414
 415         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 416         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 417         return retval;
 418     }
 419
 420     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 421     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 422     {
 423         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 424
 425         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 426
 427         void * pv = pd->address();
 428
 429         new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
 430         pd->set_initialized();
 431
 432         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 433         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 434         return retval;
 435     }
 436
 437     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 438     static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 439     {
 440         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 441
 442         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 443
 444         void * pv = pd->address();
 445
 446         new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
 447         pd->set_initialized();
 448
 449         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 450         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 451         return retval;
 452     }
 453
 454     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 455     static postconstructor_invoker<T> deconstruct( 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 )
 456     {
 457         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 458
 459         detail::deconstruct_deleter< T > * pd = boost::get_deleter< detail::deconstruct_deleter< T > >( pt );
 460
 461         void * pv = pd->address();
 462
 463         new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
 464         pd->set_initialized();
 465
 466         boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
 467         boost::detail::sp_enable_shared_from_this(&retval, retval.get(), retval.get());
 468         return retval;
 469     }
 470
 471 #endif
 472 };
 473
 474 // Zero-argument versions
 475 //
 476 // Used even when variadic templates are available because of the new T() vs new T issue
 477
 478 template< class T > postconstructor_invoker<T> deconstruct()
 479 {
 480     return deconstruct_access::deconstruct<T>();
 481 }
 482
 483 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
 484
 485 // Variadic templates, rvalue reference
 486
 487 template< class T, class... Args > postconstructor_invoker< T > deconstruct( Args && ... args )
 488 {
 489     return deconstruct_access::deconstruct<T>( detail::forward<Args>( args )... );
 490 }
 491
 492 #else
 493
 494 // C++03 version
 495
 496 template< class T, class A1 >
 497 postconstructor_invoker<T> deconstruct( A1 const & a1 )
 498 {
 499     return deconstruct_access::deconstruct<T>(a1);
 500 }
 501
 502 template< class T, class A1, class A2 >
 503 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
 504 {
 505     return deconstruct_access::deconstruct<T>(a1,a2);
 506 }
 507
 508 template< class T, class A1, class A2, class A3 >
 509 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
 510 {
 511     return deconstruct_access::deconstruct<T>(a1,a2,a3);
 512 }
 513
 514 template< class T, class A1, class A2, class A3, class A4 >
 515 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 516 {
 517     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4);
 518 }
 519
 520 template< class T, class A1, class A2, class A3, class A4, class A5 >
 521 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 522 {
 523     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5);
 524 }
 525
 526 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
 527 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 528 {
 529     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6);
 530 }
 531
 532 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
 533 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 534 {
 535     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7);
 536 }
 537
 538 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
 539 postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 540 {
 541     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8);
 542 }
 543
 544 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
 545 postconstructor_invoker<T> deconstruct( 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 )
 546 {
 547     return deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8,a9);
 548 }
 549
 550 #endif
 551
 552 } // namespace signals2
 553 } // namespace boost
 554
 555 #endif // #ifndef BOOST_SIGNALS2_DECONSTRUCT_HPP