RCObject.h

// This file is part of the "NcML Module" project, a BES module designed
// to allow NcML files to be used to be used as a wrapper to add
// AIS to existing datasets of any format.
//
// Copyright (c) 2009 OPeNDAP, Inc.
// Author: Michael Johnson  <m.johnson@opendap.org>
//
// For more information, please also see the main website: http://opendap.org/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// Please see the files COPYING and COPYRIGHT for more information on the GLPL.
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#ifndef __AGG_UTIL__REF_COUNTED_OBJECT_H__
#define __AGG_UTIL__REF_COUNTED_OBJECT_H__
 
#include "RCObjectInterface.h" // interface super
 
#include <list>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace agg_util {
class RCOBjectPool;
class RCObject;
 
typedef std::set<RCObject*> RCObjectSet;

class RCObjectPool {
    friend class RCObject;
 
public:
    RCObjectPool();

    virtual ~RCObjectPool();

    bool contains(RCObject* pObj) const;

    void add(RCObject* pObj);

    void remove(RCObject* pObj)
    {
        release(pObj, false);
    }

    void release(RCObject* pObj, bool shouldDelete = true);
 
protected:
    void deleteAllObjects();
 
private:
 
    // A set of the live, monitored objects.
    // Lookups are log(N) and entries unique, as required.
    // All entries in this list will be delete'd in the dtor.
    RCObjectSet _liveObjects;
};
// class RCObjectPool

class UseCountHitZeroCB {
public:
    UseCountHitZeroCB()
    {
    }
    virtual ~UseCountHitZeroCB()
    {
    }
    virtual void executeUseCountHitZeroCB(RCObject* pAboutToDie) = 0;
};

class RCObject: public virtual RCObjectInterface // abstract interface
{
    friend class RCObjectPool;
 
    typedef std::list<UseCountHitZeroCB*> PreDeleteCBList;
 
private:
    RCObject& operator=(const RCObject& rhs); //disallow
 
public:

    RCObject(RCObjectPool* pool = 0);

    RCObject(const RCObject& proto);
 
    virtual ~RCObject();

    virtual int ref() const;

    virtual int unref() const;

    virtual int getRefCount() const;

    virtual void removeFromPool() const;

    virtual std::string toString() const;
 
public:
    // to workaround template friend issues.  Not designed for public consumption.

    void addPreDeleteCB(UseCountHitZeroCB* pCB);

    void removePreDeleteCB(UseCountHitZeroCB* pCB);
 
private:
    // interface

    std::string printRCObject() const;

    void executeAndClearPreDeleteCallbacks();
 
private:
    // data rep
 
    // The reference count... mutable since we want to ref count const objects as well,
    // and the count doesn't affect the semantic constness of the subclasses.
    mutable int _count;
 
    // If not null, the object is from the given pool and should be release()'d to the
    // pool when count hits 0, not deleted.  If null, it can be deleted.
    RCObjectPool* _pool;
 
    // Callback list for when the use count hits 0 but before deallocate
    PreDeleteCBList _preDeleteCallbacks;
 
};
// class RCObject

template<class T>
class RCPtr {
public:
    RCPtr(T* pRef = 0) :
        _obj(pRef)
    {
        init();
    }
 
    RCPtr(const RCPtr& from) :
        _obj(from._obj)
    {
        init();
    }
 
    ~RCPtr()
    {
        if (_obj) {
            _obj->unref();
            _obj = 0;
        }
    }
 
    RCPtr&
    operator=(const RCPtr& rhs)
    {
        if (rhs._obj != _obj) {
            RCObject* oldObj = _obj;
            _obj = rhs._obj;
            init();
            if (oldObj) {
                oldObj->unref();
            }
        }
        return *this;
    }
 
    T&
    operator*() const
    {
        // caller is on their own if they deref this as null,
        // so should check with get() first.
        return *_obj;
    }
 
    T*
    operator->() const
    {
        return _obj;
    }
 
    T*
    get() const
    {
        return _obj;
    }

    T*
    refAndGet() const
    {
        if (_obj) {
            _obj->ref();
        }
        return _obj;
    }
 
private:
    void init()
    {
        if (_obj) {
            _obj->ref();
        }
    }
 
private:
    T* _obj;
};
// class RCPtr<T>

class BadWeakPtr: public std::runtime_error {
public:
    BadWeakPtr(const std::string& msg) :
        std::runtime_error(msg)
    {
    }
 
    virtual ~BadWeakPtr() noexcept
    {
    }
};
// class         BadWeakPtr

template<class T>
class WeakRCPtr: public UseCountHitZeroCB // can we private inherit this to avoid outside callers?
{
 
public:

    WeakRCPtr() :
        _pObj(0)
    {
    }
 
    explicit WeakRCPtr(RCPtr<T> src)
    {
        // Connect to the shared ptr by adding listener and storing raw.
        _pObj = src.get();
        addMeAsListener();
    }
 
    ~WeakRCPtr()
    {
        clear();
    }
 
    WeakRCPtr& operator=(const WeakRCPtr& r)
    {
        if (&r != this) {
            clear();
            _pObj = r._pObj;
            addMeAsListener();
        }
        return *this;
    }

    bool expired() const
    {
        return empty();
    }

    bool empty() const
    {
        return (!_pObj);
    }
 
    RCPtr<T> lock() const
    {
        // return a safe shared ptr to the wrapped resource
        // which will up it's count properly
        if (_pObj) {
            return RCPtr<T>(_pObj);
        }
        else {
            return RCPtr<T>(NULL);
        }
    }

    void clear()
    {
        // Remove the listener, clear the ptr so it's like default ctor.
        removeMeAsListener();
        _pObj = NULL;
    }
 
public:
    // to avoid template friend issues, but not for public use!

    virtual void executeUseCountHitZeroCB(RCObject* pAboutToDie)
    {
        if (pAboutToDie != _pObj) {
            throw BadWeakPtr("executeUseCountHitZeroCB() called with mismatched raw pointers!");
        }
        clear();
    }

private:
 
    void removeMeAsListener()
    {
        if (_pObj) {
            _pObj->removePreDeleteCB(this);
        }
    }
 
    void addMeAsListener()
    {
        if (_pObj) {
            _pObj->addPreDeleteCB(this);
        }
    }
 
private:
    // data rep
 
    // The underlying wrapped object, or NULL if uninit or expired.
    // NOTE: MUST be a subclass of RCObject
    T* _pObj;
 
};
// class WeakRCPtr<T>
 
}// namespace agg_util
 
#endif /* __AGG_UTIL__REF_COUNTED_OBJECT_H__ */