1 | // -*- c-basic-offset: 2 -*- |
2 | /* |
3 | * This file is part of the KDE libraries |
4 | * Copyright (C) 2004 Apple Computer, Inc. |
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 | |
24 | #ifndef _KJS_PROTECT_H_ |
25 | #define _KJS_PROTECT_H_ |
26 | |
27 | #include "value.h" |
28 | #include "collector.h" |
29 | #include "JSLock.h" |
30 | |
31 | namespace KJS { |
32 | |
33 | inline void gcProtect(JSValue *val) |
34 | { |
35 | Collector::protect(val); |
36 | } |
37 | |
38 | inline void gcUnprotect(JSValue *val) |
39 | { |
40 | Collector::unprotect(val); |
41 | } |
42 | |
43 | inline void gcProtectNullTolerant(JSValue *val) |
44 | { |
45 | if (val) |
46 | gcProtect(val); |
47 | } |
48 | |
49 | inline void gcUnprotectNullTolerant(JSValue *val) |
50 | { |
51 | if (val) |
52 | gcUnprotect(val); |
53 | } |
54 | |
55 | // FIXME: Share more code with RefPtr template? The only differences are the ref/deref operation |
56 | // and the implicit conversion to raw pointer |
57 | template <class T> class ProtectedPtr { |
58 | public: |
59 | ProtectedPtr() : m_ptr(NULL) { } |
60 | ProtectedPtr(T *ptr); |
61 | ProtectedPtr(const ProtectedPtr &); |
62 | ~ProtectedPtr(); |
63 | |
64 | template <class U> ProtectedPtr(const ProtectedPtr<U> &); |
65 | |
66 | T *get() const { return m_ptr; } |
67 | operator T *() const { return m_ptr; } |
68 | T *operator->() const { return m_ptr; } |
69 | |
70 | bool operator!() const { return m_ptr == NULL; } |
71 | |
72 | ProtectedPtr &operator=(const ProtectedPtr &); |
73 | ProtectedPtr &operator=(T *); |
74 | |
75 | private: |
76 | T *m_ptr; |
77 | }; |
78 | |
79 | template <class T> ProtectedPtr<T>::ProtectedPtr(T *ptr) |
80 | : m_ptr(ptr) |
81 | { |
82 | if (ptr) { |
83 | JSLock lock; |
84 | gcProtect(ptr); |
85 | } |
86 | } |
87 | |
88 | template <class T> ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr &o) |
89 | : m_ptr(o.get()) |
90 | { |
91 | if (T *ptr = m_ptr) { |
92 | JSLock lock; |
93 | gcProtect(ptr); |
94 | } |
95 | } |
96 | |
97 | template <class T> ProtectedPtr<T>::~ProtectedPtr() |
98 | { |
99 | if (T *ptr = m_ptr) { |
100 | JSLock lock; |
101 | gcUnprotect(ptr); |
102 | } |
103 | } |
104 | |
105 | template <class T> template <class U> ProtectedPtr<T>::ProtectedPtr(const ProtectedPtr<U> &o) |
106 | : m_ptr(o.get()) |
107 | { |
108 | if (T *ptr = m_ptr) { |
109 | JSLock lock; |
110 | gcProtect(ptr); |
111 | } |
112 | } |
113 | |
114 | template <class T> ProtectedPtr<T> &ProtectedPtr<T>::operator=(const ProtectedPtr<T> &o) |
115 | { |
116 | JSLock lock; |
117 | T *optr = o.m_ptr; |
118 | gcProtectNullTolerant(optr); |
119 | gcUnprotectNullTolerant(m_ptr); |
120 | m_ptr = optr; |
121 | return *this; |
122 | } |
123 | |
124 | template <class T> inline ProtectedPtr<T> &ProtectedPtr<T>::operator=(T *optr) |
125 | { |
126 | JSLock lock; |
127 | gcProtectNullTolerant(optr); |
128 | gcUnprotectNullTolerant(m_ptr); |
129 | m_ptr = optr; |
130 | return *this; |
131 | } |
132 | |
133 | template <class T> inline bool operator==(const ProtectedPtr<T> &a, const ProtectedPtr<T> &b) { return a.get() == b.get(); } |
134 | template <class T> inline bool operator==(const ProtectedPtr<T> &a, const T *b) { return a.get() == b; } |
135 | template <class T> inline bool operator==(const T *a, const ProtectedPtr<T> &b) { return a == b.get(); } |
136 | |
137 | template <class T> inline bool operator!=(const ProtectedPtr<T> &a, const ProtectedPtr<T> &b) { return a.get() != b.get(); } |
138 | template <class T> inline bool operator!=(const ProtectedPtr<T> &a, const T *b) { return a.get() != b; } |
139 | template <class T> inline bool operator!=(const T *a, const ProtectedPtr<T> &b) { return a != b.get(); } |
140 | |
141 | } // namespace |
142 | |
143 | #endif |
144 | |