RefCountedPtr< T > Class Template Reference

#include <RefCountedPtr.H>

Inheritance diagram for RefCountedPtr< T >:

Inheritance graph
[legend]

List of all members.


Detailed Description

template<class T>
class RefCountedPtr< T >

A reference-counting handle class.

This is to be used as a pointer to class T. This will feel and smell just like a built-in pointer except:

  1. There is no need to call delete on the pointer.
  2. The default copy constructor and assignment implement ref-counting.
  3. The user may call isNonUnique to determine if this pointer is the only pointer to the data. This can be used to hide the ref-counting behavior of a class.
  4. Checks for dereference of a null pointer.

This class is completely inlined.

typical usage:

{
  Box b;
  IntVect a;
  //refCount() == 1
  RefCountedPtr<IntVectSet> set(new IntVectSet());

  // still just one IntVectSet, but refCount()==2
  RefCountedPtr<IntVectSet>  otherSet(set);

  // Like a pointer, modifying one modifies the other
  otherSet->define(b);
  (*set)|=a;
  {
    RefCountedPtr<IntVectSet> anotherSet; // null
    anotherSet = otherSet ;  //now all three have refCount()==3
  }//anotherSet out of scope, so deleted.  IntVectSet NOT deleted.

  // set.refCount() == 2
  // otherSet.refCount() == 2;
  // otherset == set;

}
// when all RefCountedPtr's for a given object are deleted, the last
// one calls 'delete' on the member pointer.

Public Member Functions

 RefCountedPtr (T *ptr=0)
 RefCountedPtr (const RefCountedPtr< T > &other)
 ~RefCountedPtr ()
const RefCountedPtr< T > & operator= (const RefCountedPtr< T > &rhs)
 assignement operator. copies pointer member
T * operator-> ()
 dereference access operator. use like a pointer derefence access function.
const T * operator-> () const
bool isNull () const
T & operator* ()
 pointer dereference.
const T & operator* () const
 operator const T * () const
 auto conversion to regular const pointer where required.
bool isNonUnique () const
 true when refcount is one.
int refCount () const
void swap (RefCountedPtr< T > &b)
template<class T2>
 operator RefCountedPtr< T2 > ()
 Template Conversion.
void neverDelete ()
void increment ()
void decrement ()

Static Public Member Functions

static const std::string & name ()

Protected Attributes

T * ptr_
int * refCount_

Static Protected Attributes

static std::string name_
static BArena s_Arena
static int size_ = sizeof(T)+2*sizeof(int)

Friends

class RefCountedPtr

Constructor & Destructor Documentation

template<class T>
RefCountedPtr< T >::RefCountedPtr ( T *  ptr = 0  )  [inline, explicit]

template<class T>
RefCountedPtr< T >::RefCountedPtr ( const RefCountedPtr< T > &  other  )  [inline]

template<class T>
RefCountedPtr< T >::~RefCountedPtr (  )  [inline]


Member Function Documentation

template<class T>
const RefCountedPtr< T > & RefCountedPtr< T >::operator= ( const RefCountedPtr< T > &  rhs  )  [inline]

assignement operator. copies pointer member

copies pointer member and integer pointer, decreases refcount of rhs member before assignment. this refcount increased my one.

References RefCountedPtr< T >::decrement(), RefCountedPtr< T >::ptr_, and RefCountedPtr< T >::refCount_.

template<class T>
T * RefCountedPtr< T >::operator-> (  )  [inline]

dereference access operator. use like a pointer derefence access function.

References MayDay::Error(), and RefCountedPtr< T >::ptr_.

template<class T>
const T * RefCountedPtr< T >::operator-> (  )  const [inline]

template<class T>
bool RefCountedPtr< T >::isNull (  )  const [inline]

template<class T>
T & RefCountedPtr< T >::operator* (  )  [inline]

pointer dereference.

References MayDay::Error(), and RefCountedPtr< T >::ptr_.

template<class T>
const T & RefCountedPtr< T >::operator* (  )  const [inline]

template<class T>
RefCountedPtr< T >::operator const T * (  )  const [inline]

auto conversion to regular const pointer where required.

References RefCountedPtr< T >::ptr_.

template<class T>
bool RefCountedPtr< T >::isNonUnique (  )  const [inline]

true when refcount is one.

References RefCountedPtr< T >::refCount_.

template<class T>
int RefCountedPtr< T >::refCount (  )  const [inline]

template<class T>
void RefCountedPtr< T >::swap ( RefCountedPtr< T > &  b  )  [inline]

template<class T>
template<class T2>
RefCountedPtr< T >::operator RefCountedPtr< T2 > (  )  [inline]

Template Conversion.

provides a mechanism for the compiler to generate a conversion to a base class, like a real pointer would have

References CH_assert, RefCountedPtr< T >::ptr_, RefCountedPtr< T >::refCount_, and RefCountedPtr< T >::s_Arena.

template<class T>
void RefCountedPtr< T >::neverDelete (  )  [inline]

template<class T>
static const std::string& RefCountedPtr< T >::name (  )  [inline, static]

template<class T>
void RefCountedPtr< T >::increment (  )  [inline]

template<class T>
void RefCountedPtr< T >::decrement (  )  [inline]


Friends And Related Function Documentation

template<class T>
friend class RefCountedPtr [friend]


Member Data Documentation

template<class T>
T* RefCountedPtr< T >::ptr_ [protected]

template<class T>
int* RefCountedPtr< T >::refCount_ [protected]

template<class T>
std::string RefCountedPtr< T >::name_ [inline, static, protected]

template<class T>
BArena RefCountedPtr< T >::s_Arena [inline, static, protected]

template<class T>
int RefCountedPtr< T >::size_ = sizeof(T)+2*sizeof(int) [inline, static, protected]


The documentation for this class was generated from the following file:

Generated on Sun May 28 03:43:10 2017 for Chombo + EB by  doxygen 1.5.5