EIC code displayed by LXR master/​include/​Geant4/​G4memory.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:58:39

 //
 // ********************************************************************
 // * 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_ */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team