Reference_Counted_Pointer.hh

Go to the documentation of this file.

/*  Reference_Counted_Pointer

PIRL CVS ID: $Id: Reference_Counted_Pointer.hh,v 1.22 2010/10/19 02:30:51 castalia Exp $

Copyright (C) 2009-2010  Arizona Board of Regents on behalf of the
Planetary Image Research Laboratory, Lunar and Planetary Laboratory at
the University of Arizona.

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License, version 2.1,
as published by the Free Software Foundation.

This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.


This implementation is based on the CountedPtr class in "The C++ Standard
Library", by Nicolai M. Josuttis.

*******************************************************************************/

#ifndef _Reference_Counted_Pointer_
#define _Reference_Counted_Pointer_


#if defined (DEBUG)
//  DEBUG controls.
#define DEBUG_ALL       -1
#define DEBUG_RCP       (1 << 14)

//  Default DEBUG value
#if (DEBUG +0 == DEBUG_RCP)
#define RCP_DEBUG DEBUG_RCP
#endif
#if (DEBUG +0 == DEBUG_ALL)
#define RCP_DEBUG -1
#endif

#include    <iostream>
#include    <iomanip>
using std::clog;
using std::endl;
#endif  //  DEBUG


namespace PIRL
{
template <class T>
class Reference_Counted_Pointer
{
private:
T
    *Pointer;
long
    *Counter;


public:

explicit Reference_Counted_Pointer (T* pointer = 0)
    :   Pointer (pointer),
        Counter (new long (1))
{
#ifdef RCP_DEBUG
clog << ">-< Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ") Constructed from pointer" << endl;
#endif
}

Reference_Counted_Pointer (const Reference_Counted_Pointer<T>& RCP)
    :   Pointer (RCP.Pointer),
        Counter (RCP.Counter)
{
++*Counter;
#ifdef RCP_DEBUG
clog << ">-< Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ") Copy of RCP @ " << (void*)&RCP << endl;
#endif
}

~Reference_Counted_Pointer ()
{dispose ();}

Reference_Counted_Pointer<T>& operator=
    (const Reference_Counted_Pointer<T>& RCP)
{
#ifdef RCP_DEBUG
clog << ">>> Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ")::operator= (RCP& @ " << (void*)&RCP
        << " (@" << (void*)RCP.Pointer << '#' << *RCP.Counter << "))" << endl;
#endif
if (this != &RCP)
    {
    if (Pointer != RCP.Pointer)
        {
        //  New reference object.
        #ifdef RCP_DEBUG
        clog << "    normal assignment" << endl;
        #endif
        dispose ();
        Pointer = RCP.Pointer;
        }
    else
    if (Counter != RCP.Counter)
        {
        /*
            Special case: Same reference object but different counter.

            Join with the other RCP by using its counter,
            but don't dispose of the Pointer; the reference object is
            not to be deleted even if this RCP Counter decrements to zero.
        */
        if (--*Counter == 0)
            delete Counter;
        #ifdef RCP_DEBUG
        clog << "    same Pointer, different Counters!" << endl;
        #endif
        }
    Counter = RCP.Counter;
    ++*Counter;
    #ifdef RCP_DEBUG
    clog << "    Counter = " << *Counter << endl;
    #endif
    }
#ifdef RCP_DEBUG
clog << "<<< Reference_Counted_Pointer operator= (RCP&)" << endl;
#endif
return *this;
}

Reference_Counted_Pointer<T>& operator= (T* pointer)
{
#ifdef RCP_DEBUG
clog << ">>> Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ")::operator= (T* " << (void*)pointer << ")" << endl;
#endif
if (Pointer != pointer)
    {
    dispose ();
    Pointer = pointer;
    Counter = new long (1);
    #ifdef RCP_DEBUG
    clog << "    reset Pointer and Counter" << endl;
    #endif
    }
#ifdef RCP_DEBUG
else
    clog << "    same Pointer" << endl;
clog << "<<< Reference_Counted_Pointer::operator= (T*)" << endl;
#endif
return *this;
}

T& operator* () const
{
#if defined (RCP_DEBUG) && (RCP_DEBUG == DEBUG_ALL)
clog << ">-< Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ")::operator*" << endl;
#endif
return *Pointer;
}

T* operator-> () const
{
#if defined (RCP_DEBUG) && (RCP_DEBUG == DEBUG_ALL)
clog << ">-< Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter
        << ")::operator->" << endl;
#endif
return Pointer;
}

operator T* () const
{return Pointer;}

operator bool () const
{return Pointer != 0;}


bool operator== (const Reference_Counted_Pointer& RCP) const
{return Pointer == RCP.Pointer;}


bool operator!= (const Reference_Counted_Pointer& RCP) const
{return Pointer != RCP.Pointer;}

bool is_distinct_from (const Reference_Counted_Pointer& RCP) const
{return Pointer != RCP.Pointer || Counter != RCP.Counter;}


long reference_count () const
{return *Counter;}


protected:
void dispose ()
{
#ifdef RCP_DEBUG
clog << ">-< Reference_Counted_Pointer @ " << (void*)this
        << " (@" << (void*)Pointer << '#' << *Counter << ")::dispose" << endl;
#endif
if (--*Counter == 0)
    {
    delete Counter;
    if (Pointer)
        {
        #ifdef RCP_DEBUG
        clog << "    delete object @ " << (void*)Pointer << endl;
        #endif
        delete Pointer;
        Pointer = 0;
        }
    }
}
};  //  End of class Reference_Counted_Pointer


}   //  namespace PIRL
#endif  //  _Reference_Counted_Pointer_