rptr.h

/* -*- c++ -*- */
/*
 * A reference-counting smart pointer template class for C++ 
 *
 * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  
 */

#ifndef RPTR_RPTR_HDR
#define RPTR_RPTR_HDR

#include "debug.h"

namespace rptr {

  struct Rptr_ReferenceCounter {
    inline void Attach() { 
      ++counter; 
    }
    template<class T>
    inline void Detach(T *p) { 
      if(--counter==0) { 
        if(owner) {
          delete p; 
        }
        delete this;
      } 
    }
    inline Rptr_ReferenceCounter(bool owner0):
      owner(owner0), counter(0) {}

    bool owner;
  private:
    unsigned counter;
  };


  template<class T>
  class Rptr {
    Rptr_ReferenceCounter *refcounter;
    T *data;

    template<class TT>
    inline static void Dummy(TT * const &) {}

  public:
    template<class TT> friend class Rptr;


    inline Rptr():
      refcounter(0),
      data(0)
    {
    }
    inline Rptr(const Rptr &src): 
      refcounter(src.refcounter),
      data(src.data)
    { 
      if(refcounter) {
        refcounter->Attach(); 
      }
    }
    inline Rptr(T *data0, bool owner0=true):
      refcounter(0),
      data(data0)
    { 
      if(data) {
        refcounter = new Rptr_ReferenceCounter(owner0);
        refcounter->Attach(); 
      }
    }
    inline Rptr & Set(T *src, bool owner0=true) 
    {
      if(refcounter) {
        refcounter->Detach(data);
      }
      refcounter = 0;
      data = src;
      if(data) {
        refcounter = new Rptr_ReferenceCounter(owner0);
        refcounter->Attach();
      }
      return *this;
    }
    inline ~Rptr() 
    {
      if(refcounter) {
        refcounter->Detach(data); 
      }
    }



    inline T & operator *() const { 
      RPTR_DEBUG_CHECK_NULL(data);
      return *data; 
    }
    inline T * operator ->() const { 
      RPTR_DEBUG_CHECK_NULL(data);
      return data; 
    }
    template<class TT>
    inline operator const Rptr<TT> & () const { 
      Dummy<TT>(data); /* Check that corresponding built-in pointer conversion
                        * is allowed */
      return reinterpret_cast<const Rptr<TT> &>(*this);
    }
    inline T * Ptr() const { 
      return data; 
    }
    inline bool IsOwner() const { 
      return refcounter && refcounter->owner;
    }
    inline T * Drop() const { 
      if(refcounter) {
        refcounter->owner = false;
      }
      return data;
    }
    inline bool operator ==(const Rptr &rhs) const { 
      return data == rhs.data; 
    }
    inline bool operator ==(const T *rhs) const { 
      return data == rhs;
    }
    inline bool operator !=(const Rptr &rhs) const { 
      return data != rhs.data;
    }
    inline bool operator !=(const T *rhs) const { 
      return data != rhs; 
    }



    inline Rptr & operator =(const Rptr &src) {
      Rptr_ReferenceCounter *tmp = refcounter; // Self-assignment is safe!
      T *tmpdata = data;
      data=src.data;
      refcounter=src.refcounter;
      if(refcounter) {
        refcounter->Attach();
      }
      if(tmp) {
        tmp->Detach(tmpdata);
      }
      return *this;
    }

    inline Rptr & operator =(T *src) { 
      return Set(src,true); 
    }

    template<class TT>
    inline Rptr & DynamicCast(const Rptr<TT> &src) {
      Rptr_ReferenceCounter *tmp=refcounter;
      T *tmpdata = data;
      refcounter = 0;
      data=dynamic_cast<T *>(src.data);
      if(data) {
        refcounter = src.refcounter;
        refcounter->Attach();
      }
      if(tmp) {
        tmp->Detach(tmpdata);
      }
      return *this;
    }
    template<class TT>
    inline Rptr & StaticCast(const Rptr<TT> &src) {
      Rptr_ReferenceCounter *tmp=refcounter;
      T *tmpdata = data;
      refcounter = 0;
      data=static_cast<T *>(src.data);
      if(data) {
        refcounter = src.refcounter;
        refcounter->Attach();
      }
      if(tmp) {
        tmp->Detach(tmpdata);
      }
      return *this;
    }
  };

}
#endif

---