RCObject.h

Go to the documentation of this file.

#ifndef CLASSIC_RCObject_HH
#define CLASSIC_RCObject_HH

// ------------------------------------------------------------------------
// $RCSfile: RCObject.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: RCObject
//
// ------------------------------------------------------------------------
// Class category: MemoryManagement
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:37 $
// $Author: fci $
//
// ------------------------------------------------------------------------


// Class RCObject
// ------------------------------------------------------------------------
//  It collaborates with the templace class Pointer<Object>.
//  It is modelled after the class RCObject described in:
//  {center}
//  Scott Meyers, More Effective C++, Addison Wesley, 1996, pg. 195.
//  {/center}
//  The idiom [tt]delete this[/tt] has been avoided by moving the deletion
//  to class Pointer<Object>.
//  All derived classes must implement a clone() method, to allow the
//  Pointer class to copy the object pointed at.
//  All constructors, the destructor, and the assignment operators are
//  protected, since a stand-alone RCObject makes no sense.

//#include <Ippl.h>


class RCObject {

public:

    //  Return the new value of the reference count.
    int addReference() const;

    //  Return the new value of the reference count.
    int removeReference() const;

    //  Return true, if the pointee has more than one reference.
    bool isShared() const;


protected:

    //  By default a new object is sharable.
    RCObject();

    //  The copy inherits the sharable state.
    RCObject(const RCObject &);

    // Destructor is pure, but implemented, to make class abstract.
    virtual ~RCObject() = 0;

    RCObject &operator=(const RCObject &right);

private:

    // The object's reference count.
    // The value is mutable, since it is not really part of the objects state.
    mutable int refCount;
};


// Inline functions for class RCObject
// ------------------------------------------------------------------------

inline int RCObject::addReference() const {
    return ++refCount;
}


inline int RCObject::removeReference() const {
    return --refCount;
}


inline bool RCObject::isShared() const {
    return refCount > 1;
}


inline RCObject::RCObject():
    refCount(0)
{}


inline RCObject::RCObject(const RCObject &/*rhs*/):
    refCount(0)
{}


inline RCObject::~RCObject()
{}


inline RCObject &RCObject::operator=(const RCObject &/*rhs*/) {
    return *this;
}

#endif // CLASSIC_RCObject_HH