/* * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. * */ // RefPtr and PassRefPtr are documented at http://webkit.org/coding/RefPtr.html #ifndef WTF_RefPtr_h #define WTF_RefPtr_h #include #include "FastAllocBase.h" #include "PassRefPtr.h" namespace WTF { enum PlacementNewAdoptType { PlacementNewAdopt }; template class PassRefPtr; template class NonNullPassRefPtr; enum HashTableDeletedValueType { HashTableDeletedValue }; template class RefPtr { WTF_MAKE_FAST_ALLOCATED; public: ALWAYS_INLINE RefPtr() : m_ptr(0) { } ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); } ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); } template RefPtr(const RefPtr& o) : m_ptr(o.get()) { refIfNotNull(m_ptr); } // See comments in PassRefPtr.h for an explanation of why these takes const references. template RefPtr(const PassRefPtr&); template RefPtr(const NonNullPassRefPtr&); // Special constructor for cases where we overwrite an object in place. ALWAYS_INLINE RefPtr(PlacementNewAdoptType) { } // Hash table deleted values, which are only constructed and never copied or destroyed. RefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { } bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); } ALWAYS_INLINE ~RefPtr() { derefIfNotNull(m_ptr); } ALWAYS_INLINE T* get() const { return m_ptr; } void clear(); PassRefPtr release() { PassRefPtr tmp = adoptRef(m_ptr); m_ptr = 0; return tmp; } T& operator*() const { return *m_ptr; } ALWAYS_INLINE T* operator->() const { return m_ptr; } bool operator!() const { return !m_ptr; } // This conversion operator allows implicit conversion to bool but not to other integer types. typedef T* (RefPtr::*UnspecifiedBoolType); operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::m_ptr : 0; } RefPtr& operator=(const RefPtr&); RefPtr& operator=(T*); RefPtr& operator=(const PassRefPtr&); RefPtr& operator=(const NonNullPassRefPtr&); #if !HAVE(NULLPTR) RefPtr& operator=(std::nullptr_t) { clear(); return *this; } #endif template RefPtr& operator=(const RefPtr&); template RefPtr& operator=(const PassRefPtr&); template RefPtr& operator=(const NonNullPassRefPtr&); void swap(RefPtr&); static T* hashTableDeletedValue() { return reinterpret_cast(-1); } private: T* m_ptr; }; template template inline RefPtr::RefPtr(const PassRefPtr& o) : m_ptr(o.leakRef()) { } template template inline RefPtr::RefPtr(const NonNullPassRefPtr& o) : m_ptr(o.leakRef()) { } template inline void RefPtr::clear() { T* ptr = m_ptr; m_ptr = 0; derefIfNotNull(ptr); } template inline RefPtr& RefPtr::operator=(const RefPtr& o) { T* optr = o.get(); refIfNotNull(optr); T* ptr = m_ptr; m_ptr = optr; derefIfNotNull(ptr); return *this; } template template inline RefPtr& RefPtr::operator=(const RefPtr& o) { T* optr = o.get(); refIfNotNull(optr); T* ptr = m_ptr; m_ptr = optr; derefIfNotNull(ptr); return *this; } template inline RefPtr& RefPtr::operator=(T* optr) { refIfNotNull(optr); T* ptr = m_ptr; m_ptr = optr; derefIfNotNull(ptr); return *this; } template inline RefPtr& RefPtr::operator=(const PassRefPtr& o) { T* ptr = m_ptr; m_ptr = o.leakRef(); derefIfNotNull(ptr); return *this; } template inline RefPtr& RefPtr::operator=(const NonNullPassRefPtr& o) { T* ptr = m_ptr; m_ptr = o.leakRef(); derefIfNotNull(ptr); return *this; } template template inline RefPtr& RefPtr::operator=(const PassRefPtr& o) { T* ptr = m_ptr; m_ptr = o.leakRef(); derefIfNotNull(ptr); return *this; } template template inline RefPtr& RefPtr::operator=(const NonNullPassRefPtr& o) { T* ptr = m_ptr; m_ptr = o.leakRef(); derefIfNotNull(ptr); return *this; } template inline void RefPtr::swap(RefPtr& o) { std::swap(m_ptr, o.m_ptr); } template inline void swap(RefPtr& a, RefPtr& b) { a.swap(b); } template inline bool operator==(const RefPtr& a, const RefPtr& b) { return a.get() == b.get(); } template inline bool operator==(const RefPtr& a, U* b) { return a.get() == b; } template inline bool operator==(T* a, const RefPtr& b) { return a == b.get(); } template inline bool operator!=(const RefPtr& a, const RefPtr& b) { return a.get() != b.get(); } template inline bool operator!=(const RefPtr& a, U* b) { return a.get() != b; } template inline bool operator!=(T* a, const RefPtr& b) { return a != b.get(); } template inline RefPtr static_pointer_cast(const RefPtr& p) { return RefPtr(static_cast(p.get())); } template inline RefPtr const_pointer_cast(const RefPtr& p) { return RefPtr(const_cast(p.get())); } template inline T* getPtr(const RefPtr& p) { return p.get(); } } // namespace WTF using WTF::RefPtr; using WTF::static_pointer_cast; using WTF::const_pointer_cast; #endif // WTF_RefPtr_h