#ifndef WTF_PassOwnArrayPtr_h
#define WTF_PassOwnArrayPtr_h
#include "Assertions.h"
#include "NullPtr.h"
#include "TypeTraits.h"
namespace WTF {
template<typename T> class OwnArrayPtr;
template<typename T> class PassOwnArrayPtr;
template<typename T> PassOwnArrayPtr<T> adoptArrayPtr(T*);
template<typename T> void deleteOwnedArrayPtr(T* ptr);
template<typename T> class PassOwnArrayPtr {
public:
typedef T* PtrType;
PassOwnArrayPtr() : m_ptr(0) { }
PassOwnArrayPtr(std::nullptr_t) : m_ptr(0) { }
PassOwnArrayPtr(const PassOwnArrayPtr& o) : m_ptr(o.leakPtr()) { }
template<typename U> PassOwnArrayPtr(const PassOwnArrayPtr<U>& o) : m_ptr(o.leakPtr()) { }
~PassOwnArrayPtr() { deleteOwnedArrayPtr(m_ptr); }
PtrType get() const { return m_ptr; }
void clear();
PtrType leakPtr() const WARN_UNUSED_RETURN;
T& operator*() const { ASSERT(m_ptr); return *m_ptr; }
PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
bool operator!() const { return !m_ptr; }
typedef PtrType PassOwnArrayPtr::*UnspecifiedBoolType;
operator UnspecifiedBoolType() const { return m_ptr ? &PassOwnArrayPtr::m_ptr : 0; }
PassOwnArrayPtr& operator=(const PassOwnArrayPtr<T>&);
PassOwnArrayPtr& operator=(std::nullptr_t) { clear(); return *this; }
template<typename U> PassOwnArrayPtr& operator=(const PassOwnArrayPtr<U>&);
template<typename U> friend PassOwnArrayPtr<U> adoptArrayPtr(U*);
private:
explicit PassOwnArrayPtr(PtrType ptr) : m_ptr(ptr) { }
mutable PtrType m_ptr;
};
template<typename T> inline void PassOwnArrayPtr<T>::clear()
{
PtrType ptr = m_ptr;
m_ptr = 0;
deleteOwnedArrayPtr(ptr);
}
template<typename T> inline typename PassOwnArrayPtr<T>::PtrType PassOwnArrayPtr<T>::leakPtr() const
{
PtrType ptr = m_ptr;
m_ptr = 0;
return ptr;
}
template<typename T> inline PassOwnArrayPtr<T>& PassOwnArrayPtr<T>::operator=(const PassOwnArrayPtr<T>& optr)
{
PtrType ptr = m_ptr;
m_ptr = optr.leakPtr();
ASSERT(!ptr || m_ptr != ptr);
if (ptr)
deleteOwnedArrayPtr(ptr);
return *this;
}
template<typename T> template<typename U> inline PassOwnArrayPtr<T>& PassOwnArrayPtr<T>::operator=(const PassOwnArrayPtr<U>& optr)
{
PtrType ptr = m_ptr;
m_ptr = optr.leakPtr();
ASSERT(!ptr || m_ptr != ptr);
if (ptr)
deleteOwnedArrayPtr(ptr);
return *this;
}
template<typename T, typename U> inline bool operator==(const PassOwnArrayPtr<T>& a, const PassOwnArrayPtr<U>& b)
{
return a.get() == b.get();
}
template<typename T, typename U> inline bool operator==(const PassOwnArrayPtr<T>& a, const OwnArrayPtr<U>& b)
{
return a.get() == b.get();
}
template<typename T, typename U> inline bool operator==(const OwnArrayPtr<T>& a, const PassOwnArrayPtr<U>& b)
{
return a.get() == b.get();
}
template<typename T, typename U> inline bool operator==(const PassOwnArrayPtr<T>& a, U* b)
{
return a.get() == b;
}
template<typename T, typename U> inline bool operator==(T* a, const PassOwnArrayPtr<U>& b)
{
return a == b.get();
}
template<typename T, typename U> inline bool operator!=(const PassOwnArrayPtr<T>& a, const PassOwnArrayPtr<U>& b)
{
return a.get() != b.get();
}
template<typename T, typename U> inline bool operator!=(const PassOwnArrayPtr<T>& a, const OwnArrayPtr<U>& b)
{
return a.get() != b.get();
}
template<typename T, typename U> inline bool operator!=(const OwnArrayPtr<T>& a, const PassOwnArrayPtr<U>& b)
{
return a.get() != b.get();
}
template<typename T, typename U> inline bool operator!=(const PassOwnArrayPtr<T>& a, U* b)
{
return a.get() != b;
}
template<typename T, typename U> inline bool operator!=(T* a, const PassOwnArrayPtr<U>& b)
{
return a != b.get();
}
template<typename T> inline PassOwnArrayPtr<T> adoptArrayPtr(T* ptr)
{
return PassOwnArrayPtr<T>(ptr);
}
template<typename T> inline void deleteOwnedArrayPtr(T* ptr)
{
typedef char known[sizeof(T) ? 1 : -1];
if (sizeof(known))
delete [] ptr;
}
template<typename T, typename U> inline PassOwnArrayPtr<T> static_pointer_cast(const PassOwnArrayPtr<U>& p)
{
return adoptArrayPtr(static_cast<T*>(p.leakPtr()));
}
template<typename T, typename U> inline PassOwnArrayPtr<T> const_pointer_cast(const PassOwnArrayPtr<U>& p)
{
return adoptArrayPtr(const_cast<T*>(p.leakPtr()));
}
template<typename T> inline T* getPtr(const PassOwnArrayPtr<T>& p)
{
return p.get();
}
}
using WTF::PassOwnArrayPtr;
using WTF::adoptArrayPtr;
using WTF::const_pointer_cast;
using WTF::static_pointer_cast;
#endif // WTF_PassOwnArrayPtr_h