Geant4 LXR

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/include/G4memory.hh

   //
   // ********************************************************************
   // * License and Disclaimer                                           *
   // *                                                                  *
   // * The  Geant4 software  is  copyright of the Copyright Holders  of *
   // * the Geant4 Collaboration.  It is provided  under  the terms  and *
   // * conditions of the Geant4 Software License,  included in the file *
   // * LICENSE and available at  http://cern.ch/geant4/license .  These *
   // * include a list of copyright holders.                             *
  // *                                                                  *
  // * Neither the authors of this software system, nor their employing *
  // * institutes,nor the agencies providing financial support for this *
  // * work  make  any representation or  warranty, express or implied, *
  // * regarding  this  software system or assume any liability for its *
  // * use.  Please see the license in the file  LICENSE  and URL above *
  // * for the full disclaimer and the limitation of liability.         *
  // *                                                                  *
  // * This  code  implementation is the result of  the  scientific and *
  // * technical work of the GEANT4 collaboration.                      *
  // * By using,  copying,  modifying or  distributing the software (or *
  // * any work based  on the software)  you  agree  to acknowledge its *
  // * use  in  resulting  scientific  publications,  and indicate your *
  // * acceptance of all terms of the Geant4 Software license.          *
  // ********************************************************************
  //
  #ifndef G4SHARED_PTR_HH_
  #define G4SHARED_PTR_HH_
  
  //#if __cplusplus >= 201103L
  #include <memory>
  
  #define G4shared_ptr std::shared_ptr
  #define G4weak_ptr std::weak_ptr
  #define G4static_pointer_cast std::static_pointer_cast
  #define G4const_pointer_cast std::const_pointer_cast
  #define G4dynamic_pointer_cast std::dynamic_pointer_cast
  #define G4enable_shared_from_this std::enable_shared_from_this
  #define G4enable_shared_from_this2 std::enable_shared_from_this
  /*
  #else
  #include "CLHEP/Utility/memory.h"
  
  #define G4shared_ptr G4::shared_ptr
  #define G4weak_ptr G4::weak_ptr
  #define G4static_pointer_cast G4::static_pointer_cast
  #define G4const_pointer_cast G4::const_pointer_cast
  #define G4dynamic_pointer_cast G4::dynamic_pointer_cast
  #define G4enable_shared_from_this G4::enable_shared_from_this
  #define G4enable_shared_from_this2 G4::enable_shared_from_this2
  
  namespace G4
  {
  using CLHEP::shared_ptr;
  using CLHEP::weak_ptr;
  using CLHEP::static_pointer_cast;
  using CLHEP::const_pointer_cast;
  using CLHEP::dynamic_pointer_cast;
  }
  
  namespace CLHEP
  {
  
  template< typename T >
  class enable_shared_from_this
  {
  protected:
    enable_shared_from_this()
  { }
  
    ~enable_shared_from_this()
    { }
  
    enable_shared_from_this( enable_shared_from_this const & )
    { }
  
    enable_shared_from_this &
    operator = ( enable_shared_from_this const & )
    {
      return *this;
    }
  
  public:
    shared_ptr<T>
    shared_from_this()
    {
      shared_ptr<T>  p( weak_this_ );
      // assert( p.get() == this );
      return p;
    }
  
    shared_ptr<T const>
    shared_from_this() const
    {
      shared_ptr<T const>  p( weak_this_ );
      // assert( p.get() == this );
      return p;
    }
  
  public: // actually private, but avoids compiler template friendship issues
 
   // Note: invoked automatically by shared_ptr; do not call
   template< typename X, typename Y >
   void
   _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
   {
     if( weak_this_.expired() )
       weak_this_ = shared_ptr<T>( *ppx, py );
   }
 
 private:
   mutable weak_ptr<T>  weak_this_;
 };  // enable_shared_from_this<>
 
 
 //  enable_shared_from_this2.hpp
 
 namespace detail
 {
 
 class esft2_deleter_wrapper
 {
 private:
   shared_ptr<void>  deleter_;
 
 public:
   esft2_deleter_wrapper(){ }
 
   template< typename T >
   void
   set_deleter( shared_ptr<T> const & deleter )
   {
     deleter_ = deleter;
   }
 
   template< typename T >
   void
   operator () ( T* )
   {
     assert( deleter_.use_count() <= 1 );
     deleter_.reset();
   }
 };
 
 } // namespace detail
 
 template< typename T >
 class enable_shared_from_this2
 {
 protected:
 
   enable_shared_from_this2(){ }
 
   enable_shared_from_this2( enable_shared_from_this2 const & )
   { }
 
   enable_shared_from_this2 & operator = ( enable_shared_from_this2 const & )
   {
     return *this;
   }
 
   ~enable_shared_from_this2()
   {
     assert( shared_this_.use_count() <= 1 ); // ensure no dangling shared_ptrs
   }
 
 private:
   mutable  weak_ptr<T>    weak_this_;
   mutable  shared_ptr<T>  shared_this_;
 
 public:
 
   shared_ptr<T>
   shared_from_this()
   {
     init_weak_once();
     return shared_ptr<T>( weak_this_ );
   }
 
   shared_ptr<T const>
   shared_from_this() const
   {
     init_weak_once();
     return shared_ptr<T>( weak_this_ );
   }
 
 private:
 
   void init_weak_once() const
   {
     if( weak_this_._empty() )
     {
       shared_this_.reset( static_cast< T* >( 0 )
           , detail::esft2_deleter_wrapper()
       );
       weak_this_ = shared_this_;
     }
   }
 
 public:  // actually private, but avoids compiler template friendship issues
 
 // Note: invoked automatically by shared_ptr; do not call
   template< typename X, typename Y >
   void
   _internal_accept_owner( shared_ptr<X> * ppx, Y * py ) const
   {
     assert( ppx != 0 );
 
     if( weak_this_.use_count() == 0 )
       weak_this_ = shared_ptr<T>( *ppx, py );
     else if( shared_this_.use_count() != 0 )
     {
       assert( ppx->unique() ); // no weak_ptrs should exist either, but there's no way to check that
 
       detail::esft2_deleter_wrapper *  pd
       = //boost::
           get_deleter<detail::esft2_deleter_wrapper>( shared_this_ );
       assert( pd != 0 );
 
       pd->set_deleter( *ppx );
 
       ppx->reset( shared_this_, ppx->get() );
       shared_this_.reset();
     }
   }
 };  // enable_shared_from_this2<>
 }
 
 namespace G4
 {
   using CLHEP::enable_shared_from_this;
   using CLHEP::enable_shared_from_this2;
 }
 #endif
 */
 
 #endif /* G4SHARED_PTR_HH_ */