RCObject.h

Go to the documentation of this file.

// 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 throw();

    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() throw() { }
  }; // 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__ */