init repo

ronnie

2022-10-14 1504bb53e29d3d46222c0b3ea994fc494b48e153

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef V8_MAYBE_HANDLES_INL_H_
#define V8_MAYBE_HANDLES_INL_H_
 
#include "src/maybe-handles.h"
 
#include "src/handles-inl.h"
#include "src/objects/maybe-object-inl.h"
 
namespace v8 {
namespace internal {
template <typename T>
MaybeHandle<T>::MaybeHandle(T* object, Isolate* isolate)
    : MaybeHandle(handle(object, isolate)) {}
 
MaybeObjectHandle::MaybeObjectHandle()
    : reference_type_(HeapObjectReferenceType::STRONG),
      handle_(Handle<Object>::null()) {}
 
MaybeObjectHandle::MaybeObjectHandle(MaybeObject* object, Isolate* isolate) {
  HeapObject* heap_object;
  DCHECK(!object->IsClearedWeakHeapObject());
  if (object->ToWeakHeapObject(&heap_object)) {
    handle_ = handle(heap_object, isolate);
    reference_type_ = HeapObjectReferenceType::WEAK;
  } else {
    handle_ = handle(object->ToObject(), isolate);
    reference_type_ = HeapObjectReferenceType::STRONG;
  }
}
 
MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object)
    : reference_type_(HeapObjectReferenceType::STRONG), handle_(object) {}
 
MaybeObjectHandle::MaybeObjectHandle(Object* object, Isolate* isolate)
    : reference_type_(HeapObjectReferenceType::STRONG),
      handle_(object, isolate) {}
 
MaybeObjectHandle::MaybeObjectHandle(Object* object,
                                     HeapObjectReferenceType reference_type,
                                     Isolate* isolate)
    : reference_type_(reference_type), handle_(handle(object, isolate)) {}
 
MaybeObjectHandle::MaybeObjectHandle(Handle<Object> object,
                                     HeapObjectReferenceType reference_type)
    : reference_type_(reference_type), handle_(object) {}
 
MaybeObjectHandle MaybeObjectHandle::Weak(Handle<Object> object) {
  return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK);
}
 
MaybeObjectHandle MaybeObjectHandle::Weak(Object* object, Isolate* isolate) {
  return MaybeObjectHandle(object, HeapObjectReferenceType::WEAK, isolate);
}
 
MaybeObject* MaybeObjectHandle::operator*() const {
  if (reference_type_ == HeapObjectReferenceType::WEAK) {
    return HeapObjectReference::Weak(*handle_.ToHandleChecked());
  } else {
    return MaybeObject::FromObject(*handle_.ToHandleChecked());
  }
}
 
MaybeObject* MaybeObjectHandle::operator->() const {
  if (reference_type_ == HeapObjectReferenceType::WEAK) {
    return HeapObjectReference::Weak(*handle_.ToHandleChecked());
  } else {
    return MaybeObject::FromObject(*handle_.ToHandleChecked());
  }
}
 
Handle<Object> MaybeObjectHandle::object() const {
  return handle_.ToHandleChecked();
}
 
inline MaybeObjectHandle handle(MaybeObject* object, Isolate* isolate) {
  return MaybeObjectHandle(object, isolate);
}
 
}  // namespace internal
}  // namespace v8
 
#endif  // V8_MAYBE_HANDLES_INL_H_