1 // Copyright 2018 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_HANDLES_MAYBE_HANDLES_INL_H_
6 #define V8_HANDLES_MAYBE_HANDLES_INL_H_
7
8 #include "src/handles/maybe-handles.h"
9
10 #include "src/handles/handles-inl.h"
11 #include "src/objects/maybe-object-inl.h"
12
13 namespace v8 {
14 namespace internal {
15
16 template <typename T>
MaybeHandle(T object,Isolate * isolate)17 MaybeHandle<T>::MaybeHandle(T object, Isolate* isolate)
18 : MaybeHandle(handle(object, isolate)) {}
19
20 template <typename T>
MaybeHandle(T object,LocalHeap * local_heap)21 MaybeHandle<T>::MaybeHandle(T object, LocalHeap* local_heap)
22 : MaybeHandle(handle(object, local_heap)) {}
23
MaybeObjectHandle(MaybeObject object,Isolate * isolate)24 MaybeObjectHandle::MaybeObjectHandle(MaybeObject object, Isolate* isolate) {
25 HeapObject heap_object;
26 DCHECK(!object->IsCleared());
27 if (object->GetHeapObjectIfWeak(&heap_object)) {
28 handle_ = handle(heap_object, isolate);
29 reference_type_ = HeapObjectReferenceType::WEAK;
30 } else {
31 handle_ = handle(object->cast<Object>(), isolate);
32 reference_type_ = HeapObjectReferenceType::STRONG;
33 }
34 }
35
MaybeObjectHandle(MaybeObject object,LocalHeap * local_heap)36 MaybeObjectHandle::MaybeObjectHandle(MaybeObject object,
37 LocalHeap* local_heap) {
38 HeapObject heap_object;
39 DCHECK(!object->IsCleared());
40 if (object->GetHeapObjectIfWeak(&heap_object)) {
41 handle_ = handle(heap_object, local_heap);
42 reference_type_ = HeapObjectReferenceType::WEAK;
43 } else {
44 handle_ = handle(object->cast<Object>(), local_heap);
45 reference_type_ = HeapObjectReferenceType::STRONG;
46 }
47 }
48
MaybeObjectHandle(Handle<Object> object)49 MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object)
50 : reference_type_(HeapObjectReferenceType::STRONG), handle_(object) {}
51
MaybeObjectHandle(Object object,Isolate * isolate)52 MaybeObjectHandle::MaybeObjectHandle(Object object, Isolate* isolate)
53 : reference_type_(HeapObjectReferenceType::STRONG),
54 handle_(object, isolate) {}
55
MaybeObjectHandle(Object object,LocalHeap * local_heap)56 MaybeObjectHandle::MaybeObjectHandle(Object object, LocalHeap* local_heap)
57 : reference_type_(HeapObjectReferenceType::STRONG),
58 handle_(object, local_heap) {}
59
MaybeObjectHandle(Object object,HeapObjectReferenceType reference_type,Isolate * isolate)60 MaybeObjectHandle::MaybeObjectHandle(Object object,
61 HeapObjectReferenceType reference_type,
62 Isolate* isolate)
63 : reference_type_(reference_type), handle_(handle(object, isolate)) {}
64
MaybeObjectHandle(Handle<Object> object,HeapObjectReferenceType reference_type)65 MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object,
66 HeapObjectReferenceType reference_type)
67 : reference_type_(reference_type), handle_(object) {}
68
Weak(Handle<Object> object)69 MaybeObjectHandle MaybeObjectHandle::Weak(Handle<Object> object) {
70 return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK);
71 }
72
Weak(Object object,Isolate * isolate)73 MaybeObjectHandle MaybeObjectHandle::Weak(Object object, Isolate* isolate) {
74 return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK, isolate);
75 }
76
is_identical_to(const MaybeObjectHandle & other)77 bool MaybeObjectHandle::is_identical_to(const MaybeObjectHandle& other) const {
78 Handle<Object> this_handle;
79 Handle<Object> other_handle;
80 return reference_type_ == other.reference_type_ &&
81 handle_.ToHandle(&this_handle) ==
82 other.handle_.ToHandle(&other_handle) &&
83 this_handle.is_identical_to(other_handle);
84 }
85
86 MaybeObject MaybeObjectHandle::operator*() const {
87 if (reference_type_ == HeapObjectReferenceType::WEAK) {
88 return HeapObjectReference::Weak(*handle_.ToHandleChecked());
89 } else {
90 return MaybeObject::FromObject(*handle_.ToHandleChecked());
91 }
92 }
93
94 MaybeObject MaybeObjectHandle::operator->() const {
95 if (reference_type_ == HeapObjectReferenceType::WEAK) {
96 return HeapObjectReference::Weak(*handle_.ToHandleChecked());
97 } else {
98 return MaybeObject::FromObject(*handle_.ToHandleChecked());
99 }
100 }
101
object()102 Handle<Object> MaybeObjectHandle::object() const {
103 return handle_.ToHandleChecked();
104 }
105
handle(MaybeObject object,Isolate * isolate)106 inline MaybeObjectHandle handle(MaybeObject object, Isolate* isolate) {
107 return MaybeObjectHandle(object, isolate);
108 }
109
handle(MaybeObject object,LocalHeap * local_heap)110 inline MaybeObjectHandle handle(MaybeObject object, LocalHeap* local_heap) {
111 return MaybeObjectHandle(object, local_heap);
112 }
113
114 } // namespace internal
115 } // namespace v8
116
117 #endif // V8_HANDLES_MAYBE_HANDLES_INL_H_
118