UNPKG

11.4 kBtext/x-cView Raw
1/*********************************************************************
2 * NAN - Native Abstractions for Node.js
3 *
4 * Copyright (c) 2017 NAN contributors
5 *
6 * MIT License <https://github.com/nodejs/nan/blob/master/LICENSE.md>
7 ********************************************************************/
8
9#ifndef NAN_MAYBE_43_INL_H_
10#define NAN_MAYBE_43_INL_H_
11
12template<typename T>
13using MaybeLocal = v8::MaybeLocal<T>;
14
15template<typename T>
16using Maybe = v8::Maybe<T>;
17
18template<typename T>
19inline Maybe<T> Nothing() {
20 return v8::Nothing<T>();
21}
22
23template<typename T>
24inline Maybe<T> Just(const T& t) {
25 return v8::Just<T>(t);
26}
27
28inline
29MaybeLocal<v8::String> ToDetailString(v8::Local<v8::Value> val) {
30 v8::Isolate *isolate = v8::Isolate::GetCurrent();
31 v8::EscapableHandleScope scope(isolate);
32 return scope.Escape(val->ToDetailString(isolate->GetCurrentContext())
33 .FromMaybe(v8::Local<v8::String>()));
34}
35
36inline
37MaybeLocal<v8::Uint32> ToArrayIndex(v8::Local<v8::Value> val) {
38 v8::Isolate *isolate = v8::Isolate::GetCurrent();
39 v8::EscapableHandleScope scope(isolate);
40 return scope.Escape(val->ToArrayIndex(isolate->GetCurrentContext())
41 .FromMaybe(v8::Local<v8::Uint32>()));
42}
43
44inline
45Maybe<bool> Equals(v8::Local<v8::Value> a, v8::Local<v8::Value>(b)) {
46 v8::Isolate *isolate = v8::Isolate::GetCurrent();
47 v8::HandleScope scope(isolate);
48 return a->Equals(isolate->GetCurrentContext(), b);
49}
50
51inline
52MaybeLocal<v8::Object> NewInstance(v8::Local<v8::Function> h) {
53 v8::Isolate *isolate = v8::Isolate::GetCurrent();
54 v8::EscapableHandleScope scope(isolate);
55 return scope.Escape(h->NewInstance(isolate->GetCurrentContext())
56 .FromMaybe(v8::Local<v8::Object>()));
57}
58
59inline
60MaybeLocal<v8::Object> NewInstance(
61 v8::Local<v8::Function> h
62 , int argc
63 , v8::Local<v8::Value> argv[]) {
64 v8::Isolate *isolate = v8::Isolate::GetCurrent();
65 v8::EscapableHandleScope scope(isolate);
66 return scope.Escape(h->NewInstance(isolate->GetCurrentContext(), argc, argv)
67 .FromMaybe(v8::Local<v8::Object>()));
68}
69
70inline
71MaybeLocal<v8::Object> NewInstance(v8::Local<v8::ObjectTemplate> h) {
72 v8::Isolate *isolate = v8::Isolate::GetCurrent();
73 v8::EscapableHandleScope scope(isolate);
74 return scope.Escape(h->NewInstance(isolate->GetCurrentContext())
75 .FromMaybe(v8::Local<v8::Object>()));
76}
77
78
79inline MaybeLocal<v8::Function> GetFunction(
80 v8::Local<v8::FunctionTemplate> t) {
81 v8::Isolate *isolate = v8::Isolate::GetCurrent();
82 v8::EscapableHandleScope scope(isolate);
83 return scope.Escape(t->GetFunction(isolate->GetCurrentContext())
84 .FromMaybe(v8::Local<v8::Function>()));
85}
86
87inline Maybe<bool> Set(
88 v8::Local<v8::Object> obj
89 , v8::Local<v8::Value> key
90 , v8::Local<v8::Value> value) {
91 v8::Isolate *isolate = v8::Isolate::GetCurrent();
92 v8::HandleScope scope(isolate);
93 return obj->Set(isolate->GetCurrentContext(), key, value);
94}
95
96inline Maybe<bool> Set(
97 v8::Local<v8::Object> obj
98 , uint32_t index
99 , v8::Local<v8::Value> value) {
100 v8::Isolate *isolate = v8::Isolate::GetCurrent();
101 v8::HandleScope scope(isolate);
102 return obj->Set(isolate->GetCurrentContext(), index, value);
103}
104
105inline Maybe<bool> ForceSet(
106 v8::Local<v8::Object> obj
107 , v8::Local<v8::Value> key
108 , v8::Local<v8::Value> value
109 , v8::PropertyAttribute attribs = v8::None) {
110 v8::Isolate *isolate = v8::Isolate::GetCurrent();
111 v8::HandleScope scope(isolate);
112 return obj->ForceSet(isolate->GetCurrentContext(), key, value, attribs);
113}
114
115inline MaybeLocal<v8::Value> Get(
116 v8::Local<v8::Object> obj
117 , v8::Local<v8::Value> key) {
118 v8::Isolate *isolate = v8::Isolate::GetCurrent();
119 v8::EscapableHandleScope scope(isolate);
120 return scope.Escape(obj->Get(isolate->GetCurrentContext(), key)
121 .FromMaybe(v8::Local<v8::Value>()));
122}
123
124inline
125MaybeLocal<v8::Value> Get(v8::Local<v8::Object> obj, uint32_t index) {
126 v8::Isolate *isolate = v8::Isolate::GetCurrent();
127 v8::EscapableHandleScope scope(isolate);
128 return scope.Escape(obj->Get(isolate->GetCurrentContext(), index)
129 .FromMaybe(v8::Local<v8::Value>()));
130}
131
132inline v8::PropertyAttribute GetPropertyAttributes(
133 v8::Local<v8::Object> obj
134 , v8::Local<v8::Value> key) {
135 v8::Isolate *isolate = v8::Isolate::GetCurrent();
136 v8::HandleScope scope(isolate);
137 return obj->GetPropertyAttributes(isolate->GetCurrentContext(), key)
138 .FromJust();
139}
140
141inline Maybe<bool> Has(
142 v8::Local<v8::Object> obj
143 , v8::Local<v8::String> key) {
144 v8::Isolate *isolate = v8::Isolate::GetCurrent();
145 v8::HandleScope scope(isolate);
146 return obj->Has(isolate->GetCurrentContext(), key);
147}
148
149inline Maybe<bool> Has(v8::Local<v8::Object> obj, uint32_t index) {
150 v8::Isolate *isolate = v8::Isolate::GetCurrent();
151 v8::HandleScope scope(isolate);
152 return obj->Has(isolate->GetCurrentContext(), index);
153}
154
155inline Maybe<bool> Delete(
156 v8::Local<v8::Object> obj
157 , v8::Local<v8::String> key) {
158 v8::Isolate *isolate = v8::Isolate::GetCurrent();
159 v8::HandleScope scope(isolate);
160 return obj->Delete(isolate->GetCurrentContext(), key);
161}
162
163inline
164Maybe<bool> Delete(v8::Local<v8::Object> obj, uint32_t index) {
165 v8::Isolate *isolate = v8::Isolate::GetCurrent();
166 v8::HandleScope scope(isolate);
167 return obj->Delete(isolate->GetCurrentContext(), index);
168}
169
170inline
171MaybeLocal<v8::Array> GetPropertyNames(v8::Local<v8::Object> obj) {
172 v8::Isolate *isolate = v8::Isolate::GetCurrent();
173 v8::EscapableHandleScope scope(isolate);
174 return scope.Escape(obj->GetPropertyNames(isolate->GetCurrentContext())
175 .FromMaybe(v8::Local<v8::Array>()));
176}
177
178inline
179MaybeLocal<v8::Array> GetOwnPropertyNames(v8::Local<v8::Object> obj) {
180 v8::Isolate *isolate = v8::Isolate::GetCurrent();
181 v8::EscapableHandleScope scope(isolate);
182 return scope.Escape(obj->GetOwnPropertyNames(isolate->GetCurrentContext())
183 .FromMaybe(v8::Local<v8::Array>()));
184}
185
186inline Maybe<bool> SetPrototype(
187 v8::Local<v8::Object> obj
188 , v8::Local<v8::Value> prototype) {
189 v8::Isolate *isolate = v8::Isolate::GetCurrent();
190 v8::HandleScope scope(isolate);
191 return obj->SetPrototype(isolate->GetCurrentContext(), prototype);
192}
193
194inline MaybeLocal<v8::String> ObjectProtoToString(
195 v8::Local<v8::Object> obj) {
196 v8::Isolate *isolate = v8::Isolate::GetCurrent();
197 v8::EscapableHandleScope scope(isolate);
198 return scope.Escape(obj->ObjectProtoToString(isolate->GetCurrentContext())
199 .FromMaybe(v8::Local<v8::String>()));
200}
201
202inline Maybe<bool> HasOwnProperty(
203 v8::Local<v8::Object> obj
204 , v8::Local<v8::String> key) {
205 v8::Isolate *isolate = v8::Isolate::GetCurrent();
206 v8::HandleScope scope(isolate);
207 return obj->HasOwnProperty(isolate->GetCurrentContext(), key);
208}
209
210inline Maybe<bool> HasRealNamedProperty(
211 v8::Local<v8::Object> obj
212 , v8::Local<v8::String> key) {
213 v8::Isolate *isolate = v8::Isolate::GetCurrent();
214 v8::HandleScope scope(isolate);
215 return obj->HasRealNamedProperty(isolate->GetCurrentContext(), key);
216}
217
218inline Maybe<bool> HasRealIndexedProperty(
219 v8::Local<v8::Object> obj
220 , uint32_t index) {
221 v8::Isolate *isolate = v8::Isolate::GetCurrent();
222 v8::HandleScope scope(isolate);
223 return obj->HasRealIndexedProperty(isolate->GetCurrentContext(), index);
224}
225
226inline Maybe<bool> HasRealNamedCallbackProperty(
227 v8::Local<v8::Object> obj
228 , v8::Local<v8::String> key) {
229 v8::Isolate *isolate = v8::Isolate::GetCurrent();
230 v8::HandleScope scope(isolate);
231 return obj->HasRealNamedCallbackProperty(isolate->GetCurrentContext(), key);
232}
233
234inline MaybeLocal<v8::Value> GetRealNamedPropertyInPrototypeChain(
235 v8::Local<v8::Object> obj
236 , v8::Local<v8::String> key) {
237 v8::Isolate *isolate = v8::Isolate::GetCurrent();
238 v8::EscapableHandleScope scope(isolate);
239 return scope.Escape(obj->GetRealNamedPropertyInPrototypeChain(
240 isolate->GetCurrentContext(), key)
241 .FromMaybe(v8::Local<v8::Value>()));
242}
243
244inline MaybeLocal<v8::Value> GetRealNamedProperty(
245 v8::Local<v8::Object> obj
246 , v8::Local<v8::String> key) {
247 v8::Isolate *isolate = v8::Isolate::GetCurrent();
248 v8::EscapableHandleScope scope(isolate);
249 return scope.Escape(
250 obj->GetRealNamedProperty(isolate->GetCurrentContext(), key)
251 .FromMaybe(v8::Local<v8::Value>()));
252}
253
254inline MaybeLocal<v8::Value> CallAsFunction(
255 v8::Local<v8::Object> obj
256 , v8::Local<v8::Object> recv
257 , int argc
258 , v8::Local<v8::Value> argv[]) {
259 v8::Isolate *isolate = v8::Isolate::GetCurrent();
260 v8::EscapableHandleScope scope(isolate);
261 return scope.Escape(
262 obj->CallAsFunction(isolate->GetCurrentContext(), recv, argc, argv)
263 .FromMaybe(v8::Local<v8::Value>()));
264}
265
266inline MaybeLocal<v8::Value> CallAsConstructor(
267 v8::Local<v8::Object> obj
268 , int argc, v8::Local<v8::Value> argv[]) {
269 v8::Isolate *isolate = v8::Isolate::GetCurrent();
270 v8::EscapableHandleScope scope(isolate);
271 return scope.Escape(
272 obj->CallAsConstructor(isolate->GetCurrentContext(), argc, argv)
273 .FromMaybe(v8::Local<v8::Value>()));
274}
275
276inline
277MaybeLocal<v8::String> GetSourceLine(v8::Local<v8::Message> msg) {
278 v8::Isolate *isolate = v8::Isolate::GetCurrent();
279 v8::EscapableHandleScope scope(isolate);
280 return scope.Escape(msg->GetSourceLine(isolate->GetCurrentContext())
281 .FromMaybe(v8::Local<v8::String>()));
282}
283
284inline Maybe<int> GetLineNumber(v8::Local<v8::Message> msg) {
285 v8::Isolate *isolate = v8::Isolate::GetCurrent();
286 v8::HandleScope scope(isolate);
287 return msg->GetLineNumber(isolate->GetCurrentContext());
288}
289
290inline Maybe<int> GetStartColumn(v8::Local<v8::Message> msg) {
291 v8::Isolate *isolate = v8::Isolate::GetCurrent();
292 v8::HandleScope scope(isolate);
293 return msg->GetStartColumn(isolate->GetCurrentContext());
294}
295
296inline Maybe<int> GetEndColumn(v8::Local<v8::Message> msg) {
297 v8::Isolate *isolate = v8::Isolate::GetCurrent();
298 v8::HandleScope scope(isolate);
299 return msg->GetEndColumn(isolate->GetCurrentContext());
300}
301
302inline MaybeLocal<v8::Object> CloneElementAt(
303 v8::Local<v8::Array> array
304 , uint32_t index) {
305#if (NODE_MODULE_VERSION >= NODE_6_0_MODULE_VERSION)
306 v8::Isolate *isolate = v8::Isolate::GetCurrent();
307 v8::EscapableHandleScope scope(isolate);
308 v8::Local<v8::Context> context = isolate->GetCurrentContext();
309 v8::Local<v8::Value> elem;
310 v8::Local<v8::Object> obj;
311 if (!array->Get(context, index).ToLocal(&elem)) {
312 return scope.Escape(obj);
313 }
314 if (!elem->ToObject(context).ToLocal(&obj)) {
315 return scope.Escape(v8::Local<v8::Object>());
316 }
317 return scope.Escape(obj->Clone());
318#else
319 v8::Isolate *isolate = v8::Isolate::GetCurrent();
320 v8::EscapableHandleScope scope(isolate);
321 return scope.Escape(array->CloneElementAt(isolate->GetCurrentContext(), index)
322 .FromMaybe(v8::Local<v8::Object>()));
323#endif
324}
325
326inline MaybeLocal<v8::Value> Call(
327 v8::Local<v8::Function> fun
328 , v8::Local<v8::Object> recv
329 , int argc
330 , v8::Local<v8::Value> argv[]) {
331 v8::Isolate *isolate = v8::Isolate::GetCurrent();
332 v8::EscapableHandleScope scope(isolate);
333 return scope.Escape(fun->Call(isolate->GetCurrentContext(), recv, argc, argv)
334 .FromMaybe(v8::Local<v8::Value>()));
335}
336
337#endif // NAN_MAYBE_43_INL_H_