smartpointer.h

/*

  MusicXML Library
  Copyright (C) 2003  Grame

  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
  grame@grame.fr

*/

#ifndef __smartpointer__
#define __smartpointer__

#include <cassert>
#include "exports.h"

class EXP smartable {
    private:
        unsigned    refCount;       
    public:
        unsigned refs() const         { return refCount; }
        void addReference()           { refCount++; assert(refCount != 0); }
        void removeReference();
        
    protected:
        smartable() : refCount(0) {}
        smartable(const smartable&): refCount(0) {}
        virtual ~smartable()    { assert (refCount == 0); }
        smartable& operator=(const smartable&) { return *this; }
};

template<class T> class EXP SMARTP {
    private:
        T* fSmartPtr;

    public:
        SMARTP()    : fSmartPtr(0) {}
        SMARTP(T* rawptr) : fSmartPtr(rawptr)              { if (fSmartPtr) fSmartPtr->addReference(); }
        template<class T2> 
        SMARTP(const SMARTP<T2>& ptr) : fSmartPtr((T*)ptr) { if (fSmartPtr) fSmartPtr->addReference(); }
        SMARTP(const SMARTP& ptr) : fSmartPtr((T*)ptr)     { if (fSmartPtr) fSmartPtr->addReference(); }

        ~SMARTP()  { if (fSmartPtr) fSmartPtr->removeReference(); }
        
        operator T*() const  { return fSmartPtr;    }

        T& operator*() const {
            // checks for null dereference
            assert (fSmartPtr != 0);
            return *fSmartPtr;
        }

        T* operator->() const   { 
            // checks for null dereference
            assert (fSmartPtr != 0);
            return fSmartPtr;
        }

        template <class T2>
        SMARTP& operator=(T2 p1_)   { *this=(T*)p1_; return *this; }

        SMARTP& operator=(T* p_)    {
            // check first that pointers differ
            if (fSmartPtr != p_) {
                // increments the ref count of the new pointer if not null
                if (p_ != 0) p_->addReference();
                // decrements the ref count of the old pointer if not null
                if (fSmartPtr != 0) fSmartPtr->removeReference();
                // and finally stores the new actual pointer
                fSmartPtr = p_;
            }
            return *this;
        }
        SMARTP& operator=(const SMARTP<T>& p_)                { return operator=((T *) p_); }
        template<class T2> SMARTP& cast(T2* p_)               { return operator=(dynamic_cast<T*>(p_)); }
        template<class T2> SMARTP& cast(const SMARTP<T2>& p_) { return operator=(dynamic_cast<T*>(p_)); }
};


#endif

---