Allow easy definition of iterators.

PR-URL: #143
Reviewed-By: Jason Ginchereau <[email protected]>
Reviewed-By: Michael Dawson <[email protected]>

Author: rolftimmermans

napi-inl.h

@@ -594,6 +594,10 @@ inline Symbol Symbol::New(napi_env env, napi_value description) {
   return Symbol(env, value);
 }
 
+inline Symbol Symbol::WellKnown(napi_env env, const std::string& name) {
+  return Napi::Env(env).Global().Get("Symbol").As<Object>().Get(name).As<Symbol>();
+}
+
 inline Symbol::Symbol() : Name() {
 }
 
@@ -2510,6 +2514,41 @@ inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
   return desc;
 }
 
+template <typename T>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+    Symbol name,
+    InstanceVoidMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  // TODO: Delete when the class is destroyed
+  InstanceVoidMethodCallbackData* callbackData =
+    new InstanceVoidMethodCallbackData({ method, data});
+
+  napi_property_descriptor desc = {};
+  desc.name = name;
+  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+    Symbol name,
+    InstanceMethodCallback method,
+    napi_property_attributes attributes,
+    void* data) {
+  // TODO: Delete when the class is destroyed
+  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
+
+  napi_property_descriptor desc = {};
+  desc.name = name;
+  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.data = callbackData;
+  desc.attributes = attributes;
+  return desc;
+}
+
 template <typename T>
 inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
     const char* utf8name,

napi.h

@@ -330,6 +330,9 @@ namespace Napi {
       napi_value description ///< String value describing the symbol
     );
 
+    /// Get a public Symbol (e.g. Symbol.iterator).
+    static Symbol WellKnown(napi_env, const std::string& name);
+
     Symbol();                               ///< Creates a new _empty_ Symbol instance.
     Symbol(napi_env env, napi_value value); ///< Wraps a N-API value primitive.
   };
@@ -1305,6 +1308,14 @@ namespace Napi {
                                              InstanceMethodCallback method,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceVoidMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
     static PropertyDescriptor InstanceAccessor(const char* utf8name,
                                                InstanceGetterCallback getter,
                                                InstanceSetterCallback setter,

test/objectwrap.cc

@@ -1,5 +1,26 @@
 #include <napi.h>
 
+class TestIter : public Napi::ObjectWrap<TestIter> {
+public:
+  TestIter(const Napi::CallbackInfo& info) : Napi::ObjectWrap<TestIter>(info) {}
+
+  Napi::Value Next(const Napi::CallbackInfo& info) {
+    auto object = Napi::Object::New(info.Env());
+    object.Set("done", Napi::Boolean::New(info.Env(), true));
+    return object;
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    Constructor = Napi::Persistent(DefineClass(env, "TestIter", {
+      InstanceMethod("next", &TestIter::Next),
+    }));
+  }
+
+  static Napi::FunctionReference Constructor;
+};
+
+Napi::FunctionReference TestIter::Constructor;
+
 class Test : public Napi::ObjectWrap<Test> {
 public:
   Test(const Napi::CallbackInfo& info) :
@@ -14,10 +35,15 @@ class Test : public Napi::ObjectWrap<Test> {
     return Napi::Number::New(info.Env(), value);
   }
 
+  Napi::Value Iter(const Napi::CallbackInfo& info) {
+    return TestIter::Constructor.New({});
+  }
+
   static void Initialize(Napi::Env env, Napi::Object exports) {
     exports.Set("Test", DefineClass(env, "Test", {
       InstanceMethod("test_set", &Test::Set),
-      InstanceMethod("test_get", &Test::Get)
+      InstanceMethod("test_get", &Test::Get),
+      InstanceMethod(Napi::Symbol::WellKnown(env, "iterator"), &Test::Iter)
     }));
   }
 
@@ -28,5 +54,6 @@ class Test : public Napi::ObjectWrap<Test> {
 Napi::Object InitObjectWrap(Napi::Env env) {
   Napi::Object exports = Napi::Object::New(env);
   Test::Initialize(env, exports);
+  TestIter::Initialize(env, exports);
   return exports;
 }

test/objectwrap.js

@@ -13,8 +13,14 @@ function test(binding) {
     assert.strictEqual(obj.test_get(), 90);
   }
 
+  function testIter(obj) {
+    for (const value of obj) {
+    }
+  }
+
   function testObj(obj) {
     testSetGet(obj);
+    testIter(obj);
   }
 
   testObj(new Test());