{
  "source": "doc/api/addons.markdown",
  "modules": [
    {
      "textRaw": "Addons",
      "name": "addons",
      "desc": "<p>Addons are dynamically linked shared objects. They can provide glue to C and\nC++ libraries. The API (at the moment) is rather complex, involving\nknowledge of several libraries:\n\n</p>\n<ul>\n<li><p>V8 JavaScript, a C++ library. Used for interfacing with JavaScript:\ncreating objects, calling functions, etc.  Documented mostly in the\n<code>v8.h</code> header file (<code>deps/v8/include/v8.h</code> in the Node source\ntree), which is also available\n<a href=\"http://izs.me/v8-docs/main.html\">online</a>.</p>\n</li>\n<li><p><a href=\"https://github.com/joyent/libuv\">libuv</a>, C event loop library.\nAnytime one needs to wait for a file descriptor to become readable,\nwait for a timer, or wait for a signal to be received one will need\nto interface with libuv. That is, if you perform any I/O, libuv will\nneed to be used.</p>\n</li>\n<li><p>Internal Node libraries. Most importantly is the <code>node::ObjectWrap</code>\nclass which you will likely want to derive from.</p>\n</li>\n<li><p>Others. Look in <code>deps/</code> for what else is available.</p>\n</li>\n</ul>\n<p>Node statically compiles all its dependencies into the executable.\nWhen compiling your module, you don&#39;t need to worry about linking to\nany of these libraries.\n\n</p>\n<p>All of the following examples are available for\n<a href=\"https://github.com/rvagg/node-addon-examples\">download</a> and may be\nused as a starting-point for your own Addon.\n\n</p>\n",
      "modules": [
        {
          "textRaw": "Hello world",
          "name": "hello_world",
          "desc": "<p>To get started let&#39;s make a small Addon which is the C++ equivalent of\nthe following JavaScript code:\n\n</p>\n<pre><code>module.exports.hello = function() { return &#39;world&#39;; };</code></pre>\n<p>First we create a file <code>hello.cc</code>:\n\n</p>\n<pre><code>#include &lt;node.h&gt;\n#include &lt;v8.h&gt;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; Method(const Arguments&amp; args) {\n  HandleScope scope;\n  return scope.Close(String::New(&quot;world&quot;));\n}\n\nvoid init(Handle&lt;Object&gt; exports) {\n  exports-&gt;Set(String::NewSymbol(&quot;hello&quot;),\n      FunctionTemplate::New(Method)-&gt;GetFunction());\n}\n\nNODE_MODULE(hello, init)</code></pre>\n<p>Note that all Node addons must export an initialization function:\n\n</p>\n<pre><code>void Initialize (Handle&lt;Object&gt; exports);\nNODE_MODULE(module_name, Initialize)</code></pre>\n<p>There is no semi-colon after <code>NODE_MODULE</code> as it&#39;s not a function (see <code>node.h</code>).\n\n</p>\n<p>The <code>module_name</code> needs to match the filename of the final binary (minus the\n.node suffix).\n\n</p>\n<p>The source code needs to be built into <code>hello.node</code>, the binary Addon. To\ndo this we create a file called <code>binding.gyp</code> which describes the configuration\nto build your module in a JSON-like format. This file gets compiled by\n<a href=\"https://github.com/TooTallNate/node-gyp\">node-gyp</a>.\n\n</p>\n<pre><code>{\n  &quot;targets&quot;: [\n    {\n      &quot;target_name&quot;: &quot;hello&quot;,\n      &quot;sources&quot;: [ &quot;hello.cc&quot; ]\n    }\n  ]\n}</code></pre>\n<p>The next step is to generate the appropriate project build files for the\ncurrent platform. Use <code>node-gyp configure</code> for that.\n\n</p>\n<p>Now you will have either a <code>Makefile</code> (on Unix platforms) or a <code>vcxproj</code> file\n(on Windows) in the <code>build/</code> directory. Next invoke the <code>node-gyp build</code>\ncommand.\n\n</p>\n<p>Now you have your compiled <code>.node</code> bindings file! The compiled bindings end up\nin <code>build/Release/</code>.\n\n</p>\n<p>You can now use the binary addon in a Node project <code>hello.js</code> by pointing <code>require</code> to\nthe recently built <code>hello.node</code> module:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/hello&#39;);\n\nconsole.log(addon.hello()); // &#39;world&#39;</code></pre>\n<p>Please see patterns below for further information or\n</p>\n<p><a href=\"https://github.com/arturadib/node-qt\">https://github.com/arturadib/node-qt</a> for an example in production.\n\n\n</p>\n",
          "type": "module",
          "displayName": "Hello world"
        },
        {
          "textRaw": "Addon patterns",
          "name": "addon_patterns",
          "desc": "<p>Below are some addon patterns to help you get started. Consult the online\n<a href=\"http://izs.me/v8-docs/main.html\">v8 reference</a> for help with the various v8\ncalls, and v8&#39;s <a href=\"http://code.google.com/apis/v8/embed.html\">Embedder&#39;s Guide</a>\nfor an explanation of several concepts used such as handles, scopes,\nfunction templates, etc.\n\n</p>\n<p>In order to use these examples you need to compile them using <code>node-gyp</code>.\nCreate the following <code>binding.gyp</code> file:\n\n</p>\n<pre><code>{\n  &quot;targets&quot;: [\n    {\n      &quot;target_name&quot;: &quot;addon&quot;,\n      &quot;sources&quot;: [ &quot;addon.cc&quot; ]\n    }\n  ]\n}</code></pre>\n<p>In cases where there is more than one <code>.cc</code> file, simply add the file name to the\n<code>sources</code> array, e.g.:\n\n</p>\n<pre><code>&quot;sources&quot;: [&quot;addon.cc&quot;, &quot;myexample.cc&quot;]</code></pre>\n<p>Now that you have your <code>binding.gyp</code> ready, you can configure and build the\naddon:\n\n</p>\n<pre><code>$ node-gyp configure build</code></pre>\n",
          "modules": [
            {
              "textRaw": "Function arguments",
              "name": "function_arguments",
              "desc": "<p>The following pattern illustrates how to read arguments from JavaScript\nfunction calls and return a result. This is the main and only needed source\n<code>addon.cc</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; Add(const Arguments&amp; args) {\n  HandleScope scope;\n\n  if (args.Length() &lt; 2) {\n    ThrowException(Exception::TypeError(String::New(&quot;Wrong number of arguments&quot;)));\n    return scope.Close(Undefined());\n  }\n\n  if (!args[0]-&gt;IsNumber() || !args[1]-&gt;IsNumber()) {\n    ThrowException(Exception::TypeError(String::New(&quot;Wrong arguments&quot;)));\n    return scope.Close(Undefined());\n  }\n\n  Local&lt;Number&gt; num = Number::New(args[0]-&gt;NumberValue() +\n      args[1]-&gt;NumberValue());\n  return scope.Close(num);\n}\n\nvoid Init(Handle&lt;Object&gt; exports) {\n  exports-&gt;Set(String::NewSymbol(&quot;add&quot;),\n      FunctionTemplate::New(Add)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, Init)</code></pre>\n<p>You can test it with the following JavaScript snippet:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\nconsole.log( &#39;This should be eight:&#39;, addon.add(3,5) );</code></pre>\n",
              "type": "module",
              "displayName": "Function arguments"
            },
            {
              "textRaw": "Callbacks",
              "name": "callbacks",
              "desc": "<p>You can pass JavaScript functions to a C++ function and execute them from\nthere. Here&#39;s <code>addon.cc</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; RunCallback(const Arguments&amp; args) {\n  HandleScope scope;\n\n  Local&lt;Function&gt; cb = Local&lt;Function&gt;::Cast(args[0]);\n  const unsigned argc = 1;\n  Local&lt;Value&gt; argv[argc] = { Local&lt;Value&gt;::New(String::New(&quot;hello world&quot;)) };\n  cb-&gt;Call(Context::GetCurrent()-&gt;Global(), argc, argv);\n\n  return scope.Close(Undefined());\n}\n\nvoid Init(Handle&lt;Object&gt; exports, Handle&lt;Object&gt; module) {\n  module-&gt;Set(String::NewSymbol(&quot;exports&quot;),\n      FunctionTemplate::New(RunCallback)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, Init)</code></pre>\n<p>Note that this example uses a two-argument form of <code>Init()</code> that receives\nthe full <code>module</code> object as the second argument. This allows the addon\nto completely overwrite <code>exports</code> with a single function instead of\nadding the function as a property of <code>exports</code>.\n\n</p>\n<p>To test it run the following JavaScript snippet:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\naddon(function(msg){\n  console.log(msg); // &#39;hello world&#39;\n});</code></pre>\n",
              "type": "module",
              "displayName": "Callbacks"
            },
            {
              "textRaw": "Object factory",
              "name": "object_factory",
              "desc": "<p>You can create and return new objects from within a C++ function with this\n<code>addon.cc</code> pattern, which returns an object with property <code>msg</code> that echoes\nthe string passed to <code>createObject()</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; CreateObject(const Arguments&amp; args) {\n  HandleScope scope;\n\n  Local&lt;Object&gt; obj = Object::New();\n  obj-&gt;Set(String::NewSymbol(&quot;msg&quot;), args[0]-&gt;ToString());\n\n  return scope.Close(obj);\n}\n\nvoid Init(Handle&lt;Object&gt; exports, Handle&lt;Object&gt; module) {\n  module-&gt;Set(String::NewSymbol(&quot;exports&quot;),\n      FunctionTemplate::New(CreateObject)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, Init)</code></pre>\n<p>To test it in JavaScript:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\nvar obj1 = addon(&#39;hello&#39;);\nvar obj2 = addon(&#39;world&#39;);\nconsole.log(obj1.msg+&#39; &#39;+obj2.msg); // &#39;hello world&#39;</code></pre>\n",
              "type": "module",
              "displayName": "Object factory"
            },
            {
              "textRaw": "Function factory",
              "name": "function_factory",
              "desc": "<p>This pattern illustrates how to create and return a JavaScript function that\nwraps a C++ function:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; MyFunction(const Arguments&amp; args) {\n  HandleScope scope;\n  return scope.Close(String::New(&quot;hello world&quot;));\n}\n\nHandle&lt;Value&gt; CreateFunction(const Arguments&amp; args) {\n  HandleScope scope;\n\n  Local&lt;FunctionTemplate&gt; tpl = FunctionTemplate::New(MyFunction);\n  Local&lt;Function&gt; fn = tpl-&gt;GetFunction();\n  fn-&gt;SetName(String::NewSymbol(&quot;theFunction&quot;)); // omit this to make it anonymous\n\n  return scope.Close(fn);\n}\n\nvoid Init(Handle&lt;Object&gt; exports, Handle&lt;Object&gt; module) {\n  module-&gt;Set(String::NewSymbol(&quot;exports&quot;),\n      FunctionTemplate::New(CreateFunction)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, Init)</code></pre>\n<p>To test:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\nvar fn = addon();\nconsole.log(fn()); // &#39;hello world&#39;</code></pre>\n",
              "type": "module",
              "displayName": "Function factory"
            },
            {
              "textRaw": "Wrapping C++ objects",
              "name": "wrapping_c++_objects",
              "desc": "<p>Here we will create a wrapper for a C++ object/class <code>MyObject</code> that can be\ninstantiated in JavaScript through the <code>new</code> operator. First prepare the main\nmodule <code>addon.cc</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nvoid InitAll(Handle&lt;Object&gt; exports) {\n  MyObject::Init(exports);\n}\n\nNODE_MODULE(addon, InitAll)</code></pre>\n<p>Then in <code>myobject.h</code> make your wrapper inherit from <code>node::ObjectWrap</code>:\n\n</p>\n<pre><code>#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &lt;node.h&gt;\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init(v8::Handle&lt;v8::Object&gt; exports);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static v8::Handle&lt;v8::Value&gt; New(const v8::Arguments&amp; args);\n  static v8::Handle&lt;v8::Value&gt; PlusOne(const v8::Arguments&amp; args);\n  static v8::Persistent&lt;v8::Function&gt; constructor;\n  double value_;\n};\n\n#endif</code></pre>\n<p>And in <code>myobject.cc</code> implement the various methods that you want to expose.\nHere we expose the method <code>plusOne</code> by adding it to the constructor&#39;s\nprototype:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nPersistent&lt;Function&gt; MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init(Handle&lt;Object&gt; exports) {\n  // Prepare constructor template\n  Local&lt;FunctionTemplate&gt; tpl = FunctionTemplate::New(New);\n  tpl-&gt;SetClassName(String::NewSymbol(&quot;MyObject&quot;));\n  tpl-&gt;InstanceTemplate()-&gt;SetInternalFieldCount(1);\n  // Prototype\n  tpl-&gt;PrototypeTemplate()-&gt;Set(String::NewSymbol(&quot;plusOne&quot;),\n      FunctionTemplate::New(PlusOne)-&gt;GetFunction());\n  constructor = Persistent&lt;Function&gt;::New(tpl-&gt;GetFunction());\n  exports-&gt;Set(String::NewSymbol(&quot;MyObject&quot;), constructor);\n}\n\nHandle&lt;Value&gt; MyObject::New(const Arguments&amp; args) {\n  HandleScope scope;\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]-&gt;IsUndefined() ? 0 : args[0]-&gt;NumberValue();\n    MyObject* obj = new MyObject(value);\n    obj-&gt;Wrap(args.This());\n    return args.This();\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&lt;Value&gt; argv[argc] = { args[0] };\n    return scope.Close(constructor-&gt;NewInstance(argc, argv));\n  }\n}\n\nHandle&lt;Value&gt; MyObject::PlusOne(const Arguments&amp; args) {\n  HandleScope scope;\n\n  MyObject* obj = ObjectWrap::Unwrap&lt;MyObject&gt;(args.This());\n  obj-&gt;value_ += 1;\n\n  return scope.Close(Number::New(obj-&gt;value_));\n}</code></pre>\n<p>Test it with:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\nvar obj = new addon.MyObject(10);\nconsole.log( obj.plusOne() ); // 11\nconsole.log( obj.plusOne() ); // 12\nconsole.log( obj.plusOne() ); // 13</code></pre>\n",
              "type": "module",
              "displayName": "Wrapping C++ objects"
            },
            {
              "textRaw": "Factory of wrapped objects",
              "name": "factory_of_wrapped_objects",
              "desc": "<p>This is useful when you want to be able to create native objects without\nexplicitly instantiating them with the <code>new</code> operator in JavaScript, e.g.\n\n</p>\n<pre><code>var obj = addon.createObject();\n// instead of:\n// var obj = new addon.Object();</code></pre>\n<p>Let&#39;s register our <code>createObject</code> method in <code>addon.cc</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; CreateObject(const Arguments&amp; args) {\n  HandleScope scope;\n  return scope.Close(MyObject::NewInstance(args));\n}\n\nvoid InitAll(Handle&lt;Object&gt; exports, Handle&lt;Object&gt; module) {\n  MyObject::Init();\n\n  module-&gt;Set(String::NewSymbol(&quot;exports&quot;),\n      FunctionTemplate::New(CreateObject)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, InitAll)</code></pre>\n<p>In <code>myobject.h</code> we now introduce the static method <code>NewInstance</code> that takes\ncare of instantiating the object (i.e. it does the job of <code>new</code> in JavaScript):\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &lt;node.h&gt;\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init();\n  static v8::Handle&lt;v8::Value&gt; NewInstance(const v8::Arguments&amp; args);\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static v8::Handle&lt;v8::Value&gt; New(const v8::Arguments&amp; args);\n  static v8::Handle&lt;v8::Value&gt; PlusOne(const v8::Arguments&amp; args);\n  static v8::Persistent&lt;v8::Function&gt; constructor;\n  double value_;\n};\n\n#endif</code></pre>\n<p>The implementation is similar to the above in <code>myobject.cc</code>:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nPersistent&lt;Function&gt; MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init() {\n  // Prepare constructor template\n  Local&lt;FunctionTemplate&gt; tpl = FunctionTemplate::New(New);\n  tpl-&gt;SetClassName(String::NewSymbol(&quot;MyObject&quot;));\n  tpl-&gt;InstanceTemplate()-&gt;SetInternalFieldCount(1);\n  // Prototype\n  tpl-&gt;PrototypeTemplate()-&gt;Set(String::NewSymbol(&quot;plusOne&quot;),\n      FunctionTemplate::New(PlusOne)-&gt;GetFunction());\n  constructor = Persistent&lt;Function&gt;::New(tpl-&gt;GetFunction());\n}\n\nHandle&lt;Value&gt; MyObject::New(const Arguments&amp; args) {\n  HandleScope scope;\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]-&gt;IsUndefined() ? 0 : args[0]-&gt;NumberValue();\n    MyObject* obj = new MyObject(value);\n    obj-&gt;Wrap(args.This());\n    return args.This();\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&lt;Value&gt; argv[argc] = { args[0] };\n    return scope.Close(constructor-&gt;NewInstance(argc, argv));\n  }\n}\n\nHandle&lt;Value&gt; MyObject::NewInstance(const Arguments&amp; args) {\n  HandleScope scope;\n\n  const unsigned argc = 1;\n  Handle&lt;Value&gt; argv[argc] = { args[0] };\n  Local&lt;Object&gt; instance = constructor-&gt;NewInstance(argc, argv);\n\n  return scope.Close(instance);\n}\n\nHandle&lt;Value&gt; MyObject::PlusOne(const Arguments&amp; args) {\n  HandleScope scope;\n\n  MyObject* obj = ObjectWrap::Unwrap&lt;MyObject&gt;(args.This());\n  obj-&gt;value_ += 1;\n\n  return scope.Close(Number::New(obj-&gt;value_));\n}</code></pre>\n<p>Test it with:\n\n</p>\n<pre><code>var createObject = require(&#39;./build/Release/addon&#39;);\n\nvar obj = createObject(10);\nconsole.log( obj.plusOne() ); // 11\nconsole.log( obj.plusOne() ); // 12\nconsole.log( obj.plusOne() ); // 13\n\nvar obj2 = createObject(20);\nconsole.log( obj2.plusOne() ); // 21\nconsole.log( obj2.plusOne() ); // 22\nconsole.log( obj2.plusOne() ); // 23</code></pre>\n",
              "type": "module",
              "displayName": "Factory of wrapped objects"
            },
            {
              "textRaw": "Passing wrapped objects around",
              "name": "passing_wrapped_objects_around",
              "desc": "<p>In addition to wrapping and returning C++ objects, you can pass them around\nby unwrapping them with Node&#39;s <code>node::ObjectWrap::Unwrap</code> helper function.\nIn the following <code>addon.cc</code> we introduce a function <code>add()</code> that can take on two\n<code>MyObject</code> objects:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nHandle&lt;Value&gt; CreateObject(const Arguments&amp; args) {\n  HandleScope scope;\n  return scope.Close(MyObject::NewInstance(args));\n}\n\nHandle&lt;Value&gt; Add(const Arguments&amp; args) {\n  HandleScope scope;\n\n  MyObject* obj1 = node::ObjectWrap::Unwrap&lt;MyObject&gt;(\n      args[0]-&gt;ToObject());\n  MyObject* obj2 = node::ObjectWrap::Unwrap&lt;MyObject&gt;(\n      args[1]-&gt;ToObject());\n\n  double sum = obj1-&gt;Value() + obj2-&gt;Value();\n  return scope.Close(Number::New(sum));\n}\n\nvoid InitAll(Handle&lt;Object&gt; exports) {\n  MyObject::Init();\n\n  exports-&gt;Set(String::NewSymbol(&quot;createObject&quot;),\n      FunctionTemplate::New(CreateObject)-&gt;GetFunction());\n\n  exports-&gt;Set(String::NewSymbol(&quot;add&quot;),\n      FunctionTemplate::New(Add)-&gt;GetFunction());\n}\n\nNODE_MODULE(addon, InitAll)</code></pre>\n<p>To make things interesting we introduce a public method in <code>myobject.h</code> so we\ncan probe private values after unwrapping the object:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#ifndef MYOBJECT_H\n#define MYOBJECT_H\n\n#include &lt;node.h&gt;\n\nclass MyObject : public node::ObjectWrap {\n public:\n  static void Init();\n  static v8::Handle&lt;v8::Value&gt; NewInstance(const v8::Arguments&amp; args);\n  double Value() const { return value_; }\n\n private:\n  explicit MyObject(double value = 0);\n  ~MyObject();\n\n  static v8::Handle&lt;v8::Value&gt; New(const v8::Arguments&amp; args);\n  static v8::Persistent&lt;v8::Function&gt; constructor;\n  double value_;\n};\n\n#endif</code></pre>\n<p>The implementation of <code>myobject.cc</code> is similar as before:\n\n</p>\n<pre><code>#define BUILDING_NODE_EXTENSION\n#include &lt;node.h&gt;\n#include &quot;myobject.h&quot;\n\nusing namespace v8;\n\nPersistent&lt;Function&gt; MyObject::constructor;\n\nMyObject::MyObject(double value) : value_(value) {\n}\n\nMyObject::~MyObject() {\n}\n\nvoid MyObject::Init() {\n  // Prepare constructor template\n  Local&lt;FunctionTemplate&gt; tpl = FunctionTemplate::New(New);\n  tpl-&gt;SetClassName(String::NewSymbol(&quot;MyObject&quot;));\n  tpl-&gt;InstanceTemplate()-&gt;SetInternalFieldCount(1);\n  constructor = Persistent&lt;Function&gt;::New(tpl-&gt;GetFunction());\n}\n\nHandle&lt;Value&gt; MyObject::New(const Arguments&amp; args) {\n  HandleScope scope;\n\n  if (args.IsConstructCall()) {\n    // Invoked as constructor: `new MyObject(...)`\n    double value = args[0]-&gt;IsUndefined() ? 0 : args[0]-&gt;NumberValue();\n    MyObject* obj = new MyObject(value);\n    obj-&gt;Wrap(args.This());\n    return args.This();\n  } else {\n    // Invoked as plain function `MyObject(...)`, turn into construct call.\n    const int argc = 1;\n    Local&lt;Value&gt; argv[argc] = { args[0] };\n    return scope.Close(constructor-&gt;NewInstance(argc, argv));\n  }\n}\n\nHandle&lt;Value&gt; MyObject::NewInstance(const Arguments&amp; args) {\n  HandleScope scope;\n\n  const unsigned argc = 1;\n  Handle&lt;Value&gt; argv[argc] = { args[0] };\n  Local&lt;Object&gt; instance = constructor-&gt;NewInstance(argc, argv);\n\n  return scope.Close(instance);\n}</code></pre>\n<p>Test it with:\n\n</p>\n<pre><code>var addon = require(&#39;./build/Release/addon&#39;);\n\nvar obj1 = addon.createObject(10);\nvar obj2 = addon.createObject(20);\nvar result = addon.add(obj1, obj2);\n\nconsole.log(result); // 30</code></pre>\n",
              "type": "module",
              "displayName": "Passing wrapped objects around"
            }
          ],
          "type": "module",
          "displayName": "Addon patterns"
        }
      ],
      "type": "module",
      "displayName": "Addons"
    }
  ]
}