Source/WebKit2/UIProcess/API/cpp/WKRetainPtr.h

   1 /*
   2  * Copyright (C) 2010 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef WKRetainPtr_h
  27 #define WKRetainPtr_h
  28
  29 #include <WebKit2/WKType.h>
  30 #include <algorithm>
  31
  32 namespace WebKit {
  33
  34 enum WKAdoptTag { AdoptWK };
  35
  36 template<typename T> class WKRetainPtr {
  37 public:
  38     typedef T PtrType;
  39
  40     WKRetainPtr()
  41         : m_ptr(0)
  42     {
  43     }
  44
  45     WKRetainPtr(PtrType ptr)
  46         : m_ptr(ptr)
  47     {
  48         if (ptr)
  49             WKRetain(ptr);
  50     }
  51
  52     WKRetainPtr(WKAdoptTag, PtrType ptr)
  53         : m_ptr(ptr)
  54     {
  55     }
  56
  57     template<typename U> WKRetainPtr(const WKRetainPtr<U>& o)
  58         : m_ptr(o.get())
  59     {
  60         if (PtrType ptr = m_ptr)
  61             WKRetain(ptr);
  62     }
  63
  64     WKRetainPtr(const WKRetainPtr& o)
  65         : m_ptr(o.m_ptr)
  66     {
  67         if (PtrType ptr = m_ptr)
  68             WKRetain(ptr);
  69     }
  70
  71     ~WKRetainPtr()
  72     {
  73         if (PtrType ptr = m_ptr)
  74             WKRelease(ptr);
  75     }
  76
  77     PtrType get() const { return m_ptr; }
  78
  79     void clear()
  80     {
  81         PtrType ptr = m_ptr;
  82         m_ptr = 0;
  83         if (ptr)
  84             WKRelease(ptr);
  85     }
  86
  87     PtrType leakRef()
  88     {
  89         PtrType ptr = m_ptr;
  90         m_ptr = 0;
  91         return ptr;
  92     }
  93
  94     PtrType operator->() const { return m_ptr; }
  95     bool operator!() const { return !m_ptr; }
  96
  97     // This conversion operator allows implicit conversion to bool but not to other integer types.
  98     typedef PtrType WKRetainPtr::*UnspecifiedBoolType;
  99     operator UnspecifiedBoolType() const { return m_ptr ? &WKRetainPtr::m_ptr : 0; }
 100
 101     WKRetainPtr& operator=(const WKRetainPtr&);
 102     template<typename U> WKRetainPtr& operator=(const WKRetainPtr<U>&);
 103     WKRetainPtr& operator=(PtrType);
 104     template<typename U> WKRetainPtr& operator=(U*);
 105
 106     void adopt(PtrType);
 107     void swap(WKRetainPtr&);
 108
 109 private:
 110     PtrType m_ptr;
 111 };
 112
 113 template<typename T> inline WKRetainPtr<T>& WKRetainPtr<T>::operator=(const WKRetainPtr<T>& o)
 114 {
 115     PtrType optr = o.get();
 116     if (optr)
 117         WKRetain(optr);
 118     PtrType ptr = m_ptr;
 119     m_ptr = optr;
 120     if (ptr)
 121         WKRelease(ptr);
 122     return *this;
 123 }
 124
 125 template<typename T> template<typename U> inline WKRetainPtr<T>& WKRetainPtr<T>::operator=(const WKRetainPtr<U>& o)
 126 {
 127     PtrType optr = o.get();
 128     if (optr)
 129         WKRetain(optr);
 130     PtrType ptr = m_ptr;
 131     m_ptr = optr;
 132     if (ptr)
 133         WKRelease(ptr);
 134     return *this;
 135 }
 136
 137 template<typename T> inline WKRetainPtr<T>& WKRetainPtr<T>::operator=(PtrType optr)
 138 {
 139     if (optr)
 140         WKRetain(optr);
 141     PtrType ptr = m_ptr;
 142     m_ptr = optr;
 143     if (ptr)
 144         WKRelease(ptr);
 145     return *this;
 146 }
 147
 148 template<typename T> inline void WKRetainPtr<T>::adopt(PtrType optr)
 149 {
 150     PtrType ptr = m_ptr;
 151     m_ptr = optr;
 152     if (ptr)
 153         WKRelease(ptr);
 154 }
 155
 156 template<typename T> template<typename U> inline WKRetainPtr<T>& WKRetainPtr<T>::operator=(U* optr)
 157 {
 158     if (optr)
 159         WKRetain(optr);
 160     PtrType ptr = m_ptr;
 161     m_ptr = optr;
 162     if (ptr)
 163         WKRelease(ptr);
 164     return *this;
 165 }
 166
 167 template<typename T> inline void WKRetainPtr<T>::swap(WKRetainPtr<T>& o)
 168 {
 169     std::swap(m_ptr, o.m_ptr);
 170 }
 171
 172 template<typename T> inline void swap(WKRetainPtr<T>& a, WKRetainPtr<T>& b)
 173 {
 174     a.swap(b);
 175 }
 176
 177 template<typename T, typename U> inline bool operator==(const WKRetainPtr<T>& a, const WKRetainPtr<U>& b)
 178 {
 179     return a.get() == b.get();
 180 }
 181
 182 template<typename T, typename U> inline bool operator==(const WKRetainPtr<T>& a, U* b)
 183 {
 184     return a.get() == b;
 185 }
 186
 187 template<typename T, typename U> inline bool operator==(T* a, const WKRetainPtr<U>& b)
 188 {
 189     return a == b.get();
 190 }
 191
 192 template<typename T, typename U> inline bool operator!=(const WKRetainPtr<T>& a, const WKRetainPtr<U>& b)
 193 {
 194     return a.get() != b.get();
 195 }
 196
 197 template<typename T, typename U> inline bool operator!=(const WKRetainPtr<T>& a, U* b)
 198 {
 199     return a.get() != b;
 200 }
 201
 202 template<typename T, typename U> inline bool operator!=(T* a, const WKRetainPtr<U>& b)
 203 {
 204     return a != b.get();
 205 }
 206
 207 template<typename T> static inline WKRetainPtr<T> adoptWK(T o)
 208 {
 209     return WKRetainPtr<T>(AdoptWK, o);
 210 }
 211
 212 } // namespace WebKit
 213
 214 using WebKit::WKRetainPtr;
 215 using WebKit::AdoptWK;
 216 using WebKit::adoptWK;
 217
 218 #endif // WKRetainPtr_h