1/*
2 * Copyright (C) 2011 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 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23 * THE POSSIBILITY OF SUCH DAMAGE.
24 */
25
26#ifndef Strong_h
27#define Strong_h
28
29#include <wtf/Assertions.h>
30#include "Handle.h"
31#include "HandleSet.h"
32
33namespace JSC {
34
35class VM;
36
37// A strongly referenced handle that prevents the object it points to from being garbage collected.
38template <typename T> class Strong : public Handle<T> {
39 using Handle<T>::slot;
40 using Handle<T>::setSlot;
41 template <typename U> friend class Strong;
42
43public:
44 typedef typename Handle<T>::ExternalType ExternalType;
45
46 Strong()
47 : Handle<T>()
48 {
49 }
50
51 Strong(VM&, ExternalType = ExternalType());
52
53 Strong(VM&, Handle<T>);
54
55 Strong(const Strong& other)
56 : Handle<T>()
57 {
58 if (!other.slot())
59 return;
60 setSlot(HandleSet::heapFor(other.slot())->allocate());
61 set(other.get());
62 }
63
64 template <typename U> Strong(const Strong<U>& other)
65 : Handle<T>()
66 {
67 if (!other.slot())
68 return;
69 setSlot(HandleSet::heapFor(other.slot())->allocate());
70 set(other.get());
71 }
72
73 enum HashTableDeletedValueTag { HashTableDeletedValue };
74 bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
75 Strong(HashTableDeletedValueTag)
76 : Handle<T>(hashTableDeletedValue())
77 {
78 }
79
80 ~Strong()
81 {
82 clear();
83 }
84
85 bool operator!() const { return !slot() || !*slot(); }
86
87 explicit operator bool() const { return !!*this; }
88
89 void swap(Strong& other)
90 {
91 Handle<T>::swap(other);
92 }
93
94 ExternalType get() const { return HandleTypes<T>::getFromSlot(this->slot()); }
95
96 void set(VM&, ExternalType);
97
98 template <typename U> Strong& operator=(const Strong<U>& other)
99 {
100 if (!other.slot()) {
101 clear();
102 return *this;
103 }
104
105 set(*HandleSet::heapFor(other.slot())->vm(), other.get());
106 return *this;
107 }
108
109 Strong& operator=(const Strong& other)
110 {
111 if (!other.slot()) {
112 clear();
113 return *this;
114 }
115
116 set(*HandleSet::heapFor(other.slot())->vm(), other.get());
117 return *this;
118 }
119
120 void clear()
121 {
122 if (!slot())
123 return;
124 HandleSet::heapFor(slot())->deallocate(slot());
125 setSlot(0);
126 }
127
128private:
129 static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
130
131 void set(ExternalType externalType)
132 {
133 ASSERT(slot());
134 JSValue value = HandleTypes<T>::toJSValue(externalType);
135 HandleSet::heapFor(slot())->writeBarrier(slot(), value);
136 *slot() = value;
137 }
138};
139
140template<class T> inline void swap(Strong<T>& a, Strong<T>& b)
141{
142 a.swap(b);
143}
144
145} // namespace JSC
146
147namespace WTF {
148
149template<typename T> struct VectorTraits<JSC::Strong<T>> : SimpleClassVectorTraits {
150 static const bool canCompareWithMemcmp = false;
151};
152
153template<typename P> struct HashTraits<JSC::Strong<P>> : SimpleClassHashTraits<JSC::Strong<P>> { };
154
155}
156
157#endif // Strong_h
158