wtf/OwnPtr.h

   1 /*
   2  *  Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
   3  *
   4  *  This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  *  This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU Library General Public License
  15  *  along with this library; see the file COPYING.LIB.  If not, write to
  16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  *  Boston, MA 02110-1301, USA.
  18  *
  19  */
  20
  21 #ifndef WTF_OwnPtr_h
  22 #define WTF_OwnPtr_h
  23
  24 #include "Assertions.h"
  25 #include "Noncopyable.h"
  26 #include "OwnPtrCommon.h"
  27 #include "TypeTraits.h"
  28 #include <algorithm>
  29 #include <memory>
  30
  31 namespace WTF {
  32
  33     // Unlike most of our smart pointers, OwnPtr can take either the pointer type or the pointed-to type.
  34
  35     template <typename T> class PassOwnPtr;
  36
  37     template <typename T> class OwnPtr : public Noncopyable {
  38     public:
  39         typedef typename RemovePointer<T>::Type ValueType;
  40         typedef ValueType* PtrType;
  41
  42         explicit OwnPtr(PtrType ptr = 0) : m_ptr(ptr) { }
  43         OwnPtr(std::auto_ptr<ValueType> autoPtr) : m_ptr(autoPtr.release()) { }
  44         // See comment in PassOwnPtr.h for why this takes a const reference.
  45         template <typename U> OwnPtr(const PassOwnPtr<U>& o);
  46
  47         // This copy constructor is used implicitly by gcc when it generates
  48         // transients for assigning a PassOwnPtr<T> object to a stack-allocated
  49         // OwnPtr<T> object.  It should never be called explicitly and gcc
  50         // should optimize away the constructor when generating code.
  51         OwnPtr(const OwnPtr<ValueType>& o);
  52
  53         ~OwnPtr() { deleteOwnedPtr(m_ptr); }
  54
  55         PtrType get() const { return m_ptr; }
  56         PtrType release() { PtrType ptr = m_ptr; m_ptr = 0; return ptr; }
  57
  58         // FIXME: This should be renamed to adopt.
  59         void set(PtrType ptr) { ASSERT(!ptr || m_ptr != ptr); deleteOwnedPtr(m_ptr); m_ptr = ptr; }
  60
  61         void adopt(std::auto_ptr<ValueType> autoPtr) { ASSERT(!autoPtr.get() || m_ptr != autoPtr.get()); deleteOwnedPtr(m_ptr); m_ptr = autoPtr.release(); }
  62
  63         void clear() { deleteOwnedPtr(m_ptr); m_ptr = 0; }
  64
  65         ValueType& operator*() const { ASSERT(m_ptr); return *m_ptr; }
  66         PtrType operator->() const { ASSERT(m_ptr); return m_ptr; }
  67
  68         bool operator!() const { return !m_ptr; }
  69
  70         // This conversion operator allows implicit conversion to bool but not to other integer types.
  71         typedef PtrType OwnPtr::*UnspecifiedBoolType;
  72         operator UnspecifiedBoolType() const { return m_ptr ? &OwnPtr::m_ptr : 0; }
  73
  74         OwnPtr& operator=(const PassOwnPtr<T>&);
  75         template <typename U> OwnPtr& operator=(const PassOwnPtr<U>&);
  76
  77         void swap(OwnPtr& o) { std::swap(m_ptr, o.m_ptr); }
  78
  79     private:
  80         PtrType m_ptr;
  81     };
  82
  83     template <typename T> template <typename U> inline OwnPtr<T>::OwnPtr(const PassOwnPtr<U>& o)
  84         : m_ptr(o.release())
  85     {
  86     }
  87
  88     template <typename T> inline OwnPtr<T>& OwnPtr<T>::operator=(const PassOwnPtr<T>& o)
  89     {
  90         T* ptr = m_ptr;
  91         m_ptr = o.release();
  92         ASSERT(!ptr || m_ptr != ptr);
  93         if (ptr)
  94             deleteOwnedPtr(ptr);
  95         return *this;
  96     }
  97
  98     template <typename T> template <typename U> inline OwnPtr<T>& OwnPtr<T>::operator=(const PassOwnPtr<U>& o)
  99     {
 100         T* ptr = m_ptr;
 101         m_ptr = o.release();
 102         ASSERT(!ptr || m_ptr != ptr);
 103         if (ptr)
 104             deleteOwnedPtr(ptr);
 105         return *this;
 106     }
 107
 108     template <typename T> inline void swap(OwnPtr<T>& a, OwnPtr<T>& b)
 109     {
 110         a.swap(b);
 111     }
 112
 113     template <typename T, typename U> inline bool operator==(const OwnPtr<T>& a, U* b)
 114     {
 115         return a.get() == b;
 116     }
 117
 118     template <typename T, typename U> inline bool operator==(T* a, const OwnPtr<U>& b)
 119     {
 120         return a == b.get();
 121     }
 122
 123     template <typename T, typename U> inline bool operator!=(const OwnPtr<T>& a, U* b)
 124     {
 125         return a.get() != b;
 126     }
 127
 128     template <typename T, typename U> inline bool operator!=(T* a, const OwnPtr<U>& b)
 129     {
 130         return a != b.get();
 131     }
 132
 133     template <typename T> inline typename OwnPtr<T>::PtrType getPtr(const OwnPtr<T>& p)
 134     {
 135         return p.get();
 136     }
 137
 138 } // namespace WTF
 139
 140 using WTF::OwnPtr;
 141
 142 #endif // WTF_OwnPtr_h