node_modules/websocket/node_modules/nan/nan_maybe_43_inl.h

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