wtf/gobject/GRefPtr.h

   1 /*
   2  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   3  *  Copyright (C) 2008 Collabora Ltd.
   4  *  Copyright (C) 2009 Martin Robinson
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Library General Public
   8  *  License as published by the Free Software Foundation; either
   9  *  version 2 of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Library General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Library General Public License
  17  *  along with this library; see the file COPYING.LIB.  If not, write to
  18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301, USA.
  20  *
  21  */
  22
  23 #ifndef WTF_GRefPtr_h
  24 #define WTF_GRefPtr_h
  25
  26 #if ENABLE(GLIB_SUPPORT)
  27
  28 #include "AlwaysInline.h"
  29 #include "GRefPtr.h"
  30 #include "RefPtr.h"
  31 #include <algorithm>
  32
  33 extern "C" void g_object_unref(gpointer);
  34 extern "C" gpointer g_object_ref_sink(gpointer);
  35
  36 namespace WTF {
  37
  38 enum GRefPtrAdoptType { GRefPtrAdopt };
  39 template <typename T> inline T* refGPtr(T*);
  40 template <typename T> inline void derefGPtr(T*);
  41 template <typename T> class GRefPtr;
  42 template <typename T> GRefPtr<T> adoptGRef(T*);
  43
  44 template <typename T> class GRefPtr {
  45 public:
  46     GRefPtr() : m_ptr(0) { }
  47
  48     GRefPtr(T* ptr)
  49         : m_ptr(ptr)
  50     {
  51         if (ptr)
  52             refGPtr(ptr);
  53     }
  54
  55     GRefPtr(const GRefPtr& o)
  56         : m_ptr(o.m_ptr)
  57     {
  58         if (T* ptr = m_ptr)
  59             refGPtr(ptr);
  60     }
  61
  62     template <typename U> GRefPtr(const GRefPtr<U>& o)
  63         : m_ptr(o.get())
  64     {
  65         if (T* ptr = m_ptr)
  66             refGPtr(ptr);
  67     }
  68
  69     ~GRefPtr()
  70     {
  71         if (T* ptr = m_ptr)
  72             derefGPtr(ptr);
  73     }
  74
  75     void clear()
  76     {
  77         T* ptr = m_ptr;
  78         m_ptr = 0;
  79         if (ptr)
  80             derefGPtr(ptr);
  81     }
  82
  83     T* leakRef() WARN_UNUSED_RETURN
  84     {
  85         T* ptr = m_ptr;
  86         m_ptr = 0;
  87         return ptr;
  88     }
  89
  90     // Hash table deleted values, which are only constructed and never copied or destroyed.
  91     GRefPtr(HashTableDeletedValueType) : m_ptr(hashTableDeletedValue()) { }
  92     bool isHashTableDeletedValue() const { return m_ptr == hashTableDeletedValue(); }
  93
  94     T* get() const { return m_ptr; }
  95     T& operator*() const { return *m_ptr; }
  96     ALWAYS_INLINE T* operator->() const { return m_ptr; }
  97
  98     bool operator!() const { return !m_ptr; }
  99
 100     // This conversion operator allows implicit conversion to bool but not to other integer types.
 101     typedef T* GRefPtr::*UnspecifiedBoolType;
 102     operator UnspecifiedBoolType() const { return m_ptr ? &GRefPtr::m_ptr : 0; }
 103
 104     GRefPtr& operator=(const GRefPtr&);
 105     GRefPtr& operator=(T*);
 106     template <typename U> GRefPtr& operator=(const GRefPtr<U>&);
 107
 108     void swap(GRefPtr&);
 109     friend GRefPtr adoptGRef<T>(T*);
 110
 111 private:
 112     static T* hashTableDeletedValue() { return reinterpret_cast<T*>(-1); }
 113     // Adopting constructor.
 114     GRefPtr(T* ptr, GRefPtrAdoptType) : m_ptr(ptr) {}
 115
 116     T* m_ptr;
 117 };
 118
 119 template <typename T> inline GRefPtr<T>& GRefPtr<T>::operator=(const GRefPtr<T>& o)
 120 {
 121     T* optr = o.get();
 122     if (optr)
 123         refGPtr(optr);
 124     T* ptr = m_ptr;
 125     m_ptr = optr;
 126     if (ptr)
 127         derefGPtr(ptr);
 128     return *this;
 129 }
 130
 131 template <typename T> inline GRefPtr<T>& GRefPtr<T>::operator=(T* optr)
 132 {
 133     T* ptr = m_ptr;
 134     if (optr)
 135         refGPtr(optr);
 136     m_ptr = optr;
 137     if (ptr)
 138         derefGPtr(ptr);
 139     return *this;
 140 }
 141
 142 template <class T> inline void GRefPtr<T>::swap(GRefPtr<T>& o)
 143 {
 144     std::swap(m_ptr, o.m_ptr);
 145 }
 146
 147 template <class T> inline void swap(GRefPtr<T>& a, GRefPtr<T>& b)
 148 {
 149     a.swap(b);
 150 }
 151
 152 template <typename T, typename U> inline bool operator==(const GRefPtr<T>& a, const GRefPtr<U>& b)
 153 {
 154     return a.get() == b.get();
 155 }
 156
 157 template <typename T, typename U> inline bool operator==(const GRefPtr<T>& a, U* b)
 158 {
 159     return a.get() == b;
 160 }
 161
 162 template <typename T, typename U> inline bool operator==(T* a, const GRefPtr<U>& b)
 163 {
 164     return a == b.get();
 165 }
 166
 167 template <typename T, typename U> inline bool operator!=(const GRefPtr<T>& a, const GRefPtr<U>& b)
 168 {
 169     return a.get() != b.get();
 170 }
 171
 172 template <typename T, typename U> inline bool operator!=(const GRefPtr<T>& a, U* b)
 173 {
 174     return a.get() != b;
 175 }
 176
 177 template <typename T, typename U> inline bool operator!=(T* a, const GRefPtr<U>& b)
 178 {
 179     return a != b.get();
 180 }
 181
 182 template <typename T, typename U> inline GRefPtr<T> static_pointer_cast(const GRefPtr<U>& p)
 183 {
 184     return GRefPtr<T>(static_cast<T*>(p.get()));
 185 }
 186
 187 template <typename T, typename U> inline GRefPtr<T> const_pointer_cast(const GRefPtr<U>& p)
 188 {
 189     return GRefPtr<T>(const_cast<T*>(p.get()));
 190 }
 191
 192 template <typename T> inline T* getPtr(const GRefPtr<T>& p)
 193 {
 194     return p.get();
 195 }
 196
 197 template <typename T> GRefPtr<T> adoptGRef(T* p)
 198 {
 199     return GRefPtr<T>(p, GRefPtrAdopt);
 200 }
 201
 202 template <> GHashTable* refGPtr(GHashTable* ptr);
 203 template <> void derefGPtr(GHashTable* ptr);
 204 template <> GVariant* refGPtr(GVariant* ptr);
 205 template <> void derefGPtr(GVariant* ptr);
 206 template <> GSource* refGPtr(GSource* ptr);
 207 template <> void derefGPtr(GSource* ptr);
 208
 209 template <typename T> inline T* refGPtr(T* ptr)
 210 {
 211     if (ptr)
 212         g_object_ref_sink(ptr);
 213     return ptr;
 214 }
 215
 216 template <typename T> inline void derefGPtr(T* ptr)
 217 {
 218     if (ptr)
 219         g_object_unref(ptr);
 220 }
 221
 222 } // namespace WTF
 223
 224 using WTF::GRefPtr;
 225 using WTF::adoptGRef;
 226
 227 #endif // ENABLE(GLIB_SUPPORT)
 228
 229 #endif // WTF_GRefPtr_h