From 5ddde30071f639962dd557c453f2ad01f8f0fd00 Mon Sep 17 00:00:00 2001 From: Kristian Monsen Date: Wed, 8 Sep 2010 12:18:00 +0100 Subject: Merge WebKit at r66666 : Initial merge by git. Change-Id: I57dedeb49859adc9c539e760f0e749768c66626f --- JavaScriptCore/wtf/OwnArrayPtr.h | 186 ++++++++++++++++++++++++++++----------- 1 file changed, 133 insertions(+), 53 deletions(-) (limited to 'JavaScriptCore/wtf/OwnArrayPtr.h') diff --git a/JavaScriptCore/wtf/OwnArrayPtr.h b/JavaScriptCore/wtf/OwnArrayPtr.h index d40ea17..ce056b3 100644 --- a/JavaScriptCore/wtf/OwnArrayPtr.h +++ b/JavaScriptCore/wtf/OwnArrayPtr.h @@ -21,74 +21,154 @@ #ifndef WTF_OwnArrayPtr_h #define WTF_OwnArrayPtr_h +#include "Assertions.h" +#include "Noncopyable.h" +#include "OwnArrayPtrCommon.h" #include -#include -#include + +// Remove this once we make all WebKit code compatible with stricter rules about OwnArrayPtr. +#define LOOSE_OWN_ARRAY_PTR namespace WTF { - template class OwnArrayPtr : public Noncopyable { - public: - explicit OwnArrayPtr(T* ptr = 0) : m_ptr(ptr) { } - ~OwnArrayPtr() { safeDelete(m_ptr); } +template class PassOwnArrayPtr; +template PassOwnArrayPtr adoptArrayPtr(T*); + +template class OwnArrayPtr : public Noncopyable { +public: + typedef T* PtrType; + + OwnArrayPtr() : m_ptr(0) { } - T* get() const { return m_ptr; } - T* release() { T* ptr = m_ptr; m_ptr = 0; return ptr; } + // See comment in PassOwnArrayPtr.h for why this takes a const reference. + template OwnArrayPtr(const PassOwnArrayPtr& o); - // FIXME: This should be removed and replaced with PassOwnArrayPtr. - void set(T* ptr) - { - ASSERT(!ptr || m_ptr != ptr); - T* oldPtr = m_ptr; - m_ptr = ptr; - safeDelete(oldPtr); - } + // This copy constructor is used implicitly by gcc when it generates + // transients for assigning a PassOwnArrayPtr object to a stack-allocated + // OwnArrayPtr object. It should never be called explicitly and gcc + // should optimize away the constructor when generating code. + OwnArrayPtr(const OwnArrayPtr&); - void clear(); + ~OwnArrayPtr() { deleteOwnedArrayPtr(m_ptr); } - T& operator*() const { ASSERT(m_ptr); return *m_ptr; } - T* operator->() const { ASSERT(m_ptr); return m_ptr; } + PtrType get() const { return m_ptr; } - T& operator[](std::ptrdiff_t i) const { ASSERT(m_ptr); ASSERT(i >= 0); return m_ptr[i]; } + void clear(); + PassOwnArrayPtr release(); + PtrType leakPtr() WARN_UNUSED_RETURN; - bool operator!() const { return !m_ptr; } + T& operator*() const { ASSERT(m_ptr); return *m_ptr; } + PtrType operator->() const { ASSERT(m_ptr); return m_ptr; } - // This conversion operator allows implicit conversion to bool but not to other integer types. + T& operator[](std::ptrdiff_t i) const { ASSERT(m_ptr); ASSERT(i >= 0); return m_ptr[i]; } + + bool operator!() const { return !m_ptr; } + + // This conversion operator allows implicit conversion to bool but not to other integer types. #if COMPILER(WINSCW) - operator bool() const { return m_ptr; } + operator bool() const { return m_ptr; } #else - typedef T* OwnArrayPtr::*UnspecifiedBoolType; - operator UnspecifiedBoolType() const { return m_ptr ? &OwnArrayPtr::m_ptr : 0; } + typedef T* OwnArrayPtr::*UnspecifiedBoolType; + operator UnspecifiedBoolType() const { return m_ptr ? &OwnArrayPtr::m_ptr : 0; } +#endif + + OwnArrayPtr& operator=(const PassOwnArrayPtr&); + template OwnArrayPtr& operator=(const PassOwnArrayPtr&); + + void swap(OwnArrayPtr& o) { std::swap(m_ptr, o.m_ptr); } + +#ifdef LOOSE_OWN_ARRAY_PTR + explicit OwnArrayPtr(PtrType ptr) : m_ptr(ptr) { } + void set(PtrType); +#endif + +private: + PtrType m_ptr; +}; + +template template inline OwnArrayPtr::OwnArrayPtr(const PassOwnArrayPtr& o) + : m_ptr(o.leakPtr()) +{ +} + +template inline void OwnArrayPtr::clear() +{ + PtrType ptr = m_ptr; + m_ptr = 0; + deleteOwnedArrayPtr(ptr); +} + +template inline PassOwnArrayPtr OwnArrayPtr::release() +{ + PtrType ptr = m_ptr; + m_ptr = 0; + return adoptArrayPtr(ptr); +} + +template inline typename OwnArrayPtr::PtrType OwnArrayPtr::leakPtr() +{ + PtrType ptr = m_ptr; + m_ptr = 0; + return ptr; +} + +#ifdef LOOSE_OWN_ARRAY_PTR +template inline void OwnArrayPtr::set(PtrType ptr) +{ + ASSERT(!ptr || m_ptr != ptr); + PtrType oldPtr = m_ptr; + m_ptr = ptr; + deleteOwnedPtr(oldPtr); +} #endif - void swap(OwnArrayPtr& o) { std::swap(m_ptr, o.m_ptr); } - - private: - static void safeDelete(T*); - - T* m_ptr; - }; - - template inline void OwnArrayPtr::clear() - { - T* ptr = m_ptr; - m_ptr = 0; - safeDelete(ptr); - } - - template inline void OwnArrayPtr::safeDelete(T* ptr) - { - typedef char known[sizeof(T) ? 1 : -1]; - if (sizeof(known)) - delete [] ptr; - } - - template inline void swap(OwnArrayPtr& a, OwnArrayPtr& b) { a.swap(b); } - - template inline T* getPtr(const OwnArrayPtr& p) - { - return p.get(); - } +template inline OwnArrayPtr& OwnArrayPtr::operator=(const PassOwnArrayPtr& o) +{ + PtrType ptr = m_ptr; + m_ptr = o.leakPtr(); + ASSERT(!ptr || m_ptr != ptr); + deleteOwnedArrayPtr(ptr); + return *this; +} + +template template inline OwnArrayPtr& OwnArrayPtr::operator=(const PassOwnArrayPtr& o) +{ + PtrType ptr = m_ptr; + m_ptr = o.leakPtr(); + ASSERT(!ptr || m_ptr != ptr); + deleteOwnedArrayPtr(ptr); + return *this; +} + +template inline void swap(OwnArrayPtr& a, OwnArrayPtr& b) +{ + a.swap(b); +} + +template inline bool operator==(const OwnArrayPtr& a, U* b) +{ + return a.get() == b; +} + +template inline bool operator==(T* a, const OwnArrayPtr& b) +{ + return a == b.get(); +} + +template inline bool operator!=(const OwnArrayPtr& a, U* b) +{ + return a.get() != b; +} + +template inline bool operator!=(T* a, const OwnArrayPtr& b) +{ + return a != b.get(); +} + +template inline T* getPtr(const OwnArrayPtr& p) +{ + return p.get(); +} } // namespace WTF -- cgit v1.1