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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* Template types for use in generic code: to use Rooted/Handle/MutableHandle in
* cases where GC may occur, or to use mock versions of those types that perform
* no rooting or root list manipulation when GC cannot occur.
*/
#ifndef gc_MaybeRooted_h
#define gc_MaybeRooted_h
#include "mozilla/Attributes.h" // MOZ_IMPLICIT, MOZ_RAII
#include <type_traits> // std::true_type
#include "gc/GCEnum.h" // js::AllowGC, js::CanGC, js::NoGC
#include "js/ComparisonOperators.h" // JS::detail::DefineComparisonOps
#include "js/RootingAPI.h" // js::{Rooted,MutableHandle}Base, JS::SafelyInitialized, DECLARE_POINTER_{CONSTREF,ASSIGN}_OPS, DECLARE_NONPOINTER_{,MUTABLE_}ACCESSOR_METHODS, JS::Rooted, JS::{,Mutable}Handle
namespace js {
/**
* Interface substitute for Rooted<T> which does not root the variable's
* memory.
*/
template <typename T>
class MOZ_RAII FakeRooted : public RootedOperations<T, FakeRooted<T>> {
public:
using ElementType = T;
explicit FakeRooted(JSContext* cx)
: ptr(JS::SafelyInitialized<T>::create()) {}
FakeRooted(JSContext* cx, T initial) : ptr(initial) {}
FakeRooted(const FakeRooted&) = delete;
DECLARE_POINTER_CONSTREF_OPS(T);
DECLARE_POINTER_ASSIGN_OPS(FakeRooted, T);
DECLARE_NONPOINTER_ACCESSOR_METHODS(ptr);
DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(ptr);
private:
T ptr;
void set(const T& value) { ptr = value; }
};
} // namespace js
namespace JS::detail {
template <typename T>
struct DefineComparisonOps<js::FakeRooted<T>> : std::true_type {
static const T& get(const js::FakeRooted<T>& v) { return v.get(); }
};
} // namespace JS::detail
namespace js {
/**
* Interface substitute for MutableHandle<T> which is not required to point to
* rooted memory.
*/
template <typename T>
class FakeMutableHandle
: public js::MutableHandleOperations<T, FakeMutableHandle<T>> {
public:
using ElementType = T;
MOZ_IMPLICIT FakeMutableHandle(T* t) : ptr(t) {}
MOZ_IMPLICIT FakeMutableHandle(FakeRooted<T>* root) : ptr(root->address()) {}
void set(const T& v) { *ptr = v; }
DECLARE_POINTER_CONSTREF_OPS(T);
DECLARE_NONPOINTER_ACCESSOR_METHODS(*ptr);
DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(*ptr);
private:
FakeMutableHandle() : ptr(nullptr) {}
DELETE_ASSIGNMENT_OPS(FakeMutableHandle, T);
T* ptr;
};
} // namespace js
namespace JS::detail {
template <typename T>
struct DefineComparisonOps<js::FakeMutableHandle<T>> : std::true_type {
static const T& get(const js::FakeMutableHandle<T>& v) { return v.get(); }
};
} // namespace JS::detail
namespace js {
/**
* Types for a variable that either should or shouldn't be rooted, depending on
* the template parameter allowGC. Used for implementing functions that can
* operate on either rooted or unrooted data.
*/
template <typename T, AllowGC allowGC>
class MaybeRooted;
template <typename T>
class MaybeRooted<T, CanGC> {
public:
using HandleType = JS::Handle<T>;
using RootType = JS::Rooted<T>;
using MutableHandleType = JS::MutableHandle<T>;
};
template <typename T>
class MaybeRooted<T, NoGC> {
public:
using HandleType = const T&;
using RootType = FakeRooted<T>;
using MutableHandleType = FakeMutableHandle<T>;
};
} // namespace js
#endif // gc_MaybeRooted_h
|
