projects / synfig.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Use etl::mutexes to lock access to reference counts.
[synfig.git] / ETL / trunk / ETL / _handle.h
diff --git a/ETL/trunk/ETL/_handle.h b/ETL/trunk/ETL/_handle.h
index 13af09b..862c914 100644 (file)
--- a/ETL/trunk/ETL/_handle.h
+++ b/ETL/trunk/ETL/_handle.h
@@ -6,6 +6,7 @@
 **
 **     \legal
 **     Copyright (c) 2002 Robert B. Quattlebaum Jr.
+**     Copyright (c) 2007 Chris Moore
 **
 **     This package is free software; you can redistribute it and/or
 **     modify it under the terms of the GNU General Public License as
@@ -35,8 +36,9 @@
 #define ETL_LOCK_REFCOUNTS
 
 #include <cassert>
+
 #ifdef ETL_LOCK_REFCOUNTS
-#include <synfig/mutex.h>
+#  include "_mutex_simple.h"
 #endif
 
 /* === M A C R O S ========================================================= */
@@ -73,7 +75,7 @@ class shared_object
 private:
        mutable int refcount;
 #ifdef ETL_LOCK_REFCOUNTS
-       mutable synfig::Mutex mutex;
+       mutable etl::mutex mtx;
 #endif
 
 protected:
@@ -89,42 +91,41 @@ public:
        void ref()const
        {
 #ifdef ETL_LOCK_REFCOUNTS
-               synfig::Mutex::Lock lock(mutex);
+               etl::mutex::lock lock(mtx);
 #endif
-               assert(refcount>=0); refcount++;
+               assert(refcount>=0);
+               refcount++;
        }
 
        //! Returns \c false if object needs to be deleted
        bool unref()const
        {
+               bool ret = true;
+               {
 #ifdef ETL_LOCK_REFCOUNTS
-               synfig::Mutex::Lock lock(mutex);
+                       etl::mutex::lock lock(mtx);
 #endif
-               assert(refcount>0);
+                       assert(refcount>0);
 
-               refcount--;
+                       refcount--;
 
-               if(refcount==0) {
+                       if(refcount==0) {
+                               ret = false;
 #ifdef ETL_SELF_DELETING_SHARED_OBJECT
-                       refcount=-666;
-#ifdef ETL_LOCK_REFCOUNTS
-                       mutex.unlock();
-#endif
-                       delete this;
+                               refcount=-666;
 #endif
-                       return false;
+                       }
                }
 
-               return true;
-       }
-
-       int count()const
-       { 
-#ifdef ETL_LOCK_REFCOUNTS
-               synfig::Mutex::Lock lock(mutex);
+#ifdef ETL_SELF_DELETING_SHARED_OBJECT
+               if (!ret)
+                       delete this;
 #endif
-               return refcount;
+               return ret;
        }
+
+       int count()const { return refcount; }
+
 }; // END of class shared_object
 
 // ========================================================================
@@ -165,6 +166,9 @@ public:
        typedef int size_type;
 
 protected:
+#ifdef _DEBUG
+public:
+#endif
        value_type *obj;                //!< Pointer to object
 
 public:
@@ -289,41 +293,29 @@ public:
        operator handle<const value_type>()const
        { return handle<const value_type>(static_cast<const_pointer>(obj)); }
 
-
        //! <tt> static_cast\<\> </tt> wrapper
-       template <class U> static
-       handle<T> cast_static(const handle<U> &x)
-       { return handle<T>(static_cast<T*>(x.get())); }
-
+       template <class U> static handle<T> cast_static         (const handle<U> &x) { return handle<T>(static_cast             <T*>(x.get())); }
        //! <tt> dynamic_cast\<\> </tt> wrapper
-       template <class U> static
-       handle<T> cast_dynamic(const handle<U> &x)
-       { return handle<T>(dynamic_cast<T*>(x.get())); }
-
+       template <class U> static handle<T> cast_dynamic        (const handle<U> &x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
        //! <tt> const_cast\<\> </tt> wrapper
-       template <class U> static
-       handle<T> cast_const(const handle<U> &x)
-       { return handle<T>(const_cast<T*>(x.get())); }
-
+       template <class U> static handle<T> cast_const          (const handle<U> &x) { return handle<T>(const_cast              <T*>(x.get())); }
        //! <tt> reinterpret_cast\<\> </tt> wrapper
-       template <class U> static
-       handle<T> cast_reinterpret(const handle<U> &x)
-       { return handle<T>(reinterpret_cast<T*>(x.get())); }
+       template <class U> static handle<T> cast_reinterpret(const handle<U> &x) { return handle<T>(reinterpret_cast<T*>(x.get())); }
 
-       template<class U> static handle<T> cast_static(const loose_handle<U> &x);
-       template<class U> static handle<T> cast_dynamic(const loose_handle<U> &x);
-       template<class U> static handle<T> cast_const(const loose_handle<U> &x);
-       template<class U> static handle<T> cast_reinterpret(const loose_handle<U> &x);
+       template <class U> static handle<T> cast_static         (const loose_handle<U> &x);
+       template <class U> static handle<T> cast_dynamic        (const loose_handle<U> &x);
+       template <class U> static handle<T> cast_const          (const loose_handle<U> &x);
+       template <class U> static handle<T> cast_reinterpret(const loose_handle<U> &x);
 
-       template<class U> static handle<T> cast_static(const rhandle<U> &x);
-       template<class U> static handle<T> cast_dynamic(const rhandle<U> &x);
-       template<class U> static handle<T> cast_const(const rhandle<U> &x);
-       template<class U> static handle<T> cast_reinterpret(const rhandle<U> &x);
+       template <class U> static handle<T> cast_static         (const rhandle<U> &x);
+       template <class U> static handle<T> cast_dynamic        (const rhandle<U> &x);
+       template <class U> static handle<T> cast_const          (const rhandle<U> &x);
+       template <class U> static handle<T> cast_reinterpret(const rhandle<U> &x);
 
-       template<class U> static handle<T> cast_static(U* x);
-       template<class U> static handle<T> cast_dynamic(U* x);
-       template<class U> static handle<T> cast_const(U* x);
-       template<class U> static handle<T> cast_reinterpret(U* x);
+       template <class U> static handle<T> cast_static         (U* x);
+       template <class U> static handle<T> cast_dynamic        (U* x);
+       template <class U> static handle<T> cast_const          (U* x);
+       template <class U> static handle<T> cast_reinterpret(U* x);
 
        //! Returns pointer to the object that is being wrapped
        pointer get()const { return obj; }
@@ -395,8 +387,8 @@ public:
        using handle<value_type>::unique;
        using handle<value_type>::operator bool;
        using handle<value_type>::get;
-       using handle<value_type>::operator *;
-       using handle<value_type>::operator ->;
+       using handle<value_type>::operator*;
+       using handle<value_type>::operator->;
 
        /*
        operator const handle<value_type>&()const
@@ -411,7 +403,7 @@ private:
 
        void add_to_rlist()
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
 
                assert(obj);
                obj->rref();
@@ -432,7 +424,7 @@ private:
 
        void del_from_rlist()
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                assert(obj);
                obj->runref();
 
@@ -463,20 +455,20 @@ public:
        //! Constructor that constructs from a pointer to new object
        rhandle(pointer x):handle<T>(x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(obj)add_to_rlist();
        }
 
        rhandle(const handle<value_type> &x):handle<T>(x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(obj)add_to_rlist();
        }
 
        //! Default copy constructor
        rhandle(const rhandle<value_type> &x):handle<T>(x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(obj)add_to_rlist();
        }
 
@@ -510,7 +502,7 @@ public:
        rhandle<value_type> &
        operator=(const rhandle<value_type> &x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(x.get()==obj)
                        return *this;
 
@@ -528,7 +520,7 @@ public:
        rhandle<value_type>&
        operator=(const handle<value_type> &x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(x.get()==obj)
                        return *this;
 
@@ -546,7 +538,7 @@ public:
        rhandle<value_type>&
        operator=(value_type* x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(x==obj)
                        return *this;
 
@@ -566,7 +558,7 @@ public:
        void
        detach()
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                if(obj)del_from_rlist();
                handle<value_type>::detach();
                obj=0;
@@ -585,7 +577,7 @@ public:
        count_type
        rcount()const
        {
-//             value_type*const& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*const& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                return obj?obj->rcount():0;
        }
 
@@ -593,14 +585,14 @@ public:
        bool
        runique()const
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                assert(obj); return obj->front_==obj->back_;
        }
 
        //! \writeme
        int replace(const handle<value_type> &x)
        {
-//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 form barfing
+//             value_type*& obj(handle<T>::obj); // Required to keep gcc 3.4.2 from barfing
                assert(obj);
                assert(x.get()!=obj);
 
@@ -648,11 +640,6 @@ public:
 }; // END of template class rhandle
 
 
-
-
-
-
-
 // ========================================================================
 /*!    \class  loose_handle _handle.h  ETL/handle
 **     \brief  Loose Object Handle
@@ -673,6 +660,9 @@ public:
        typedef int size_type;
 
 protected:
+#ifdef _DEBUG
+public:
+#endif
        value_type *obj;                //!< Pointer to object
 
 public:
@@ -788,141 +778,53 @@ public:
        bool unref() { if(obj && !obj->unref()){ obj=0; return false; } return true; }
 }; // END of template class loose_handle
 
-
-
-
-template<class T> template<class U> handle<T>
-handle<T>::cast_static(const loose_handle<U> &x)
-       { return handle<T>(static_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_dynamic(const loose_handle<U> &x)
-       { return handle<T>(dynamic_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_const(const loose_handle<U> &x)
-       { return handle<T>(const_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_reinterpret(const loose_handle<U> &x)
-       { return handle<T>(reinterpret_cast<T*>(x.get())); }
-
-
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_static(const rhandle<U> &x)
-       { return handle<T>(static_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_dynamic(const rhandle<U> &x)
-       { return handle<T>(dynamic_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_const(const rhandle<U> &x)
-       { return handle<T>(const_cast<T*>(x.get())); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_reinterpret(const rhandle<U> &x)
-       { return handle<T>(reinterpret_cast<T*>(x.get())); }
-
-
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_static(U* x)
-       { return handle<T>(static_cast<T*>(x)); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_dynamic(U* x)
-       { return handle<T>(dynamic_cast<T*>(x)); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_const(U* x)
-       { return handle<T>(const_cast<T*>(x)); }
-
-template <class T> template <class U> handle<T>
-handle<T>::cast_reinterpret(U* x)
-       { return handle<T>(reinterpret_cast<T*>(x)); }
-
-
-
-
-
-template <class T,class U> bool
-operator==(const handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()==rhs.get()); }
-template <class T,class U> bool
-operator==(const loose_handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()==rhs.get()); }
-template <class T,class U> bool
-operator==(const handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()==rhs.get()); }
-template <class T,class U> bool
-operator==(const loose_handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()==rhs.get()); }
-template <class T> bool
-operator==(const handle<T> &lhs,const T *rhs)
-       { return (lhs.get()==rhs); }
-template <class T> bool
-operator==(const loose_handle<T> &lhs,const T *rhs)
-       { return (lhs.get()==rhs); }
-template <class T> bool
-operator==(const T *lhs,const handle<T> &rhs)
-       { return (lhs==rhs.get()); }
-template <class T> bool
-operator==(const T *lhs,const loose_handle<T> &rhs)
-       { return (lhs==rhs.get()); }
-
-
-template <class T,class U> bool
-operator!=(const handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()!=rhs.get()); }
-template <class T,class U> bool
-operator!=(const loose_handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()!=rhs.get()); }
-template <class T,class U> bool
-operator!=(const handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()!=rhs.get()); }
-template <class T,class U> bool
-operator!=(const loose_handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()!=rhs.get()); }
-template <class T> bool
-operator!=(const handle<T> &lhs,const T *rhs)
-       { return (lhs.get()!=rhs); }
-template <class T> bool
-operator!=(const loose_handle<T> &lhs,const T *rhs)
-       { return (lhs.get()!=rhs); }
-template <class T> bool
-operator!=(const T *lhs,const handle<T> &rhs)
-       { return (lhs!=rhs.get()); }
-template <class T> bool
-operator!=(const T *lhs,const loose_handle<T> &rhs)
-       { return (lhs!=rhs.get()); }
-
-
-template <class T,class U> bool
-operator<(const handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()<rhs.get()); }
-template <class T,class U> bool
-operator<(const loose_handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()<rhs.get()); }
-template <class T,class U> bool
-operator<(const handle<T> &lhs,const loose_handle<U> &rhs)
-       { return (lhs.get()<rhs.get()); }
-template <class T,class U> bool
-operator<(const loose_handle<T> &lhs,const handle<U> &rhs)
-       { return (lhs.get()<rhs.get()); }
-template <class T> bool
-operator<(const handle<T> &lhs,const T *rhs)
-       { return (lhs.get()<rhs); }
-template <class T> bool
-operator<(const loose_handle<T> &lhs,const T *rhs)
-       { return (lhs.get()<rhs); }
-template <class T> bool
-operator<(const T *lhs,const handle<T> &rhs)
-       { return (lhs<rhs.get()); }
-template <class T> bool
-operator<(const T *lhs,const loose_handle<T> &rhs)
-       { return (lhs<rhs.get()); }
+// cast loose_handle<> -> handle<>
+template <class T> template <class U> handle<T> handle<T>::cast_static    (const loose_handle<U>& x) { return handle<T>(static_cast     <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_dynamic           (const loose_handle<U>& x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_const     (const loose_handle<U>& x) { return handle<T>(const_cast              <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(const loose_handle<U>& x) { return handle<T>(reinterpret_cast<T*>(x.get())); }
+
+// cast rhandle_handle<> -> handle<>
+template <class T> template <class U> handle<T> handle<T>::cast_static    (const rhandle<U>&      x) { return handle<T>(static_cast     <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_dynamic           (const rhandle<U>&      x) { return handle<T>(dynamic_cast    <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_const     (const rhandle<U>&      x) { return handle<T>(const_cast              <T*>(x.get())); }
+template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(const rhandle<U>&     x) { return handle<T>(reinterpret_cast<T*>(x.get())); }
+
+// cast U* -> handle<>
+template <class T> template <class U> handle<T> handle<T>::cast_static    (U*                                     x) { return handle<T>(static_cast     <T*>(x));               }
+template <class T> template <class U> handle<T> handle<T>::cast_dynamic           (U*                                     x) { return handle<T>(dynamic_cast    <T*>(x));               }
+template <class T> template <class U> handle<T> handle<T>::cast_const     (U*                                     x) { return handle<T>(const_cast              <T*>(x));               }
+template <class T> template <class U> handle<T> handle<T>::cast_reinterpret(U*                                    x) { return handle<T>(reinterpret_cast<T*>(x));               }
+
+// operator== for handle<>, loose_handle<> and T*
+template <class T,class U> bool operator==(const handle                 <T>& lhs,const handle          <U>& rhs) { return (lhs.get()==rhs.get()); }
+template <class T,class U> bool operator==(const loose_handle<T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()==rhs.get()); }
+template <class T,class U> bool operator==(const handle                 <T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()==rhs.get()); }
+template <class T,class U> bool operator==(const loose_handle<T>& lhs,const handle             <U>& rhs) { return (lhs.get()==rhs.get()); }
+template <class T>                bool operator==(const handle<T>&               lhs,const T*                           rhs) { return (lhs.get()==rhs);           }
+template <class T>                bool operator==(const loose_handle<T>& lhs,const T*                           rhs) { return (lhs.get()==rhs);           }
+template <class T>                bool operator==(const T*                               lhs,const handle<T>&           rhs) { return (lhs              ==rhs.get()); }
+template <class T>                bool operator==(const T*                               lhs,const loose_handle<T>& rhs) { return (lhs          ==rhs.get()); }
+
+// operator!= for handle<>, loose_handle<> and T*
+template <class T,class U> bool operator!=(const handle                 <T>& lhs,const handle          <U>& rhs) { return (lhs.get()!=rhs.get()); }
+template <class T,class U> bool operator!=(const loose_handle<T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()!=rhs.get()); }
+template <class T,class U> bool operator!=(const handle                 <T>& lhs,const loose_handle<U>& rhs) { return (lhs.get()!=rhs.get()); }
+template <class T,class U> bool operator!=(const loose_handle<T>& lhs,const handle             <U>& rhs) { return (lhs.get()!=rhs.get()); }
+template <class T>                bool operator!=(const handle<T>&               lhs,const T*                           rhs) { return (lhs.get()!=rhs);           }
+template <class T>                bool operator!=(const loose_handle<T>& lhs,const T*                           rhs) { return (lhs.get()!=rhs);           }
+template <class T>                bool operator!=(const T*                               lhs,const handle<T>&           rhs) { return (lhs              !=rhs.get()); }
+template <class T>                bool operator!=(const T*                               lhs,const loose_handle<T>& rhs) { return (lhs          !=rhs.get()); }
+
+// operator< for handle<>, loose_handle<> and T*
+template <class T,class U> bool operator<(const handle<T>&               lhs,const handle<U>&           rhs) { return (lhs.get()<rhs.get());  }
+template <class T,class U> bool operator<(const loose_handle<T>&  lhs,const loose_handle<U>& rhs) { return (lhs.get()<rhs.get());  }
+template <class T,class U> bool operator<(const handle<T>&               lhs,const loose_handle<U>& rhs) { return (lhs.get()<rhs.get());  }
+template <class T,class U> bool operator<(const loose_handle<T>&  lhs,const handle<U>&          rhs) { return (lhs.get()<rhs.get());  }
+template <class T>                bool operator<(const handle<T>&                lhs,const T*                           rhs) { return (lhs.get()<rhs);            }
+template <class T>                bool operator<(const loose_handle<T>&  lhs,const T*                           rhs) { return (lhs.get()<rhs);            }
+template <class T>                bool operator<(const T*                                lhs,const handle<T>&           rhs) { return (lhs              <rhs.get());  }
+template <class T>                bool operator<(const T*                                lhs,const loose_handle<T>& rhs) { return (lhs          <rhs.get());  }
 
 _ETL_END_NAMESPACE
 
Synfig (Bombe’s repository)