Changeset 9893

Timestamp:

03/10/09 18:51:05 (4 years ago)

Author:

robert

Message:

From Mathias Froehlich, "an other topic pointed out by some Microsoft verification tool:
On destruction of some static variables, the global referenced mutex is used
to lock access to the parent lists of state attributes, nodes and so on.
This even happens past the mutex is already destroyed.

This change to Referenced.cpp revision 9851 uses the same technique like the
DeleteHandlerPointer? already in Referenced.cpp to return an zero pointer for
the global referenced lock if it is already destroyed."

Files:

• OpenSceneGraph/trunk/src/osg/Referenced.cpp (modified) (4 diffs)

OpenSceneGraph/trunk/src/osg/Referenced.cpp

@@ -34 +34 @@
 
 // specialized smart pointer, used to get round auto_ptr<>'s lack of the destructor reseting itself to 0.
-struct DeleteHandlerPointer
-{
-    DeleteHandlerPointer():
+template<typename T>
+struct ResetPointer
+{
+    ResetPointer():
         _ptr(0) {}
 
-    DeleteHandlerPointer(DeleteHandler* ptr):
+    ResetPointer(T* ptr):
         _ptr(ptr) {}
 
-    ~DeleteHandlerPointer()
+    ~ResetPointer()
     {
         delete _ptr;
@@ -48 +49 @@
     }
 
-    inline DeleteHandlerPointer& operator = (DeleteHandler* ptr)
+    inline ResetPointer& operator = (T* ptr)
     {
         if (_ptr==ptr) return *this;
@@ -56 +57 @@
     }
 
-    void reset(DeleteHandler* ptr)
+    void reset(T* ptr)
     {
         if (_ptr==ptr) return;
@@ -63 +64 @@
     }
 
-    inline DeleteHandler& operator*()  { return *_ptr; }
-
-    inline const DeleteHandler& operator*() const { return *_ptr; }
-
-    inline DeleteHandler* operator->() { return _ptr; }
-
-    inline const DeleteHandler* operator->() const   { return _ptr; }
-
-    DeleteHandler* get() { return _ptr; }
-
-    const DeleteHandler* get() const { return _ptr; }
-
-    DeleteHandler* _ptr;
+    inline T& operator*()  { return *_ptr; }
+
+    inline const T& operator*() const { return *_ptr; }
+
+    inline T* operator->() { return _ptr; }
+
+    inline const T* operator->() const   { return _ptr; }
+
+    T* get() { return _ptr; }
+
+    const T* get() const { return _ptr; }
+
+    T* _ptr;
 };
 
+typedef ResetPointer<DeleteHandler> DeleteHandlerPointer;
+typedef ResetPointer<OpenThreads::Mutex> GlobalMutexPointer;
+
 OpenThreads::Mutex* Referenced::getGlobalReferencedMutex()
 {
-    static OpenThreads::Mutex s_ReferencedGlobalMutext;
-    return &s_ReferencedGlobalMutext;
+    static GlobalMutexPointer s_ReferencedGlobalMutext = new OpenThreads::Mutex;
+    return s_ReferencedGlobalMutext.get();
 }