--- /dev/null
+/*
+
+ Copyright (C) 2011 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
+ research@grame.fr
+
+*/
+
+#ifndef __smartpointer__
+#define __smartpointer__
+
+#include <cassert>
+
+namespace oscfaust
+{
+
+/*!
+\brief the base class for smart pointers implementation
+
+ Any object that want to support smart pointers should
+ inherit from the smartable class which provides reference counting
+ and automatic delete when the reference count drops to zero.
+*/
+class smartable {
+ private:
+ unsigned refCount;
+ public:
+ //! gives the reference count of the object
+ unsigned refs() const { return refCount; }
+ //! addReference increments the ref count and checks for refCount overflow
+ void addReference() { refCount++; assert(refCount != 0); }
+ //! removeReference delete the object when refCount is zero
+ void removeReference() { if (--refCount == 0) delete this; }
+
+ protected:
+ smartable() : refCount(0) {}
+ smartable(const smartable&): refCount(0) {}
+ //! destructor checks for non-zero refCount
+ virtual ~smartable() { assert (refCount == 0); }
+ smartable& operator=(const smartable&) { return *this; }
+};
+
+/*!
+\brief the smart pointer implementation
+
+ A smart pointer is in charge of maintaining the objects reference count
+ by the way of pointers operators overloading. It supports class
+ inheritance and conversion whenever possible.
+\n Instances of the SMARTP class are supposed to use \e smartable types (or at least
+ objects that implements the \e addReference and \e removeReference
+ methods in a consistent way).
+*/
+template<class T> class SMARTP {
+ private:
+ //! the actual pointer to the class
+ T* fSmartPtr;
+
+ public:
+ //! an empty constructor - points to null
+ SMARTP() : fSmartPtr(0) {}
+ //! build a smart pointer from a class pointer
+ SMARTP(T* rawptr) : fSmartPtr(rawptr) { if (fSmartPtr) fSmartPtr->addReference(); }
+ //! build a smart pointer from an convertible class reference
+ template<class T2>
+ SMARTP(const SMARTP<T2>& ptr) : fSmartPtr((T*)ptr) { if (fSmartPtr) fSmartPtr->addReference(); }
+ //! build a smart pointer from another smart pointer reference
+ SMARTP(const SMARTP& ptr) : fSmartPtr((T*)ptr) { if (fSmartPtr) fSmartPtr->addReference(); }
+
+ //! the smart pointer destructor: simply removes one reference count
+ ~SMARTP() { if (fSmartPtr) fSmartPtr->removeReference(); }
+
+ //! cast operator to retrieve the actual class pointer
+ operator T*() const { return fSmartPtr; }
+
+ //! '*' operator to access the actual class pointer
+ T& operator*() const {
+ // checks for null dereference
+ assert (fSmartPtr != 0);
+ return *fSmartPtr;
+ }
+
+ //! operator -> overloading to access the actual class pointer
+ T* operator->() const {
+ // checks for null dereference
+ assert (fSmartPtr != 0);
+ return fSmartPtr;
+ }
+
+ //! operator = that moves the actual class pointer
+ template <class T2>
+ SMARTP& operator=(T2 p1_) { *this=(T*)p1_; return *this; }
+
+ //! operator = that moves the actual class pointer
+ 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;
+ }
+ //! operator < to support SMARTP map with Visual C++
+ bool operator<(const SMARTP<T>& p_) const { return fSmartPtr < ((T *) p_); }
+ //! operator = to support inherited class reference
+ SMARTP& operator=(const SMARTP<T>& p_) { return operator=((T *) p_); }
+ //! dynamic cast support
+ template<class T2> SMARTP& cast(T2* p_) { return operator=(dynamic_cast<T*>(p_)); }
+ //! dynamic cast support
+ template<class T2> SMARTP& cast(const SMARTP<T2>& p_) { return operator=(dynamic_cast<T*>(p_)); }
+};
+
+}
+
+#endif
projects / Faustine.git / blobdiff