Return Buffer object with handoff from unique ptr string

src/module_utils.hpp

@@ -1,5 +1,7 @@
 #pragma once
+#include <memory>
 #include <nan.h>
+#include <string>
 
 namespace utils {
 
@@ -24,4 +26,19 @@ inline void CallbackError(std::string message, v8::Local<v8::Function> func) {
     v8::Local<v8::Value> argv[1] = {Nan::Error(message.c_str())};
     Nan::Call(cb, 1, argv);
 }
+
+inline Nan::MaybeLocal<v8::Object> NewBufferFrom(std::unique_ptr<std::string>&& ptr) {
+    Nan::MaybeLocal<v8::Object> res = Nan::NewBuffer(
+        &(*ptr)[0],
+        ptr->size(),
+        [](char*, void* hint) {
+            delete static_cast<std::string*>(hint);
+        },
+        ptr.get());
+    if (!res.IsEmpty()) {
+        ptr.release();
+    }
+    return res;
+}
+
 } // namespace utils

src/object_async/hello_async.cpp

@@ -22,6 +22,7 @@
  * @memberof HelloObjectAsync
  * @param {Object} args - different ways to alter the string
  * @param {boolean} args.louder - adds exclamation points to the string
+ * @param {buffer} args.buffer - returns object as a node buffer rather then string
  * @param {Function} callback - from whence the hello comes, returns a string
  * @returns {String}
  * @example
@@ -44,7 +45,7 @@ namespace object_async {
 // This avoids copying the value and duplicating memory allocation, which can
 // negatively affect performance.
 HelloObjectAsync::HelloObjectAsync(std::string&& name)
-    : name_(std::move(name)) {}
+    : name_(name) {}
 
 // Triggered from Javascript world when calling "new HelloObjectAsync(name)"
 NAN_METHOD(HelloObjectAsync::New) {
@@ -109,7 +110,7 @@ NAN_METHOD(HelloObjectAsync::New) {
 // This function performs expensive allocation of std::map, querying, and string
 // comparison, therefore threads are nice & busy.
 // Also, notice that name is passed by reference (std::string const& name)
-std::string do_expensive_work(bool louder, std::string const& name) {
+std::unique_ptr<std::string> do_expensive_work(bool louder, std::string const& name) {
 
     std::map<std::size_t, std::string> container;
     std::size_t work_to_do = 100000;
@@ -132,10 +133,10 @@ std::string do_expensive_work(bool louder, std::string const& name) {
         }
     }
 
-    std::string result = "...threads are busy async bees...hello " + name;
+    std::unique_ptr<std::string> result = std::make_unique<std::string>("...threads are busy async bees...hello " + name);
 
     if (louder) {
-        result += "!!!!";
+        *result += "!!!!";
     }
 
     return result;
@@ -156,9 +157,15 @@ struct AsyncHelloWorker : Nan::AsyncWorker // NOLINT to disable cppcoreguideline
     // pointer member without the silly g++ warning of "error: ‘struct object_async::AsyncHelloWorker’ has pointer data members [-Werror=effc++]"
     AsyncHelloWorker(AsyncHelloWorker const&) = delete;
     AsyncHelloWorker& operator=(AsyncHelloWorker const&) = delete;
-    AsyncHelloWorker(bool louder, const std::string* name,
+    AsyncHelloWorker(bool louder,
+                     bool buffer,
+                     const std::string* name,
                      Nan::Callback* cb)
-        : Base(cb, "skel:object-async-worker"), louder_{louder}, name_{name} {}
+        : Base(cb, "skel:object-async-worker"),
+          result_(),
+          louder_(louder),
+          buffer_(buffer),
+          name_(name) {}
 
     // The Execute() function is getting called when the worker starts to run.
     // - You only have access to member variables stored in this worker.
@@ -181,16 +188,27 @@ struct AsyncHelloWorker : Nan::AsyncWorker // NOLINT to disable cppcoreguideline
     void HandleOKCallback() override {
         Nan::HandleScope scope;
 
-        const auto argc = 2u;
-        v8::Local<v8::Value> argv[argc] = {
-            Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};
+        if (buffer_) {
+            const auto argc = 2u;
+            v8::Local<v8::Value> argv[argc] = {
+                Nan::Null(), utils::NewBufferFrom(std::move(result_)).ToLocalChecked()};
 
-        // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
-        callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+            // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
+            callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+
+        } else {
+            const auto argc = 2u;
+            v8::Local<v8::Value> argv[argc] = {
+                Nan::Null(), Nan::New<v8::String>(*result_).ToLocalChecked()};
+
+            // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
+            callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+        }
     }
 
-    std::string result_{};
+    std::unique_ptr<std::string> result_;
     const bool louder_;
+    const bool buffer_;
     // We use a pointer here to avoid copying the string data.
     // This works because we know that the original string we are
     // pointing to will be kept in scope/alive for the time while AsyncHelloWorker
@@ -214,6 +232,7 @@ NAN_METHOD(HelloObjectAsync::helloAsync) {
         Nan::ObjectWrap::Unwrap<HelloObjectAsync>(info.Holder());
 
     bool louder = false;
+    bool buffer = false;
 
     // Check second argument, should be a 'callback' function.
     // This allows us to set the callback so we can use it to return errors
@@ -243,6 +262,17 @@ NAN_METHOD(HelloObjectAsync::helloAsync) {
         }
         louder = louder_val->BooleanValue();
     }
+    // Check options object for the "buffer" property, which should be a boolean
+    // value
+    if (options->Has(Nan::New("buffer").ToLocalChecked())) {
+        v8::Local<v8::Value> buffer_val =
+            options->Get(Nan::New("buffer").ToLocalChecked());
+        if (!buffer_val->IsBoolean()) {
+            return utils::CallbackError("option 'buffer' must be a boolean",
+                                        callback);
+        }
+        buffer = buffer_val->BooleanValue();
+    }
 
     // Create a worker instance and queues it to run asynchronously invoking the
     // callback when done.
@@ -251,7 +281,7 @@ NAN_METHOD(HelloObjectAsync::helloAsync) {
     // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes
     // the pointer automatically.
     auto cb = std::make_unique<Nan::Callback>(callback);
-    auto worker = std::make_unique<AsyncHelloWorker>(louder, &h->name_, cb.release());
+    auto worker = std::make_unique<AsyncHelloWorker>(louder, buffer, &h->name_, cb.release());
     Nan::AsyncQueueWorker(worker.release());
 }
 

src/object_sync/hello.cpp

@@ -31,7 +31,7 @@ namespace object_sync {
 // Custom constructor, assigns custom name passed in from Javascript world.
 // This constructor uses member init list via the semicolon, aka "direct initialization"
 // which is more efficient than using assignment operators.
-HelloObject::HelloObject(std::string&& name) : name_(std::move(name)) {}
+HelloObject::HelloObject(std::string&& name) : name_(name) {}
 
 // Triggered from Javascript world when calling "new HelloObject(name)"
 NAN_METHOD(HelloObject::New) {
@@ -167,4 +167,4 @@ void HelloObject::Init(v8::Local<v8::Object> target) {
     Nan::Set(target, whoami, fn);
 }
 
-} // namespace object_sync
+} // namespace object_sync

src/standalone_async/hello_async.cpp

@@ -12,6 +12,7 @@
  * @name helloAsync
  * @param {Object} args - different ways to alter the string
  * @param {boolean} args.louder - adds exclamation points to the string
+ * @param {boolean} args.buffer - returns value as a node buffer rather than a string
  * @param {Function} callback - from whence the hello comes, returns a string
  * @returns {string}
  * @example
@@ -32,7 +33,7 @@ namespace standalone_async {
 
 // Expensive allocation of std::map, querying, and string comparison,
 // therefore threads are busy
-std::string do_expensive_work(bool louder) {
+std::unique_ptr<std::string> do_expensive_work(bool louder) {
 
     std::map<std::size_t, std::string> container;
     std::size_t work_to_do = 100000;
@@ -54,10 +55,10 @@ std::string do_expensive_work(bool louder) {
         }
     }
 
-    std::string result = "...threads are busy async bees...hello world";
+    std::unique_ptr<std::string> result = std::make_unique<std::string>("...threads are busy async bees...hello world");
 
     if (louder) {
-        result += "!!!!";
+        *result += "!!!!";
     }
 
     return result;
@@ -72,8 +73,8 @@ std::string do_expensive_work(bool louder) {
 struct AsyncHelloWorker : Nan::AsyncWorker {
     using Base = Nan::AsyncWorker;
 
-    AsyncHelloWorker(bool louder, Nan::Callback* cb)
-        : Base(cb, "skel:standalone-async-worker"), louder_{louder} {}
+    AsyncHelloWorker(bool louder, bool buffer, Nan::Callback* cb)
+        : Base(cb, "skel:standalone-async-worker"), result_(), louder_(louder), buffer_(buffer) {}
 
     // The Execute() function is getting called when the worker starts to run.
     // - You only have access to member variables stored in this worker.
@@ -98,15 +99,24 @@ struct AsyncHelloWorker : Nan::AsyncWorker {
     void HandleOKCallback() override {
         Nan::HandleScope scope;
 
-        const auto argc = 2u;
-        v8::Local<v8::Value> argv[argc] = {
-            Nan::Null(), Nan::New<v8::String>(result_).ToLocalChecked()};
-        // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
-        callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+        if (buffer_) {
+            const auto argc = 2u;
+            v8::Local<v8::Value> argv[argc] = {
+                Nan::Null(), utils::NewBufferFrom(std::move(result_)).ToLocalChecked()};
+            // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
+            callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+        } else {
+            const auto argc = 2u;
+            v8::Local<v8::Value> argv[argc] = {
+                Nan::Null(), Nan::New<v8::String>(*result_).ToLocalChecked()};
+            // Static cast done here to avoid 'cppcoreguidelines-pro-bounds-array-to-pointer-decay' warning with clang-tidy
+            callback->Call(argc, static_cast<v8::Local<v8::Value>*>(argv), async_resource);
+        }
     }
 
-    std::string result_{};
+    std::unique_ptr<std::string> result_;
     const bool louder_;
+    const bool buffer_;
 };
 
 // helloAsync is a "standalone function" because it's not a class.
@@ -115,6 +125,7 @@ struct AsyncHelloWorker : Nan::AsyncWorker {
 NAN_METHOD(helloAsync) {
 
     bool louder = false;
+    bool buffer = false;
 
     // Check second argument, should be a 'callback' function.
     // This allows us to set the callback so we can use it to return errors
@@ -144,6 +155,17 @@ NAN_METHOD(helloAsync) {
         }
         louder = louder_val->BooleanValue();
     }
+    // Check options object for the "buffer" property, which should be a boolean
+    // value
+    if (options->Has(Nan::New("buffer").ToLocalChecked())) {
+        v8::Local<v8::Value> buffer_val =
+            options->Get(Nan::New("buffer").ToLocalChecked());
+        if (!buffer_val->IsBoolean()) {
+            return utils::CallbackError("option 'buffer' must be a boolean",
+                                        callback);
+        }
+        buffer = buffer_val->BooleanValue();
+    }
 
     // Creates a worker instance and queues it to run asynchronously, invoking the
     // callback when done.
@@ -152,7 +174,7 @@ NAN_METHOD(helloAsync) {
     // - Nan::AsyncQueueWorker takes a pointer to a Nan::AsyncWorker and deletes
     // the pointer automatically.
     auto cb = std::make_unique<Nan::Callback>(callback);
-    auto worker = std::make_unique<AsyncHelloWorker>(louder, cb.release());
+    auto worker = std::make_unique<AsyncHelloWorker>(louder, buffer, cb.release());
     Nan::AsyncQueueWorker(worker.release());
 }
 

test/hello_async.test.js

@@ -17,6 +17,16 @@ test('success: prints regular busy world', function(t) {
   });
 });
 
+test('success: buffer regular busy world', function(t) {
+  module.helloAsync({ buffer: true }, function(err, result) {
+    if (err) throw err;
+    t.equal(result.length, 44);
+    t.equal(typeof(result), 'object');
+    t.equal(result.toString(), '...threads are busy async bees...hello world');
+    t.end();
+  });
+});
+
 test('error: handles invalid louder value', function(t) {
   module.helloAsync({ louder: 'oops' }, function(err, result) {
     t.ok(err, 'expected error');
@@ -25,6 +35,14 @@ test('error: handles invalid louder value', function(t) {
   });
 });
 
+test('error: handles invalid buffer value', function(t) {
+  module.helloAsync({ buffer: 'oops' }, function(err, result) {
+    t.ok(err, 'expected error');
+    t.ok(err.message.indexOf('option \'buffer\' must be a boolean') > -1, 'expected error message');
+    t.end();
+  });
+});
+
 test('error: handles invalid options value', function(t) {
   module.helloAsync('oops', function(err, result) {
     t.ok(err, 'expected error');
@@ -41,4 +59,4 @@ test('error: handles missing callback', function(t) {
     t.ok(err.message.indexOf('second arg \'callback\' must be a function') > -1, 'expected error message');
     t.end();
   }
-});
+});

test/hello_object_async.test.js

@@ -19,6 +19,17 @@ test('success: prints loud busy world', function(t) {
   });
 });
 
+test('success: return buffer busy world', function(t) {
+  var H = new module.HelloObjectAsync('world');
+  H.helloAsync({ buffer: true }, function(err, result) {
+    if (err) throw err;
+    t.equal(result.length, 44);
+    t.equal(typeof(result), 'object');
+    t.equal(result.toString(), '...threads are busy async bees...hello world');
+    t.end();
+  });
+});
+
 test('error: throws when passing empty string', function(t) {
   try {
     var H = new module.HelloObjectAsync('');
@@ -58,6 +69,15 @@ test('error: handles invalid louder value', function(t) {
   });
 });
 
+test('error: handles invalid buffer value', function(t) {
+  var H = new module.HelloObjectAsync('world');
+  H.helloAsync({ buffer: 'oops' }, function(err, result) {
+    t.ok(err, 'expected error');
+    t.ok(err.message.indexOf('option \'buffer\' must be a boolean') > -1, 'expected error message');
+    t.end();
+  });
+});
+
 test('error: handles invalid options value', function(t) {
   var H = new module.HelloObjectAsync('world');
   H.helloAsync('oops', function(err, result) {
@@ -86,4 +106,4 @@ test('error: handles missing arg', function(t) {
     t.ok(err.message.indexOf('must provide string arg') > -1, 'expected error message');
     t.end();
   }
-});
+});