rcptr.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
 
#ifndef CARTOBASE_SMART_RCPTR_H
#define CARTOBASE_SMART_RCPTR_H
 
#include <cartobase/config/cartobase_config.h>
#include <memory>
#include <iostream>
#include <utility>
 
// uncomment this line to get debugging information
// #define DEBUG_REF
 
// comment this line to disable thread-safe code using ZooLib atomic operations
#define CARTO_THREADED_RCPTR
 
#ifdef CARTO_THREADED_RCPTR
#ifndef CARTO_NO_BOOST
#include <boost/version.hpp>
#if BOOST_VERSION >= 103300 && \
  ( !defined( linux ) || ( defined( __GNUC__ ) && __GNUC__ >= 4 ) )
#include <boost/detail/atomic_count.hpp>
#ifndef BOOST_AC_USE_PTHREADS
#define CARTO_RCPTR_USE_BOOST
#endif
#endif // BOOST_VERSION
#endif // CARTO_NO_BOOST
 
#ifndef CARTO_RCPTR_USE_BOOST
// try using ZooLib-based implementation
#include <cartobase/zoolib/atomiccount.h>
#endif
 
#if !defined( CARTO_RCPTR_USE_BOOST ) && !defined( CARTO_RCPTR_USE_ZOOLIB )
#undef CARTO_THREADED_RCPTR
#endif
 
#endif // CARTO_THREADED_RCPTR
 
namespace carto {

template <class T>
class const_ref;
template <class T>
class ref;
 

#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
class DefaultRefConstruction
{
  template <class T>  friend class ref;
  template <class T>  friend class const_ref;
 
  template <class T>
  static void destroy( const_ref<T> * );
  template <class T>
  static void construct( const_ref<T> *, const T *, bool externalowner );
protected:
  /* if T has a release() method, there will be an ambiguity in
      RefConstruction<T>::release, since RefConstruction inherits T and
      DefaultRefConstruction. Then we will need to specialize
      RefConstruction for these classes and overload release() there.
  */
  template <class T>
  static const T *release( const_ref<T> * );
};
 
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES

class RCObject 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
: public virtual DefaultRefConstruction
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
{
  template <class T>  friend class ref;
  template <class T>  friend class const_ref;
  template <class T>  friend class shared_ptr;
  friend class rc_ptr_trick;
 
  template <class T>
  static void destroy( const_ref<T> * );
  template <class T>
  static void construct( const_ref<T> *, const T *, bool externalowner );
  template <class T>
  static const T *release( const_ref<T> * );
 
public:
#ifdef CARTO_THREADED_RCPTR
  typedef boost::detail::atomic_count RefCounterType;
#else
  typedef int RefCounterType;
#endif
 
private:
  mutable RefCounterType _refCounter;
 
public:
  
  inline RCObject() : _refCounter( 0 ) {}
 
  inline RCObject( const RCObject & )
    : _refCounter( 0 ) {}
 
  inline RCObject & operator = ( const RCObject & ) { return *this; }
 
  inline virtual ~RCObject()
  {
    // set counter to 0 in case of forced deletion
    long refCounter = _refCounter;
#ifdef CARTO_DEBUG
    if( refCounter > 0 )
      std::cerr << "RCObject destructor called while " << refCounter 
                << " references are still alive on object " << this 
                << std::endl;
#endif
    if( refCounter > 0 )
      for( long i=0; i<refCounter; ++i )
        --_refCounter;
    else
      for( long i=0; i<-refCounter; ++i )
        ++_refCounter;
  }
};
 
 
class rc_ptr_trick;
 

#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES 
template <class T>
class RefConstruction : T, virtual DefaultRefConstruction
{
  template <class R>  friend class ref;
  template <class R>  friend class const_ref;

  RefConstruction();
};

template <class T>
class RefData
{
  template <class R> friend class const_ref;
  template <class R> friend class ref;
  friend class DefaultRefConstruction;
  friend class RCObject;
  friend class rc_ptr_trick;
 
  RCObject::RefCounterType *_pcount;
  T *_ref;
 
public:
 
  inline int count() const
  {
    return ( _pcount ? *_pcount : 0 );
  }
};
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
 


template <class T>
class const_ref 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
: public RefData<T>
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
{
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
  friend class DefaultRefConstruction;
  friend class RCObject;
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES
  template <class R> friend class ref;
 
public:
 
  typedef T referenced_type;
  inline const_ref() { this->_pcount = 0; this->_ref = 0; }
 
  inline explicit const_ref( const T *pObject )
  {
    RefConstruction<T>::construct( this, pObject, false );
  }
 
  inline explicit const_ref( const T *pObject, bool externalowner )
  {
    RefConstruction<T>::construct( this, pObject, externalowner );
  }
 
#if __cplusplus >= 201103L
  // Only unique_ptr with the default deleter can be converted, because
  // const_ref does not support custom deleters (it calls the delete operator
  // upon destruction, just like std::default_delete).
  template< class U >
  const_ref( std::unique_ptr<U>&& r )
  {
    RefConstruction<T>::construct( this, r.release(), false );
  }
#else
  template< class U >
  const_ref( std::auto_ptr<U> r )
  {
    RefConstruction<T>::construct( this, r.release(), false );
  }
#endif
 
  inline const_ref( const ref<T> &other ) {
#ifdef DEBUG_REF
    std::cout << "New ref from other ref (" << other._ref << ")" << std::endl;
#endif
    if( other._pcount && *other._pcount >= 0 )
      ++(*other._pcount);
    this->_pcount = other._pcount;
    this->_ref = other._ref;
  }
 
  inline const_ref( const const_ref<T> &other ) {
#ifdef DEBUG_REF
    std::cout << "New ref from other ref (" << other._ref << ")" << std::endl;
#endif
    if( other._pcount && *other._pcount >= 0 )
      ++(*other._pcount);
    this->_pcount = other._pcount;
    this->_ref = other._ref;
  }
 
  template <class R>
  inline const_ref( const ref<R> &o ){
    const RefData<R> &other = o;
#ifdef DEBUG_REF
    std::cout << "New ref from other ref with implicit cast (" << other._ref
      << ")" << std::endl;
#endif
    if( other._pcount && *other._pcount >= 0 )
      ++(*other._pcount);
    this->_pcount = other._pcount;
    this->_ref = other._ref;
  }
 
  template <class R>
  inline const_ref( const const_ref<R> &other ){
#ifdef DEBUG_REF
    std::cout << "New ref from other ref with implicit cast (" << other._ref << ")" << std::endl;
#endif
    if( other._pcount && *other._pcount >= 0 )
      ++(*other._pcount);
    this->_pcount = other._pcount;
    this->_ref = other._ref;
  }
 
  inline ~const_ref() {  RefConstruction<T>::destroy( this ); }
  
  // const_ref<T> &operator =( const T *pObject );
  const_ref<T> &operator =( const ref<T> &other );
  const_ref<T> &operator =( const const_ref<T> &other );
 
  inline bool isNull() const { return this->_pcount == NULL; }
  inline bool operator ==( const ref<T> &other ) const { return this->_ref == other._ref; }
  inline bool operator ==( const T *pointer ) const { return this->_ref == pointer; }
  inline bool operator ==( const const_ref<T> &other ) const { return this->_ref == other._ref; }
  inline bool operator !=( const ref<T> &other ) const { return this->_ref != other._ref; }
  inline bool operator !=( const const_ref<T> &other ) const { return this->_ref != other._ref; }
  inline bool operator !=( const T *pointer ) const { return this->_ref != pointer; }
 
  inline const T *operator ->() const {
    return static_cast<const T *>( this->_ref );
  }
 
  inline const T &operator *() const {
    return *static_cast<const T *>( this->_ref );
  }
 
  inline const T *pointer() const {
    return static_cast<const T *>( this->_ref );
  }
 
  inline int refCount() const
  {
    return this->_pcount ? *this->_pcount : 0;
  }
};
 

  /*
template <class T>
const_ref<T> &const_ref<T>::operator =( const T *pObject ) {
#ifdef DEBUG_REF
    std::cout << "ref (" << this->_ref << ") = " << pObject << std::endl;
#endif
  if ( this->_ref != pObject ) {
    RefConstruction<T>::destroy( this );
    RefConstruction<T>::construct( this, pObject, false );
  }
  return *this;
}
  */

template <class T>
const_ref<T> &const_ref<T>::operator =( const ref<T> &other ) {
#ifdef DEBUG_REF
    std::cout << "ref (" << this->_ref << ") = ref (" << other._ref << ")"
      << std::endl;
#endif
  if ( this->_ref != other._ref )
    {
      if( other._pcount && *other._pcount >= 0 )
        ++(*other._pcount);
      RefConstruction<T>::destroy( this );
      this->_pcount = other._pcount;
      this->_ref = other._ref;
    }
  return *this;
}

template <class T>
const_ref<T> &const_ref<T>::operator =( const const_ref<T> &other ) {
#ifdef DEBUG_REF
    std::cout << "ref (" << this->_ref << ") = ref (" << other._ref << ")"
      << std::endl;
#endif
  if ( this != &other && this->_ref != other._ref )
    {
      if( other._pcount && *other._pcount >= 0 )
        ++(*other._pcount);
      RefConstruction<T>::destroy( this );
      this->_pcount = other._pcount;
      this->_ref = other._ref;
    }
  return *this;
}
 

template <class T>
class ref : public const_ref<T>
{
  template <class R> friend class const_ref;
  
public:
  
  typedef T referenced_type;
 
  inline ref() : const_ref<T>() {
#ifdef DEBUG_REF
    std::cout << "New empty ref" << std::endl;
#endif
  }
 
  inline explicit ref( T *pObject ) : const_ref<T>( pObject ) {}
  inline explicit ref( T *pObject, bool externalowner ) 
    : const_ref<T>( pObject, externalowner ) {}
 
#if __cplusplus >= 201103L
  template< class U >
  ref( std::unique_ptr<U>&& r ) : const_ref<T>( std::move(r) ) {}
#else
  template< class U >
  ref( std::auto_ptr<U> r ) : const_ref<T>( r ) {}
#endif
 
  inline ref( const ref<T> &other ) : const_ref<T>( other ) {}
  
  template <class R>
  inline ref( const ref<R> &other ) : const_ref<T>( other ) {}
 
  inline ~ref() {}
 
  inline T *release() {
    return const_cast<T *>( RefConstruction<T>::release( this ) );
  }
 
  inline ref<T> &operator =( const ref<T> &other ) {
    this->const_ref<T>::operator =( other );
    return *this;
  }
 
  inline T *operator ->() const {
    return static_cast<T *>( this->_ref );
  }
 
  inline T &operator *() const {
    return *static_cast<T *>( this->_ref );
  }
 
  inline T *pointer() const {
    return static_cast<T *>( this->_ref );
  }
 
};
 
 

#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
template <class T>
void DefaultRefConstruction::construct( const_ref<T> *r, const T *pObject, 
                                        bool externalowner )
{
#ifdef DEBUG_REF
    std::cout << "New ref (" << pObject << ")" << std::endl;
#endif
  if ( pObject && !externalowner )
    r->_pcount = new RCObject::RefCounterType( 1 );
  else r->_pcount = NULL;
  r->_ref = const_cast<T *>( pObject );
}

template <class T>
void DefaultRefConstruction::destroy( const_ref<T> *r ) {
#ifdef DEBUG_REF
  std::cout << "Deleting ref (" << r->_ref << ")" << std::endl;
#endif
  if ( r->_pcount && --(*r->_pcount) == 0 )
    {
#ifdef DEBUG_REF
      std::cout << "Deleting ref object (" << r->_ref << ")" << std::endl;
#endif
      delete r->_pcount;
      delete static_cast<T *>( r->_ref );
    }
}

template <class T>
const T *DefaultRefConstruction::release( const_ref<T> *r ) {
#ifdef DEBUG_REF
  std::cout << "Releasing ref (" << r->_ref << ")" << std::endl;
#endif
  const T * const result = r->_ref;
  if ( r->_pcount && --(*r->_pcount) == 0 )
    {
      delete r->_pcount;
      r->_pcount = 0;
    }
  r->_ref = NULL;
  return result;
}
#endif // DOXYGEN_HIDE_INTERNAL_CLASSES

 
 
 

template <class T>
void RCObject::construct( const_ref<T> *r, const T * pObject, 
                          bool externalowner )
{
#ifdef DEBUG_REF
  std::cout << "New RCObject (" << pObject << ")" << std::endl;
#endif
  if( pObject )
    {
      long x = pObject->_refCounter;
      if( externalowner && x == 0 )
      {
        --pObject->_refCounter;
        // r->_pcount = NULL;
      }
      else if( x >= 0 )
        ++pObject->_refCounter;
      r->_pcount = &pObject->_refCounter;
    }
  else
    r->_pcount = NULL;
  r->_ref = const_cast<T *>( pObject );
}

template <class T>
void RCObject::destroy( const_ref<T> *r )
{
#ifdef DEBUG_REF
  std::cout << "RCObject::destroy (" << r->_ref << ")" << std::endl;
  if( r->_pcount )
    std::cout << "  count: " << *r->_pcount << std::endl;
  else
    std::cout << "  no counter\n";
#endif
  if( r->_pcount && --(*r->_pcount) == 0 )
    {
#ifdef DEBUG_REF
      std::cout << "Deleting RCObject object (" << r->_ref << ")" << std::endl;
#endif
      delete static_cast<T *>( r->_ref );
    }
}

template <class T>
const T *RCObject::release( const_ref<T> *r ) {
#ifdef DEBUG_REF
  std::cout << "Releasing RCObject (" << r->_ref << ")" << std::endl;
#endif
  const T * const result = r->_ref;
  if ( r->_pcount && *r->_pcount >= 0 )
    --(*r->_pcount);
  r->_pcount = 0;
  r->_ref = 0;
  return result;
}
 
 
template <typename T>
class rc_ptr : public ref<T>
{
public:
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
  class insipid
  {
  protected:
      void operator delete( void* );
      void operator delete[]( void* );
  };
#endif
 
  inline rc_ptr() {}
  inline explicit rc_ptr( T *p ) : ref<T>( p ) {}
  inline explicit rc_ptr( T *p, bool externalowner ) 
    : ref<T>( p, externalowner ) {}
 
#if __cplusplus >= 201103L
  template< class U >
  rc_ptr( std::unique_ptr<U>&& r ) : ref<T>( std::move(r) ) {}
#else
  template< class U >
  rc_ptr( std::auto_ptr<U> r ) : ref<T>( r ) {}
#endif
 
  inline void reset( T *p = NULL )
  { *static_cast< ref<T> * >( this ) = ref<T>( p ); }
  inline T *get() const { return this->pointer(); }
  inline bool operator <( const rc_ptr<T> &other ) const {
    return this->pointer() < other.pointer();
  }
 
#ifndef DOXYGEN_HIDE_INTERNAL_CLASSES
  inline operator insipid*() const
  {
    return reinterpret_cast< insipid* >( this->pointer() );
  }
#endif
};
 
 
 
template <>
class RefConstruction< char > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< unsigned char > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< short > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< unsigned short > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< int > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< unsigned int > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< long > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< unsigned long > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< float > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
template <>
class RefConstruction< double > : DefaultRefConstruction
{
 
  private:
 
    template < class R > friend class ref;
    template < class R > friend class const_ref;
 
    RefConstruction();
 
 
};
 
 
} // namespace carto
 
 
#endif