DGtal::CountedPtr< T > Class Template Reference

#include <DGtal/base/CountedPtr.h>

Inheritance diagram for DGtal::CountedPtr< T >:

Collaboration diagram for DGtal::CountedPtr< T >:

Data Structures
struct	Counter

Public Member Functions
	CountedPtr (T *p=0)
	~CountedPtr ()
	CountedPtr (const CountedPtr &r) noexcept
CountedPtr &	operator= (const CountedPtr &r)
T &	operator* () const noexcept
T *	operator-> () const noexcept
T *	get () const noexcept
bool	unique () const noexcept
bool	operator== (const T *other) const
bool	operator!= (const T *other) const
unsigned int	count () const
T *	drop ()
void	selfDisplay (std::ostream &out) const
bool	isValid () const

Private Member Functions
void	acquire (Counter *c) noexcept
void	release ()

Private Attributes
Counter *	myCounter

Friends
class	CountedPtrOrPtr< T >
class	CountedConstPtrOrConstPtr< T >

Detailed Description

template<typename T>
class DGtal::CountedPtr< T >

Aim: Smart pointer based on reference counts.

Description of template class 'CountedPtr'

It is a standard smart pointer by reference counts. Of course, only dynamically allocated objects may be pointed by a smart pointer. The CountedPtr<T> holds a pointer to a CountedPtr::Counter object. This Counter object holds the pointer to the dynamically allocated object and an integer representing the number of smart pointers currently pointing to this Counter.

struct A{};
CountedPtr<A> smart_p1( new A );
CountedPtr<A> smart_p2( new A );
smart_p2 = smart_p1;  // second object is freed, first object is now shared.

Template Parameters

T	any data type.

Taken from http://ootips.org/yonat/4dev/smart-pointers.html

Definition at line 79 of file CountedPtr.h.

Constructor & Destructor Documentation

template<typename T>

DGtal::CountedPtr< T >::CountedPtr ( T *  p = 0 )

inlineexplicit

Default Constructor and constructor from pointer.

Creates a new CountedPtr, either null if p is 0 or pointing to the given address p.

Parameters

p	either 0 or a pointer on a dynamically allocated object of type T.

Definition at line 119 of file CountedPtr.h.

                                  : myCounter(0) 
    { 
      if (p) myCounter = new Counter(p);
    }

template<typename T>

DGtal::CountedPtr< T >::~CountedPtr ( )

inline

Destructor. If it was the last CountedPtr pointing on the object, delete it.

Definition at line 128 of file CountedPtr.h.

    { 
      release(); 
    }

template<typename T>

DGtal::CountedPtr< T >::CountedPtr ( const CountedPtr< T > &  r )

inlinenoexcept

Copy Constructor.

Performs a smart copy. The CountedPtr only references the same object as r. There is now one more reference on the same object.

Parameters

r	the object to copy.

Definition at line 142 of file CountedPtr.h.

    {
      acquire(r.myCounter);
    }

Member Function Documentation

template<typename T>

void DGtal::CountedPtr< T >::acquire ( Counter *  c )

inlineprivatenoexcept

Tells this smart pointer that it should reference the counter c. If c is not null, the number of reference counts is incremented.

Parameters

c	any counter (except this.myCounter).

Definition at line 265 of file CountedPtr.h.

Referenced by DGtal::CountedPtr< Domain >::CountedPtr(), and DGtal::CountedPtr< Domain >::operator=().

    { // increment the count
        myCounter = c;
        if (c) ++c->count;
    }

template<typename T>

unsigned int DGtal::CountedPtr< T >::count ( ) const

inline

Note

For debug.

Returns

the number of smart pointers pointing to the same object as 'this'.

Definition at line 236 of file CountedPtr.h.

    {
      return myCounter->count;
    }

template<typename T>

T* DGtal::CountedPtr< T >::drop ( )

inline

Gives back the pointer without deleting him. Deletes only the Counter.

Returns

the address that was pointed by this smart pointer

Note

Use with care.

Precondition

'isValid()' and 'unique()'.

Definition at line 249 of file CountedPtr.h.

    { 
      ASSERT( isValid() );
      ASSERT( unique() );
      T* tmp = myCounter->ptr;
      delete myCounter;
      myCounter = 0; 
      return tmp;
    }

template<typename T>

T* DGtal::CountedPtr< T >::get ( ) const

inlinenoexcept

Secured member access operator.

Returns

a pointer on the object that is pointed by the smart pointer or 0 if the object is not valid ('isValid()' is false).

Definition at line 195 of file CountedPtr.h.

Referenced by DGtal::CowPtr< Domain >::copy(), DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator*(), DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator->(), and DGtal::GraphVisitorRange< TGraphVisitor >::GenericConstIterator< TAccessor >::operator==().

    {
      return myCounter ? myCounter->ptr : 0;
    }

template<typename T>

bool DGtal::CountedPtr< T >::isValid

(

)

const

Checks the validity/consistency of the object.

Returns

'true' if the object is valid, 'false' otherwise.

Referenced by DGtal::CountedPtr< Domain >::drop().

template<typename T>

bool DGtal::CountedPtr< T >::operator!= ( const T *  other ) const

inline

Inequality operator !=

Parameters

other

any other pointer.

Returns

'true' if 'this' points to a different address than other.

Definition at line 226 of file CountedPtr.h.

    {
      return get() != other;
    }

template<typename T>

T& DGtal::CountedPtr< T >::operator* ( ) const

inlinenoexcept

Dereferencing operator.

Returns

a reference on the object that is pointed by the smart pointer.

Precondition

'isValid()' is true

Definition at line 174 of file CountedPtr.h.

    {
      return *myCounter->ptr;
    }

template<typename T>

T* DGtal::CountedPtr< T >::operator-> ( ) const

inlinenoexcept

Member access operator.

Returns

a pointer on the object that is pointed by the smart pointer.

Precondition

'isValid()' is true

Definition at line 184 of file CountedPtr.h.

    {
      return myCounter->ptr;
    }

template<typename T>

CountedPtr& DGtal::CountedPtr< T >::operator= ( const CountedPtr< T > &  r )

inline

Assignment.

Performs a smart assignment. The current referenced object is dropped (and possibly freed if it was the last smart pointer pointing on it). Then, this CountedPtr only references the same object as r. There is now one more reference on the same object.

Parameters

r	the object to copy.

Returns

a reference on 'this'.

Definition at line 159 of file CountedPtr.h.

    {
      if (this != &r)
        {
          release();
          acquire(r.myCounter);
        }
      return *this;
    }

template<typename T>

bool DGtal::CountedPtr< T >::operator== ( const T *  other ) const

inline

Equality operator ==

Parameters

other

any other pointer.

Returns

'true' if 'this' points to other.

Definition at line 215 of file CountedPtr.h.

    {
      return get() == other;
    }

template<typename T>

void DGtal::CountedPtr< T >::release ( )

inlineprivate

Tells this smart pointer to that it should release its current counter. If this counter was shared then the number of reference counts is decremented, else both the object pointed by the counter and the counter are freed. In all cases, this smart pointer becomes invalid.

Definition at line 278 of file CountedPtr.h.

Referenced by DGtal::CountedPtr< Domain >::operator=(), and DGtal::CountedPtr< Domain >::~CountedPtr().

    { // decrement the count, delete if it is 0
        if (myCounter) {
            if (--myCounter->count == 0) {
                delete myCounter->ptr;
                delete myCounter;
            }
            myCounter = 0;
        }
    }

template<typename T>

void DGtal::CountedPtr< T >::selfDisplay

(

std::ostream &

out

)

const

Writes/Displays the object on an output stream.

Parameters

out	the output stream where the object is written.

template<typename T>

bool DGtal::CountedPtr< T >::unique ( ) const

inlinenoexcept

Returns

'true' iff the smart pointer is the sole one pointing on this object or if the smart pointer is invalid ('isValid()' is false).

Definition at line 204 of file CountedPtr.h.

Referenced by DGtal::CowPtr< Domain >::copy(), and DGtal::CountedPtr< Domain >::drop().

    {
      return (myCounter ? myCounter->count == 1 : true);
    }

Friends And Related Function Documentation

template<typename T>

friend class CountedConstPtrOrConstPtr< T >

friend

Friend class which needs to access to CountedPtr.myCounter.

Definition at line 86 of file CountedPtr.h.

template<typename T>

friend class CountedPtrOrPtr< T >

friend

Friend class which needs to access to CountedPtr.myCounter.

Definition at line 84 of file CountedPtr.h.

Field Documentation

template<typename T>

Counter* DGtal::CountedPtr< T >::myCounter

private

The counter object pointed by this smart pointer.

Definition at line 308 of file CountedPtr.h.

Referenced by DGtal::CountedPtr< Domain >::acquire(), DGtal::CountedPtr< Domain >::count(), DGtal::CountedPtr< Domain >::CountedPtr(), DGtal::CountedPtr< Domain >::drop(), DGtal::CountedPtr< Domain >::get(), DGtal::CountedPtr< Domain >::operator*(), DGtal::CountedPtr< Domain >::operator->(), DGtal::CountedPtr< Domain >::operator=(), DGtal::CountedPtrOrPtr< DummyTbl >::operator=(), DGtal::CountedConstPtrOrConstPtr< Shape >::operator=(), DGtal::CountedPtr< Domain >::release(), and DGtal::CountedPtr< Domain >::unique().

---

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

• CountedPtr.h