1 | /* |
2 | * Copyright (C) 2005, 2006, 2007 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 | * |
8 | * 1. Redistributions of source code must retain the above copyright |
9 | * notice, this list of conditions and the following disclaimer. |
10 | * 2. Redistributions in binary form must reproduce the above copyright |
11 | * notice, this list of conditions and the following disclaimer in the |
12 | * documentation and/or other materials provided with the distribution. |
13 | * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of |
14 | * its contributors may be used to endorse or promote products derived |
15 | * from this software without specific prior written permission. |
16 | * |
17 | * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY |
18 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
19 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
20 | * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY |
21 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
22 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
23 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
24 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
27 | */ |
28 | |
29 | #ifndef JSRetainPtr_h |
30 | #define JSRetainPtr_h |
31 | |
32 | #include <JavaScriptCore/JSStringRef.h> |
33 | #include <algorithm> |
34 | |
35 | inline void JSRetain(JSStringRef string) { JSStringRetain(string); } |
36 | inline void JSRelease(JSStringRef string) { JSStringRelease(string); } |
37 | |
38 | enum AdoptTag { Adopt }; |
39 | |
40 | template <typename T> class JSRetainPtr { |
41 | public: |
42 | JSRetainPtr() : m_ptr(0) {} |
43 | JSRetainPtr(T ptr) : m_ptr(ptr) { if (ptr) JSRetain(ptr); } |
44 | |
45 | JSRetainPtr(AdoptTag, T ptr) : m_ptr(ptr) { } |
46 | |
47 | JSRetainPtr(const JSRetainPtr& o) : m_ptr(o.m_ptr) { if (T ptr = m_ptr) JSRetain(ptr); } |
48 | |
49 | ~JSRetainPtr() { if (T ptr = m_ptr) JSRelease(ptr); } |
50 | |
51 | template <typename U> JSRetainPtr(const JSRetainPtr<U>& o) : m_ptr(o.get()) { if (T ptr = m_ptr) JSRetain(ptr); } |
52 | |
53 | T get() const { return m_ptr; } |
54 | |
55 | T releaseRef() { T tmp = m_ptr; m_ptr = 0; return tmp; } |
56 | |
57 | T operator->() const { return m_ptr; } |
58 | |
59 | bool operator!() const { return !m_ptr; } |
60 | |
61 | // This conversion operator allows implicit conversion to bool but not to other integer types. |
62 | typedef T JSRetainPtr::*UnspecifiedBoolType; |
63 | operator UnspecifiedBoolType() const { return m_ptr ? &JSRetainPtr::m_ptr : 0; } |
64 | |
65 | JSRetainPtr& operator=(const JSRetainPtr&); |
66 | template <typename U> JSRetainPtr& operator=(const JSRetainPtr<U>&); |
67 | JSRetainPtr& operator=(T); |
68 | template <typename U> JSRetainPtr& operator=(U*); |
69 | |
70 | void adopt(T); |
71 | |
72 | void swap(JSRetainPtr&); |
73 | |
74 | private: |
75 | T m_ptr; |
76 | }; |
77 | |
78 | template <typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<T>& o) |
79 | { |
80 | T optr = o.get(); |
81 | if (optr) |
82 | JSRetain(optr); |
83 | T ptr = m_ptr; |
84 | m_ptr = optr; |
85 | if (ptr) |
86 | JSRelease(ptr); |
87 | return *this; |
88 | } |
89 | |
90 | template <typename T> template <typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<U>& o) |
91 | { |
92 | T optr = o.get(); |
93 | if (optr) |
94 | JSRetain(optr); |
95 | T ptr = m_ptr; |
96 | m_ptr = optr; |
97 | if (ptr) |
98 | JSRelease(ptr); |
99 | return *this; |
100 | } |
101 | |
102 | template <typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(T optr) |
103 | { |
104 | if (optr) |
105 | JSRetain(optr); |
106 | T ptr = m_ptr; |
107 | m_ptr = optr; |
108 | if (ptr) |
109 | JSRelease(ptr); |
110 | return *this; |
111 | } |
112 | |
113 | template <typename T> inline void JSRetainPtr<T>::adopt(T optr) |
114 | { |
115 | T ptr = m_ptr; |
116 | m_ptr = optr; |
117 | if (ptr) |
118 | JSRelease(ptr); |
119 | } |
120 | |
121 | template <typename T> template <typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(U* optr) |
122 | { |
123 | if (optr) |
124 | JSRetain(optr); |
125 | T ptr = m_ptr; |
126 | m_ptr = optr; |
127 | if (ptr) |
128 | JSRelease(ptr); |
129 | return *this; |
130 | } |
131 | |
132 | template <class T> inline void JSRetainPtr<T>::swap(JSRetainPtr<T>& o) |
133 | { |
134 | std::swap(m_ptr, o.m_ptr); |
135 | } |
136 | |
137 | template <class T> inline void swap(JSRetainPtr<T>& a, JSRetainPtr<T>& b) |
138 | { |
139 | a.swap(b); |
140 | } |
141 | |
142 | template <typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b) |
143 | { |
144 | return a.get() == b.get(); |
145 | } |
146 | |
147 | template <typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, U* b) |
148 | { |
149 | return a.get() == b; |
150 | } |
151 | |
152 | template <typename T, typename U> inline bool operator==(T* a, const JSRetainPtr<U>& b) |
153 | { |
154 | return a == b.get(); |
155 | } |
156 | |
157 | template <typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b) |
158 | { |
159 | return a.get() != b.get(); |
160 | } |
161 | |
162 | template <typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, U* b) |
163 | { |
164 | return a.get() != b; |
165 | } |
166 | |
167 | template <typename T, typename U> inline bool operator!=(T* a, const JSRetainPtr<U>& b) |
168 | { |
169 | return a != b.get(); |
170 | } |
171 | |
172 | |
173 | #endif // JSRetainPtr_h |
174 | |