Release-1.4.7-20060910

1 files changed, 165 insertions, 0 deletions

diff --git a/src/lockingptr.h b/src/lockingptr.h
new file mode 100644
index 0000000..e981056
--- /dev/null
+++ b/src/lockingptr.h
@@ -0,0 +1,165 @@
+/******************************************************************************
+ *
+ * 
+ *
+ * Copyright (C) 1997-2006 by Dimitri van Heesch.
+ *
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation under the terms of the GNU General Public License is hereby 
+ * granted. No representations are made about the suitability of this software 
+ * for any purpose. It is provided "as is" without express or implied warranty.
+ * See the GNU General Public License for more details.
+ *
+ * Documents produced by Doxygen are derivative works derived from the
+ * input used in their production; they are not affected by this license.
+ *
+ */
+
+#ifndef LOCKINGPTR_H
+#define LOCKINGPTR_H
+
+/*! @brief Abstract interface for lockable objects.
+ *
+ *  By implementing this interface, a smart pointer can be created which
+ *  will lock this object. This is used to prevent that an internal pointer
+ *  owned by a lockable object would become invalid when the object is removed from 
+ *  memory, leaving the client with an invalid pointer. By letting the client use 
+ *  a smart pointer instead of the real object the object will be locked into
+ *  memory until the pointer is no longer used, at which point the owner object will be
+ *  unlock and can be removed from memory.
+ */
+class LockableObj
+{
+  public:
+    LockableObj() : m_lockCount(0) {}
+    virtual ~LockableObj() {}
+
+    /*! Returns TRUE if the object is currently locked. */
+    bool isLocked() const { return m_lockCount>0; }
+
+#ifndef _WIN32
+  protected:
+#endif
+    /*! Called when the object is locked. */
+    virtual void lock() const = 0;
+
+    /*! Called when the object is unlocked. */
+    virtual void unlock() const = 0;
+
+#ifndef _WIN32 // HACK: VC++ 6.0 does not understand friend template classes.
+  private:
+    template<class T> friend class LockingPtr;
+#endif
+
+    int  m_lockCount;
+};
+
+/*! @brief Smart pointer which keeps a lock on the owner of the pointer.
+ *
+ *  With the pointer an owner object derived from LockableObj is associated.
+ *  As long as the smart object exists it will keep a lock on the obj by calling 
+ *  LockableObj::lock(). Smart pointers can be copied and passed by value. As 
+ *  soon as there or no more smart pointer references to the object, 
+ *  LockableObj::unlock() will be called automatically.
+ */
+template<class T> class LockingPtr
+{
+    LockableObj *m_owner;
+    const T *m_ptr;
+
+  public:
+    /*! Creates a smart pointer for pointer \a p owned by object \a o.
+     */
+    LockingPtr(const LockableObj *o,const T* p) 
+    { 
+      if (o->m_lockCount==0) o->lock(); 
+      m_owner = (LockableObj *)o;
+      m_owner->m_lockCount++;
+      m_ptr = p;
+    }
+    
+    /*! Copies the smart pointer \a lp 
+     */
+    LockingPtr(const LockingPtr &lp)
+    {
+      m_ptr   = lp.m_ptr;
+      m_owner = lp.m_owner;
+      m_owner->m_lockCount++;
+    }
+
+    /*! Assigns the smart pointer \a lp 
+     */
+    LockingPtr &operator=(const LockingPtr &lp)
+    {
+      m_owner->m_lockCount--;
+      if (m_owner->m_lockCount==0) // no more references
+      {
+        m_owner->unlock(); 
+      }
+      m_ptr   = lp.m_ptr;
+      m_owner = lp.m_owner;
+      m_owner->m_lockCount++;
+      return *this;
+    }
+
+    /*! Destroys the smart pointer, will unlock the owner.
+     */
+    ~LockingPtr() 
+    { 
+      m_owner->m_lockCount--;
+      if (m_owner->m_lockCount==0) // no more references
+      {
+        m_owner->unlock(); 
+      }
+    }
+
+    bool isNull() const
+    {
+      return m_ptr==0;
+    }
+
+    bool operator!() const
+    {
+      return !m_ptr;
+    }
+
+    bool operator==(T *p) const
+    {
+      return m_ptr==p;
+    }
+
+    bool operator==(const LockingPtr &lp) const
+    {
+      return m_ptr==lp.m_ptr;
+    }
+
+    bool operator!=(T *p) const
+    {
+      return m_ptr!=p;
+    }
+
+    bool operator!=(const LockingPtr &lp) const
+    {
+      return m_ptr!=lp.m_ptr;
+    }
+
+    /*! Dereference operator */
+    const T& operator* () const
+    { 
+      return *m_ptr; 
+    }
+
+    T* pointer() const
+    {
+      return (T*)m_ptr;
+    }
+    
+    /*! Pointer operator */
+    T* operator-> () const
+    { 
+      return (T*)m_ptr; 
+    }
+};
+
+#endif // LOCKINGPTR_H
+