G4memory.hh

Go to the documentation of this file.

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