• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.11.5 API Reference
  • KDE Home
  • Contact Us
 

WTF

  • kjs
  • wtf
PassRefPtr.h
Go to the documentation of this file.
1 // -*- mode: c++; c-basic-offset: 4 -*-
2 /*
3  * Copyright (C) 2005, 2006, 2007 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB. If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21 
22 #ifndef WTF_PassRefPtr_h
23 #define WTF_PassRefPtr_h
24 
25 #include "AlwaysInline.h"
26 
27 namespace WTF {
28 
29  template<typename T> class RefPtr;
30  template<typename T> class PassRefPtr;
31  template <typename T> PassRefPtr<T> adoptRef(T*);
32 
33  template<typename T> class PassRefPtr {
34  public:
35  PassRefPtr() : m_ptr(0) {}
36  PassRefPtr(T* ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
37  // It somewhat breaks the type system to allow transfer of ownership out of
38  // a const PassRefPtr. However, it makes it much easier to work with PassRefPtr
39  // temporaries, and we don't really have a need to use real const PassRefPtrs
40  // anyway.
41  PassRefPtr(const PassRefPtr& o) : m_ptr(o.releaseRef()) {}
42  template <typename U> PassRefPtr(const PassRefPtr<U>& o) : m_ptr(o.releaseRef()) { }
43 
44  ALWAYS_INLINE ~PassRefPtr() { if (T* ptr = m_ptr) ptr->deref(); }
45 
46  template <class U>
47  PassRefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T* ptr = m_ptr) ptr->ref(); }
48 
49  T* get() const { return m_ptr; }
50 
51  void clear() { if (T* ptr = m_ptr) ptr->deref(); m_ptr = 0; }
52  T* releaseRef() const { T* tmp = m_ptr; m_ptr = 0; return tmp; }
53 
54  T& operator*() const { return *m_ptr; }
55  T* operator->() const { return m_ptr; }
56 
57  bool operator!() const { return !m_ptr; }
58 
59  // This conversion operator allows implicit conversion to bool but not to other integer types.
60  typedef T* PassRefPtr::*UnspecifiedBoolType;
61  operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : 0; }
62 
63  PassRefPtr& operator=(T*);
64  PassRefPtr& operator=(const PassRefPtr&);
65  template <typename U> PassRefPtr& operator=(const PassRefPtr<U>&);
66  template <typename U> PassRefPtr& operator=(const RefPtr<U>&);
67 
68  friend PassRefPtr adoptRef<T>(T*);
69  private:
70  // adopting constructor
71  PassRefPtr(T* ptr, bool) : m_ptr(ptr) {}
72  mutable T* m_ptr;
73  };
74 
75  template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const RefPtr<U>& o)
76  {
77  T* optr = o.get();
78  if (optr)
79  optr->ref();
80  T* ptr = m_ptr;
81  m_ptr = optr;
82  if (ptr)
83  ptr->deref();
84  return *this;
85  }
86 
87  template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(T* optr)
88  {
89  if (optr)
90  optr->ref();
91  T* ptr = m_ptr;
92  m_ptr = optr;
93  if (ptr)
94  ptr->deref();
95  return *this;
96  }
97 
98  template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<T>& ref)
99  {
100  T* ptr = m_ptr;
101  m_ptr = ref.releaseRef();
102  if (ptr)
103  ptr->deref();
104  return *this;
105  }
106 
107  template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<U>& ref)
108  {
109  T* ptr = m_ptr;
110  m_ptr = ref.releaseRef();
111  if (ptr)
112  ptr->deref();
113  return *this;
114  }
115 
116  template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const PassRefPtr<U>& b)
117  {
118  return a.get() == b.get();
119  }
120 
121  template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, const RefPtr<U>& b)
122  {
123  return a.get() == b.get();
124  }
125 
126  template <typename T, typename U> inline bool operator==(const RefPtr<T>& a, const PassRefPtr<U>& b)
127  {
128  return a.get() == b.get();
129  }
130 
131  template <typename T, typename U> inline bool operator==(const PassRefPtr<T>& a, U* b)
132  {
133  return a.get() == b;
134  }
135 
136  template <typename T, typename U> inline bool operator==(T* a, const PassRefPtr<U>& b)
137  {
138  return a == b.get();
139  }
140 
141  template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const PassRefPtr<U>& b)
142  {
143  return a.get() != b.get();
144  }
145 
146  template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, const RefPtr<U>& b)
147  {
148  return a.get() != b.get();
149  }
150 
151  template <typename T, typename U> inline bool operator!=(const RefPtr<T>& a, const PassRefPtr<U>& b)
152  {
153  return a.get() != b.get();
154  }
155 
156  template <typename T, typename U> inline bool operator!=(const PassRefPtr<T>& a, U* b)
157  {
158  return a.get() != b;
159  }
160 
161  template <typename T, typename U> inline bool operator!=(T* a, const PassRefPtr<U>& b)
162  {
163  return a != b.get();
164  }
165 
166  template <typename T> inline PassRefPtr<T> adoptRef(T* p)
167  {
168  return PassRefPtr<T>(p, true);
169  }
170 
171  template <typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p)
172  {
173  return adoptRef(static_cast<T*>(p.releaseRef()));
174  }
175 
176  template <typename T, typename U> inline PassRefPtr<T> const_pointer_cast(const PassRefPtr<U>& p)
177  {
178  return adoptRef(const_cast<T*>(p.releaseRef()));
179  }
180 
181  template <typename T> inline T* getPtr(const PassRefPtr<T>& p)
182  {
183  return p.get();
184  }
185 
186 } // namespace WTF
187 
188 using WTF::PassRefPtr;
189 using WTF::adoptRef;
190 using WTF::static_pointer_cast;
191 using WTF::const_pointer_cast;
192 
193 #endif // WTF_PassRefPtr_h
This file is part of the KDE documentation.
Documentation copyright © 1996-2014 The KDE developers.
Generated on Mon May 5 2014 18:09:29 by doxygen 1.8.3.1 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

WTF

Skip menu "WTF"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.11.5 API Reference

Skip menu "kdelibs-4.11.5 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal