e400840803c71087cc7d6d6ef48ce41076fb8260
[WebKit-https.git] / Source / JavaScriptCore / API / JSRetainPtr.h
1 /*
2  * Copyright (C) 2005, 2006, 2007, 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  *
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 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/JSContextRef.h>
33 #include <JavaScriptCore/JSStringRef.h>
34 #include <algorithm>
35
36 inline void JSRetain(JSStringRef string) { JSStringRetain(string); }
37 inline void JSRelease(JSStringRef string) { JSStringRelease(string); }
38 inline void JSRetain(JSGlobalContextRef context) { JSGlobalContextRetain(context); }
39 inline void JSRelease(JSGlobalContextRef context) { JSGlobalContextRelease(context); }
40
41 enum AdoptTag { Adopt };
42
43 template<typename T> class JSRetainPtr {
44 public:
45     JSRetainPtr() : m_ptr(0) { }
46     JSRetainPtr(T ptr) : m_ptr(ptr) { if (ptr) JSRetain(ptr); }
47     JSRetainPtr(AdoptTag, T ptr) : m_ptr(ptr) { }
48     JSRetainPtr(const JSRetainPtr&);
49     template<typename U> JSRetainPtr(const JSRetainPtr<U>&);
50     ~JSRetainPtr();
51     
52     T get() const { return m_ptr; }
53     
54     void clear();
55     T leakRef();
56
57     T operator->() const { return m_ptr; }
58     
59     bool operator!() const { return !m_ptr; }
60     explicit operator bool() const { return m_ptr; }
61
62     JSRetainPtr& operator=(const JSRetainPtr&);
63     template<typename U> JSRetainPtr& operator=(const JSRetainPtr<U>&);
64     JSRetainPtr& operator=(T);
65     template<typename U> JSRetainPtr& operator=(U*);
66
67     void adopt(T);
68     
69     void swap(JSRetainPtr&);
70
71 private:
72     T m_ptr;
73 };
74
75 inline JSRetainPtr<JSStringRef> adopt(JSStringRef o)
76 {
77     return JSRetainPtr<JSStringRef>(Adopt, o);
78 }
79
80 inline JSRetainPtr<JSGlobalContextRef> adopt(JSGlobalContextRef o)
81 {
82     return JSRetainPtr<JSGlobalContextRef>(Adopt, o);
83 }
84
85 template<typename T> inline JSRetainPtr<T>::JSRetainPtr(const JSRetainPtr& o)
86     : m_ptr(o.m_ptr)
87 {
88     if (m_ptr)
89         JSRetain(m_ptr);
90 }
91
92 template<typename T> template<typename U> inline JSRetainPtr<T>::JSRetainPtr(const JSRetainPtr<U>& o)
93     : m_ptr(o.get())
94 {
95     if (m_ptr)
96         JSRetain(m_ptr);
97 }
98
99 template<typename T> inline JSRetainPtr<T>::~JSRetainPtr()
100 {
101     if (m_ptr)
102         JSRelease(m_ptr);
103 }
104
105 template<typename T> inline void JSRetainPtr<T>::clear()
106 {
107     if (T ptr = m_ptr) {
108         m_ptr = 0;
109         JSRelease(ptr);
110     }
111 }
112
113 template<typename T> inline T JSRetainPtr<T>::leakRef()
114 {
115     T ptr = m_ptr;
116     m_ptr = 0;
117     return ptr;
118 }
119
120 template<typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<T>& o)
121 {
122     T optr = o.get();
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<typename T> template<typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(const JSRetainPtr<U>& o)
133 {
134     T optr = o.get();
135     if (optr)
136         JSRetain(optr);
137     T ptr = m_ptr;
138     m_ptr = optr;
139     if (ptr)
140         JSRelease(ptr);
141     return *this;
142 }
143
144 template<typename T> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(T optr)
145 {
146     if (optr)
147         JSRetain(optr);
148     T ptr = m_ptr;
149     m_ptr = optr;
150     if (ptr)
151         JSRelease(ptr);
152     return *this;
153 }
154
155 template<typename T> inline void JSRetainPtr<T>::adopt(T optr)
156 {
157     T ptr = m_ptr;
158     m_ptr = optr;
159     if (ptr)
160         JSRelease(ptr);
161 }
162
163 template<typename T> template<typename U> inline JSRetainPtr<T>& JSRetainPtr<T>::operator=(U* optr)
164 {
165     if (optr)
166         JSRetain(optr);
167     T ptr = m_ptr;
168     m_ptr = optr;
169     if (ptr)
170         JSRelease(ptr);
171     return *this;
172 }
173
174 template<typename T> inline void JSRetainPtr<T>::swap(JSRetainPtr<T>& o)
175 {
176     std::swap(m_ptr, o.m_ptr);
177 }
178
179 template<typename T> inline void swap(JSRetainPtr<T>& a, JSRetainPtr<T>& b)
180 {
181     a.swap(b);
182 }
183
184 template<typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
185
186     return a.get() == b.get(); 
187 }
188
189 template<typename T, typename U> inline bool operator==(const JSRetainPtr<T>& a, U* b)
190
191     return a.get() == b; 
192 }
193
194 template<typename T, typename U> inline bool operator==(T* a, const JSRetainPtr<U>& b) 
195 {
196     return a == b.get(); 
197 }
198
199 template<typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, const JSRetainPtr<U>& b)
200
201     return a.get() != b.get(); 
202 }
203
204 template<typename T, typename U> inline bool operator!=(const JSRetainPtr<T>& a, U* b)
205 {
206     return a.get() != b; 
207 }
208
209 template<typename T, typename U> inline bool operator!=(T* a, const JSRetainPtr<U>& b)
210
211     return a != b.get(); 
212 }
213
214
215 #endif // JSRetainPtr_h