www.aleph1.co.uk Git - yaffs-website/blob - node_modules/nan/nan_maybe_43_inl.h

   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
  12 template<typename T>
  13 using MaybeLocal = v8::MaybeLocal<T>;
  14
  15 template<typename T>
  16 using Maybe = v8::Maybe<T>;
  17
  18 template<typename T>
  19 inline Maybe<T> Nothing() {
  20   return v8::Nothing<T>();
  21 }
  22
  23 template<typename T>
  24 inline Maybe<T> Just(const T& t) {
  25   return v8::Just<T>(t);
  26 }
  27
  28 inline
  29 MaybeLocal<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
  36 inline
  37 MaybeLocal<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
  44 inline
  45 Maybe<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
  51 inline
  52 MaybeLocal<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
  59 inline
  60 MaybeLocal<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
  70 inline
  71 MaybeLocal<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
  79 inline 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
  87 inline 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
  96 inline 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
 105 inline 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
 115 inline 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
 124 inline
 125 MaybeLocal<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
 132 inline 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
 141 inline 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
 149 inline 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
 155 inline 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
 163 inline
 164 Maybe<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
 170 inline
 171 MaybeLocal<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
 178 inline
 179 MaybeLocal<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
 186 inline 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
 194 inline 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
 202 inline 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
 210 inline 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
 218 inline 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
 226 inline 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
 234 inline 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
 244 inline 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
 254 inline 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
 266 inline 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
 276 inline
 277 MaybeLocal<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
 284 inline 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
 290 inline 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
 296 inline 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
 302 inline 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
 326 inline 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_