Move JavaScriptCore to Source
[WebKit-https.git] / Source / JavaScriptCore / runtime / Protect.h
1 /*
2  *  Copyright (C) 2004, 2008, 2009 Apple Inc. All rights reserved.
3  *
4  *  This library is free software; you can redistribute it and/or
5  *  modify it under the terms of the GNU Library General Public
6  *  License as published by the Free Software Foundation; either
7  *  version 2 of the License, or (at your option) any later version.
8  *
9  *  This library is distributed in the hope that it will be useful,
10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  *  Library General Public License for more details.
13  *
14  *  You should have received a copy of the GNU Library General Public License
15  *  along with this library; see the file COPYING.LIB.  If not, write to
16  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  *  Boston, MA 02110-1301, USA.
18  *
19  */
20
21
22 #ifndef Protect_h
23 #define Protect_h
24
25 #include "Collector.h"
26 #include "JSValue.h"
27
28 namespace JSC {
29
30     inline void gcProtect(JSCell* val) 
31     {
32         Heap::heap(val)->protect(val);
33     }
34
35     inline void gcUnprotect(JSCell* val)
36     {
37         Heap::heap(val)->unprotect(val);
38     }
39
40     inline void gcProtectNullTolerant(JSCell* val) 
41     {
42         if (val) 
43             gcProtect(val);
44     }
45
46     inline void gcUnprotectNullTolerant(JSCell* val) 
47     {
48         if (val) 
49             gcUnprotect(val);
50     }
51     
52     inline void gcProtect(JSValue value)
53     {
54         if (value && value.isCell())
55             gcProtect(value.asCell());
56     }
57
58     inline void gcUnprotect(JSValue value)
59     {
60         if (value && value.isCell())
61             gcUnprotect(value.asCell());
62     }
63
64     // FIXME: Share more code with RefPtr template? The only differences are the ref/deref operation
65     // and the implicit conversion to raw pointer
66     template <class T> class ProtectedPtr {
67     public:
68         ProtectedPtr() : m_ptr(0) {}
69         ProtectedPtr(T* ptr);
70         ProtectedPtr(const ProtectedPtr&);
71         ~ProtectedPtr();
72
73         template <class U> ProtectedPtr(const ProtectedPtr<U>&);
74         
75         T* get() const { return m_ptr; }
76         operator T*() const { return m_ptr; }
77         operator JSValue() const { return JSValue(m_ptr); }
78         T* operator->() const { return m_ptr; }
79         
80         operator bool() const { return m_ptr; }
81         bool operator!() const { return !m_ptr; }
82
83         ProtectedPtr& operator=(const ProtectedPtr&);
84         ProtectedPtr& operator=(T*);
85         
86     private:
87         T* m_ptr;
88     };
89
90     class ProtectedJSValue {
91     public:
92         ProtectedJSValue() {}
93         ProtectedJSValue(JSValue value);
94         ProtectedJSValue(const ProtectedJSValue&);
95         ~ProtectedJSValue();
96
97         template <class U> ProtectedJSValue(const ProtectedPtr<U>&);
98         
99         JSValue get() const { return m_value; }
100         operator JSValue() const { return m_value; }
101         JSValue operator->() const { return m_value; }
102         
103         operator bool() const { return m_value; }
104         bool operator!() const { return !m_value; }
105
106         ProtectedJSValue& operator=(const ProtectedJSValue&);
107         ProtectedJSValue& operator=(JSValue);
108         
109     private:
110         JSValue m_value;
111     };
112
113     template <class T> inline ProtectedPtr<T>::ProtectedPtr(T* ptr)
114         : m_ptr(ptr)
115     {
116         gcProtectNullTolerant(m_ptr);
117     }
118
119     template <class T> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr& o)
120         : m_ptr(o.get())
121     {
122         gcProtectNullTolerant(m_ptr);
123     }
124
125     template <class T> inline ProtectedPtr<T>::~ProtectedPtr()
126     {
127         gcUnprotectNullTolerant(m_ptr);
128     }
129
130     template <class T> template <class U> inline ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr<U>& o)
131         : m_ptr(o.get())
132     {
133         gcProtectNullTolerant(m_ptr);
134     }
135
136     template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(const ProtectedPtr<T>& o) 
137     {
138         T* optr = o.m_ptr;
139         gcProtectNullTolerant(optr);
140         gcUnprotectNullTolerant(m_ptr);
141         m_ptr = optr;
142         return *this;
143     }
144
145     template <class T> inline ProtectedPtr<T>& ProtectedPtr<T>::operator=(T* optr)
146     {
147         gcProtectNullTolerant(optr);
148         gcUnprotectNullTolerant(m_ptr);
149         m_ptr = optr;
150         return *this;
151     }
152
153     inline ProtectedJSValue::ProtectedJSValue(JSValue value)
154         : m_value(value)
155     {
156         gcProtect(m_value);
157     }
158
159     inline ProtectedJSValue::ProtectedJSValue(const ProtectedJSValue& o)
160         : m_value(o.get())
161     {
162         gcProtect(m_value);
163     }
164
165     inline ProtectedJSValue::~ProtectedJSValue()
166     {
167         gcUnprotect(m_value);
168     }
169
170     template <class U> ProtectedJSValue::ProtectedJSValue(const ProtectedPtr<U>& o)
171         : m_value(o.get())
172     {
173         gcProtect(m_value);
174     }
175
176     inline ProtectedJSValue& ProtectedJSValue::operator=(const ProtectedJSValue& o) 
177     {
178         JSValue ovalue = o.m_value;
179         gcProtect(ovalue);
180         gcUnprotect(m_value);
181         m_value = ovalue;
182         return *this;
183     }
184
185     inline ProtectedJSValue& ProtectedJSValue::operator=(JSValue ovalue)
186     {
187         gcProtect(ovalue);
188         gcUnprotect(m_value);
189         m_value = ovalue;
190         return *this;
191     }
192
193     template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() == b.get(); }
194     template <class T> inline bool operator==(const ProtectedPtr<T>& a, const T* b) { return a.get() == b; }
195     template <class T> inline bool operator==(const T* a, const ProtectedPtr<T>& b) { return a == b.get(); }
196
197     template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedPtr<T>& b) { return a.get() != b.get(); }
198     template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const T* b) { return a.get() != b; }
199     template <class T> inline bool operator!=(const T* a, const ProtectedPtr<T>& b) { return a != b.get(); }
200
201     inline bool operator==(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() == b.get(); }
202     inline bool operator==(const ProtectedJSValue& a, const JSValue b) { return a.get() == b; }
203     template <class T> inline bool operator==(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() == JSValue(b.get()); }
204     inline bool operator==(const JSValue a, const ProtectedJSValue& b) { return a == b.get(); }
205     template <class T> inline bool operator==(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) == b.get(); }
206
207     inline bool operator!=(const ProtectedJSValue& a, const ProtectedJSValue& b) { return a.get() != b.get(); }
208     inline bool operator!=(const ProtectedJSValue& a, const JSValue b) { return a.get() != b; }
209     template <class T> inline bool operator!=(const ProtectedJSValue& a, const ProtectedPtr<T>& b) { return a.get() != JSValue(b.get()); }
210     inline bool operator!=(const JSValue a, const ProtectedJSValue& b) { return a != b.get(); }
211     template <class T> inline bool operator!=(const ProtectedPtr<T>& a, const ProtectedJSValue& b) { return JSValue(a.get()) != b.get(); }
212  
213 } // namespace JSC
214
215 #endif // Protect_h