diff options
Diffstat (limited to 'indra/llcommon/llhandle.h')
| -rw-r--r-- | indra/llcommon/llhandle.h | 240 |
1 files changed, 120 insertions, 120 deletions
diff --git a/indra/llcommon/llhandle.h b/indra/llcommon/llhandle.h index 570cd330b8..ceea1d9c48 100644 --- a/indra/llcommon/llhandle.h +++ b/indra/llcommon/llhandle.h @@ -1,4 +1,4 @@ -/** +/** * @file llhandle.h * @brief "Handle" to an object (usually a floater) whose lifetime you don't * control. @@ -6,21 +6,21 @@ * $LicenseInfo:firstyear=2001&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. -* +* * 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; * version 2.1 of the License only. -* +* * 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 -* +* * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ @@ -42,22 +42,22 @@ class LLTombStone : public LLRefCount { public: - LLTombStone(void* target = NULL) : mTarget(target) {} + LLTombStone(void* target = NULL) : mTarget(target) {} - void setTarget(void* target) { mTarget = target; } - void* getTarget() const { return mTarget; } + void setTarget(void* target) { mTarget = target; } + void* getTarget() const { return mTarget; } private: - mutable void* mTarget; + mutable void* mTarget; }; /** - * LLHandles are used to refer to objects whose lifetime you do not control or influence. - * Calling get() on a handle will return a pointer to the referenced object or NULL, - * if the object no longer exists. Note that during the lifetime of the returned pointer, - * you are assuming that the object will not be deleted by any action you perform, - * or any other thread, as normal when using pointers, so avoid using that pointer outside of - * the local code block. - * + * LLHandles are used to refer to objects whose lifetime you do not control or influence. + * Calling get() on a handle will return a pointer to the referenced object or NULL, + * if the object no longer exists. Note that during the lifetime of the returned pointer, + * you are assuming that the object will not be deleted by any action you perform, + * or any other thread, as normal when using pointers, so avoid using that pointer outside of + * the local code block. + * * https://wiki.lindenlab.com/mediawiki/index.php?title=LLHandle&oldid=79669 * * The implementation is like some "weak pointer" implementations. When we @@ -84,58 +84,58 @@ private: template <typename T> class LLHandle { - template <typename U> friend class LLHandle; - template <typename U> friend class LLHandleProvider; + template <typename U> friend class LLHandle; + template <typename U> friend class LLHandleProvider; public: - LLHandle() : mTombStone(getDefaultTombStone()) {} - - template<typename U> - LLHandle(const LLHandle<U>& other, typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0) - : mTombStone(other.mTombStone) - {} - - bool isDead() const - { - return mTombStone->getTarget() == NULL; - } - - void markDead() - { - mTombStone = getDefaultTombStone(); - } - - T* get() const - { - return reinterpret_cast<T*>(mTombStone->getTarget()); - } - - friend bool operator== (const LLHandle<T>& lhs, const LLHandle<T>& rhs) - { - return lhs.mTombStone == rhs.mTombStone; - } - friend bool operator!= (const LLHandle<T>& lhs, const LLHandle<T>& rhs) - { - return !(lhs == rhs); - } - friend bool operator< (const LLHandle<T>& lhs, const LLHandle<T>& rhs) - { - return lhs.mTombStone < rhs.mTombStone; - } - friend bool operator> (const LLHandle<T>& lhs, const LLHandle<T>& rhs) - { - return lhs.mTombStone > rhs.mTombStone; - } + LLHandle() : mTombStone(getDefaultTombStone()) {} + + template<typename U> + LLHandle(const LLHandle<U>& other, typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0) + : mTombStone(other.mTombStone) + {} + + bool isDead() const + { + return mTombStone->getTarget() == NULL; + } + + void markDead() + { + mTombStone = getDefaultTombStone(); + } + + T* get() const + { + return reinterpret_cast<T*>(mTombStone->getTarget()); + } + + friend bool operator== (const LLHandle<T>& lhs, const LLHandle<T>& rhs) + { + return lhs.mTombStone == rhs.mTombStone; + } + friend bool operator!= (const LLHandle<T>& lhs, const LLHandle<T>& rhs) + { + return !(lhs == rhs); + } + friend bool operator< (const LLHandle<T>& lhs, const LLHandle<T>& rhs) + { + return lhs.mTombStone < rhs.mTombStone; + } + friend bool operator> (const LLHandle<T>& lhs, const LLHandle<T>& rhs) + { + return lhs.mTombStone > rhs.mTombStone; + } protected: - LLPointer<LLTombStone> mTombStone; + LLPointer<LLTombStone> mTombStone; private: - typedef T* pointer_t; - static LLPointer<LLTombStone>& getDefaultTombStone() - { - static LLPointer<LLTombStone> sDefaultTombStone = new LLTombStone; - return sDefaultTombStone; - } + typedef T* pointer_t; + static LLPointer<LLTombStone>& getDefaultTombStone() + { + static LLPointer<LLTombStone> sDefaultTombStone = new LLTombStone; + return sDefaultTombStone; + } }; /** @@ -150,36 +150,36 @@ template <typename T> class LLRootHandle : public LLHandle<T> { public: - typedef LLRootHandle<T> self_t; - typedef LLHandle<T> base_t; - - LLRootHandle(T* object) { bind(object); } - LLRootHandle() {}; - ~LLRootHandle() { unbind(); } - - // this is redundant, since an LLRootHandle *is* an LLHandle - //LLHandle<T> getHandle() { return LLHandle<T>(*this); } - - void bind(T* object) - { - // unbind existing tombstone - if (LLHandle<T>::mTombStone.notNull()) - { - if (LLHandle<T>::mTombStone->getTarget() == (void*)object) return; - LLHandle<T>::mTombStone->setTarget(NULL); - } - // tombstone reference counted, so no paired delete - LLHandle<T>::mTombStone = new LLTombStone((void*)object); - } - - void unbind() - { - LLHandle<T>::mTombStone->setTarget(NULL); - } - - //don't allow copying of root handles, since there should only be one + typedef LLRootHandle<T> self_t; + typedef LLHandle<T> base_t; + + LLRootHandle(T* object) { bind(object); } + LLRootHandle() {}; + ~LLRootHandle() { unbind(); } + + // this is redundant, since an LLRootHandle *is* an LLHandle + //LLHandle<T> getHandle() { return LLHandle<T>(*this); } + + void bind(T* object) + { + // unbind existing tombstone + if (LLHandle<T>::mTombStone.notNull()) + { + if (LLHandle<T>::mTombStone->getTarget() == (void*)object) return; + LLHandle<T>::mTombStone->setTarget(NULL); + } + // tombstone reference counted, so no paired delete + LLHandle<T>::mTombStone = new LLTombStone((void*)object); + } + + void unbind() + { + LLHandle<T>::mTombStone->setTarget(NULL); + } + + //don't allow copying of root handles, since there should only be one private: - LLRootHandle(const LLRootHandle& other) {}; + LLRootHandle(const LLRootHandle& other) {}; }; /** @@ -190,31 +190,31 @@ template <typename T> class LLHandleProvider { public: - LLHandle<T> getHandle() const - { - // perform lazy binding to avoid small tombstone allocations for handle - // providers whose handles are never referenced - mHandle.bind(static_cast<T*>(const_cast<LLHandleProvider<T>* >(this))); - return mHandle; - } - - template <typename U> - LLHandle<U> getDerivedHandle(typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0) const - { - LLHandle<U> downcast_handle; - downcast_handle.mTombStone = getHandle().mTombStone; - return downcast_handle; - } + LLHandle<T> getHandle() const + { + // perform lazy binding to avoid small tombstone allocations for handle + // providers whose handles are never referenced + mHandle.bind(static_cast<T*>(const_cast<LLHandleProvider<T>* >(this))); + return mHandle; + } + + template <typename U> + LLHandle<U> getDerivedHandle(typename boost::enable_if< typename boost::is_convertible<U*, T*> >::type* dummy = 0) const + { + LLHandle<U> downcast_handle; + downcast_handle.mTombStone = getHandle().mTombStone; + return downcast_handle; + } protected: - typedef LLHandle<T> handle_type_t; - LLHandleProvider() - { - // provided here to enforce T deriving from LLHandleProvider<T> - } + typedef LLHandle<T> handle_type_t; + LLHandleProvider() + { + // provided here to enforce T deriving from LLHandleProvider<T> + } private: - mutable LLRootHandle<T> mHandle; + mutable LLRootHandle<T> mHandle; }; @@ -236,12 +236,12 @@ protected: }; /** - * This is a simple wrapper for Handles, allowing direct calls to the underlying - * pointer. The checked handle will throw a Stale if an attempt - * is made to access the object referenced by the handle and that object has + * This is a simple wrapper for Handles, allowing direct calls to the underlying + * pointer. The checked handle will throw a Stale if an attempt + * is made to access the object referenced by the handle and that object has * been destroyed. **/ -template <typename T> +template <typename T> class LLCheckedHandle: public LLCheckedHandleBase { public: @@ -269,7 +269,7 @@ public: } /** - * Converts the LLCheckedHandle to a bool. Allows for if (chkdHandle) {} + * Converts the LLCheckedHandle to a bool. Allows for if (chkdHandle) {} * Does not throw. */ /*explicit*/ operator bool() const // explicit conversion operator not available with Linux compiler @@ -278,8 +278,8 @@ public: } /** - * Attempt to call a method or access a member in the structure referenced - * by the handle. If the handle no longer points to a valid structure + * Attempt to call a method or access a member in the structure referenced + * by the handle. If the handle no longer points to a valid structure * throw a Stale. */ T* operator ->() const |