wtf/RetainPtr.h

   1 /*
   2  *  Copyright (C) 2005, 2006, 2007, 2008 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 RetainPtr_h
  22 #define RetainPtr_h
  23
  24 #include "TypeTraits.h"
  25 #include <algorithm>
  26 #include <CoreFoundation/CoreFoundation.h>
  27
  28 #ifdef __OBJC__
  29 #import <Foundation/Foundation.h>
  30 #endif
  31
  32 namespace WTF {
  33
  34     // Unlike most most of our smart pointers, RetainPtr can take either the pointer type or the pointed-to type,
  35     // so both RetainPtr<NSDictionary> and RetainPtr<CFDictionaryRef> will work.
  36
  37     enum AdoptCFTag { AdoptCF };
  38     enum AdoptNSTag { AdoptNS };
  39
  40 #ifdef __OBJC__
  41     inline void adoptNSReference(id ptr)
  42     {
  43         if (ptr) {
  44             CFRetain(ptr);
  45             [ptr release];
  46         }
  47     }
  48 #endif
  49
  50     template <typename T> class RetainPtr {
  51     public:
  52         typedef typename RemovePointer<T>::Type ValueType;
  53         typedef ValueType* PtrType;
  54
  55         RetainPtr() : m_ptr(0) {}
  56         RetainPtr(PtrType ptr) : m_ptr(ptr) { if (ptr) CFRetain(ptr); }
  57
  58         RetainPtr(AdoptCFTag, PtrType ptr) : m_ptr(ptr) { }
  59         RetainPtr(AdoptNSTag, PtrType ptr) : m_ptr(ptr) { adoptNSReference(ptr); }
  60
  61         RetainPtr(const RetainPtr& o) : m_ptr(o.m_ptr) { if (PtrType ptr = m_ptr) CFRetain(ptr); }
  62
  63         ~RetainPtr() { if (PtrType ptr = m_ptr) CFRelease(ptr); }
  64
  65         template <typename U> RetainPtr(const RetainPtr<U>& o) : m_ptr(o.get()) { if (PtrType ptr = m_ptr) CFRetain(ptr); }
  66
  67         PtrType get() const { return m_ptr; }
  68
  69         PtrType releaseRef() { PtrType tmp = m_ptr; m_ptr = 0; return tmp; }
  70
  71         PtrType operator->() const { return m_ptr; }
  72
  73         bool operator!() const { return !m_ptr; }
  74
  75         // This conversion operator allows implicit conversion to bool but not to other integer types.
  76         typedef PtrType RetainPtr::*UnspecifiedBoolType;
  77         operator UnspecifiedBoolType() const { return m_ptr ? &RetainPtr::m_ptr : 0; }
  78
  79         RetainPtr& operator=(const RetainPtr&);
  80         template <typename U> RetainPtr& operator=(const RetainPtr<U>&);
  81         RetainPtr& operator=(PtrType);
  82         template <typename U> RetainPtr& operator=(U*);
  83
  84         void adoptCF(PtrType);
  85         void adoptNS(PtrType);
  86
  87         void swap(RetainPtr&);
  88
  89     private:
  90         PtrType m_ptr;
  91     };
  92
  93     template <typename T> inline RetainPtr<T>& RetainPtr<T>::operator=(const RetainPtr<T>& o)
  94     {
  95         PtrType optr = o.get();
  96         if (optr)
  97             CFRetain(optr);
  98         PtrType ptr = m_ptr;
  99         m_ptr = optr;
 100         if (ptr)
 101             CFRelease(ptr);
 102         return *this;
 103     }
 104
 105     template <typename T> template <typename U> inline RetainPtr<T>& RetainPtr<T>::operator=(const RetainPtr<U>& o)
 106     {
 107         PtrType optr = o.get();
 108         if (optr)
 109             CFRetain(optr);
 110         PtrType ptr = m_ptr;
 111         m_ptr = optr;
 112         if (ptr)
 113             CFRelease(ptr);
 114         return *this;
 115     }
 116
 117     template <typename T> inline RetainPtr<T>& RetainPtr<T>::operator=(PtrType optr)
 118     {
 119         if (optr)
 120             CFRetain(optr);
 121         PtrType ptr = m_ptr;
 122         m_ptr = optr;
 123         if (ptr)
 124             CFRelease(ptr);
 125         return *this;
 126     }
 127
 128     template <typename T> inline void RetainPtr<T>::adoptCF(PtrType optr)
 129     {
 130         PtrType ptr = m_ptr;
 131         m_ptr = optr;
 132         if (ptr)
 133             CFRelease(ptr);
 134     }
 135
 136     template <typename T> inline void RetainPtr<T>::adoptNS(PtrType optr)
 137     {
 138         adoptNSReference(optr);
 139
 140         PtrType ptr = m_ptr;
 141         m_ptr = optr;
 142         if (ptr)
 143             CFRelease(ptr);
 144     }
 145
 146     template <typename T> template <typename U> inline RetainPtr<T>& RetainPtr<T>::operator=(U* optr)
 147     {
 148         if (optr)
 149             CFRetain(optr);
 150         PtrType ptr = m_ptr;
 151         m_ptr = optr;
 152         if (ptr)
 153             CFRelease(ptr);
 154         return *this;
 155     }
 156
 157     template <class T> inline void RetainPtr<T>::swap(RetainPtr<T>& o)
 158     {
 159         std::swap(m_ptr, o.m_ptr);
 160     }
 161
 162     template <class T> inline void swap(RetainPtr<T>& a, RetainPtr<T>& b)
 163     {
 164         a.swap(b);
 165     }
 166
 167     template <typename T, typename U> inline bool operator==(const RetainPtr<T>& a, const RetainPtr<U>& b)
 168     {
 169         return a.get() == b.get();
 170     }
 171
 172     template <typename T, typename U> inline bool operator==(const RetainPtr<T>& a, U* b)
 173     {
 174         return a.get() == b;
 175     }
 176
 177     template <typename T, typename U> inline bool operator==(T* a, const RetainPtr<U>& b)
 178     {
 179         return a == b.get();
 180     }
 181
 182     template <typename T, typename U> inline bool operator!=(const RetainPtr<T>& a, const RetainPtr<U>& b)
 183     {
 184         return a.get() != b.get();
 185     }
 186
 187     template <typename T, typename U> inline bool operator!=(const RetainPtr<T>& a, U* b)
 188     {
 189         return a.get() != b;
 190     }
 191
 192     template <typename T, typename U> inline bool operator!=(T* a, const RetainPtr<U>& b)
 193     {
 194         return a != b.get();
 195     }
 196
 197 } // namespace WTF
 198
 199 using WTF::AdoptCF;
 200 using WTF::AdoptNS;
 201 using WTF::RetainPtr;
 202
 203 #endif // WTF_RetainPtr_h