From ccd9f313097ae75bac5a666a4dbeaba3ecee0c38 Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Mon, 17 May 2010 14:21:53 +0000 Subject: [PATCH] Removed signalUnreffed interface --- include/osg/Observer | 9 --------- include/osg/Referenced | 9 +++------ include/osg/observer_ptr | 2 +- src/osg/Observer.cpp | 19 ------------------- src/osg/Referenced.cpp | 34 ++++++++-------------------------- 5 files changed, 12 insertions(+), 61 deletions(-) diff --git a/include/osg/Observer b/include/osg/Observer index a5be3fa6b..f0d60189e 100644 --- a/include/osg/Observer +++ b/include/osg/Observer @@ -27,13 +27,6 @@ class OSG_EXPORT Observer Observer(); virtual ~Observer(); - /** objectUnreferenced(void*) is called when the observed object's referenced count goes to zero, indicating that - * the object will be deleted unless a new reference is made to it. If you wish to prevent deletion of the object - * then it's reference count should be incremented such as via taking a ref_ptr<> to it, if no refernce is taken - * by any of the observers of the object then the object will be deleted, and objectDeleted will in turn be called. - * return true if the Observer wishes to removed from the oberseved objects observer set.*/ - virtual bool objectUnreferenced(void*) { return false; } - /** objectDeleted is called when the observed object is about to be deleted. The observer will be automatically * removed from the observerd objects observer set so there is no need for the objectDeleted implementation * to call removeObserver() on the observed object. */ @@ -54,8 +47,6 @@ class OSG_EXPORT ObserverSet void addObserver(Observer* observer); void removeObserver(Observer* observer); - void signalObjectUnreferenced(void* ptr); - void signalObjectDeleted(void* ptr); typedef std::set Observers; diff --git a/include/osg/Referenced b/include/osg/Referenced index c0b55bc61..4fb34060b 100644 --- a/include/osg/Referenced +++ b/include/osg/Referenced @@ -90,11 +90,8 @@ class OSG_EXPORT Referenced should only be called if the user knows exactly who will be responsible for, one should prefer unref() over unref_nodelete() as the later can lead to memory leaks. - - @param signalObserversOnZeroRefCount - By default true, adjust the reference count and send - any signal to observers if ref count goes to zero. */ - int unref_nodelete(bool signalObserversOnZeroRefCount = true) const; + int unref_nodelete() const; /** Return the number pointers currently referencing this object. */ inline int referenceCount() const { return _refCount; } @@ -141,7 +138,7 @@ class OSG_EXPORT Referenced virtual ~Referenced(); - void signalObserversAndDelete(bool signalUnreferened, bool signalDelete, bool doDelete) const; + void signalObserversAndDelete(bool signalDelete, bool doDelete) const; void deleteUsingDeleteHandler() const; @@ -199,7 +196,7 @@ inline int Referenced::unref() const if (needDelete) { - signalObserversAndDelete(true,true,true); + signalObserversAndDelete(true,true); } return newRef; } diff --git a/include/osg/observer_ptr b/include/osg/observer_ptr index 7ab3e4571..b8dcc1542 100644 --- a/include/osg/observer_ptr +++ b/include/osg/observer_ptr @@ -47,7 +47,7 @@ struct WeakReference : public Observer, public Referenced // The object is in the process of being deleted, but our // objectDeleted() method hasn't been run yet (and we're // blocking it -- and the final destruction -- with our lock). - _ptr->unref_nodelete(false); + _ptr->unref_nodelete(); return 0; } return _ptr; diff --git a/src/osg/Observer.cpp b/src/osg/Observer.cpp index 462cb1e7e..54d8b2507 100644 --- a/src/osg/Observer.cpp +++ b/src/osg/Observer.cpp @@ -48,25 +48,6 @@ void ObserverSet::removeObserver(Observer* observer) _observers.erase(observer); } -void ObserverSet::signalObjectUnreferenced(void* ptr) -{ - for(Observers::iterator itr = _observers.begin(); - itr != _observers.end(); - ) - { - if ((*itr)->objectUnreferenced(ptr)) - { - Observers::iterator orig_itr = itr; - ++itr; - _observers.erase(orig_itr); - } - else - { - ++itr; - } - } -} - void ObserverSet::signalObjectDeleted(void* ptr) { for(Observers::iterator itr = _observers.begin(); diff --git a/src/osg/Referenced.cpp b/src/osg/Referenced.cpp index f45f6b9b3..debfd89ac 100644 --- a/src/osg/Referenced.cpp +++ b/src/osg/Referenced.cpp @@ -238,7 +238,7 @@ Referenced::~Referenced() } // signal observers that we are being deleted. - signalObserversAndDelete(false, true, false); + signalObserversAndDelete(true, false); // delete the ObserverSet #if defined(_OSG_REFERENCED_USE_ATOMIC_OPERATIONS) @@ -278,7 +278,7 @@ ObserverSet* Referenced::getOrCreateObserverSet() const #endif } -void Referenced::signalObserversAndDelete(bool signalUnreferened, bool signalDelete, bool doDelete) const +void Referenced::signalObserversAndDelete(bool signalDelete, bool doDelete) const { #if defined(_OSG_REFERENCED_USE_ATOMIC_OPERATIONS) ObserverSet* observerSet = static_cast(_observerSet.get()); @@ -286,18 +286,10 @@ void Referenced::signalObserversAndDelete(bool signalUnreferened, bool signalDel ObserverSet* observerSet = static_cast(_observerSet); #endif - if (observerSet) + if (observerSet && signalDelete) { OpenThreads::ScopedLock lock(*(observerSet->getObserverSetMutex())); - if (signalUnreferened) - { - observerSet->signalObjectUnreferenced(const_cast(this)); - } - - if (signalDelete) - { - observerSet->signalObjectDeleted(const_cast(this)); - } + observerSet->signalObjectDeleted(const_cast(this)); } if (doDelete) @@ -334,32 +326,22 @@ void Referenced::setThreadSafeRefUnref(bool threadSafe) #endif } -int Referenced::unref_nodelete(bool signalObserversOnZeroRefCount) const +int Referenced::unref_nodelete() const { - int result; #if defined(_OSG_REFERENCED_USE_ATOMIC_OPERATIONS) - result = --_refCount; - bool needUnreferencedSignal = (result == 0); + return --_refCount; #else bool needUnreferencedSignal = false; if (_refMutex) { OpenThreads::ScopedLock lock(*_refMutex); - result = --_refCount; - needUnreferencedSignal = (result == 0); + return --_refCount; } else { - result = --_refCount; - needUnreferencedSignal = (result == 0); + return --_refCount; } #endif - - if (needUnreferencedSignal && signalObserversOnZeroRefCount) - { - signalObserversAndDelete(true,false,false); - } - return result; } void Referenced::deleteUsingDeleteHandler() const