I'm currently writing a native addon for NodeJS using their c++/v8 system, and am attempting to write an array from Javascript, to C++ and later retrieve it. Whenever I attempt to retrieve a value from the array and return it, it returns an empty array - as I'm recently diving into c++ I am unsure if this is my misunderstanding pointers/c++ fundamentals or NodeJS c++ interactions.
My files as follows:
#include "functions.h"
#include <node.h>
#include <nan.h>
using namespace std;
using namespace v8;
NAN_METHOD(nothing) {
}
NAN_METHOD(aString) {
info.GetReturnValue().Set(Nan::New("This is a thing.").ToLocalChecked());
}
NAN_METHOD(aBoolean) {
info.GetReturnValue().Set(false);
}
NAN_METHOD(aNumber) {
info.GetReturnValue().Set(1.75);
}
NAN_METHOD(anObject) {
v8::Local<v8::Object> obj = Nan::New<v8::Object>();
Nan::Set(obj, Nan::New("key").ToLocalChecked(), Nan::New("value").ToLocalChecked());
info.GetReturnValue().Set(obj);
}
NAN_METHOD(anArray) {
v8::Local<v8::Array> arr = Nan::New<v8::Array>(3);
Nan::Set(arr, 0, Nan::New(1));
Nan::Set(arr, 1, Nan::New(2));
Nan::Set(arr, 2, Nan::New(3));
info.GetReturnValue().Set(arr);
}
NAN_METHOD(callback) {
v8::Local<v8::Function> callbackHandle = info[0].As<v8::Function>();
Nan::MakeCallback(Nan::GetCurrentContext()->Global(), callbackHandle, 0, 0);
}
// Wrapper Impl
Nan::Persistent<v8::Function> MyObject::constructor;
NAN_MODULE_INIT(MyObject::Init) {
v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
tpl->SetClassName(Nan::New("MyObject").ToLocalChecked());
tpl->InstanceTemplate()->SetInternalFieldCount(1);
//Nan::SetPrototypeMethod(tpl, "plusOne", PlusOne);
Nan::SetPrototypeMethod(tpl, "getArr", arrY);
Nan::SetPrototypeMethod(tpl, "PassArray", passArray);
Nan::SetPrototypeMethod(tpl, "setArray", SetArray);
constructor.Reset(Nan::GetFunction(tpl).ToLocalChecked());
Nan::Set(target, Nan::New("MyObject").ToLocalChecked(), Nan::GetFunction(tpl).ToLocalChecked());
}
MyObject::MyObject(v8::Local<v8::Array> value) : value_(value) {
}
MyObject::~MyObject() {
}
NAN_METHOD(MyObject::New) {
if (info.IsConstructCall()) {
v8::Local<v8::Array> arr = Nan::New<v8::Array>();
v8::Local<v8::Array> value = v8::Handle<v8::Array>::Cast(arr);
MyObject *obj = new MyObject(value);
obj->Wrap(info.This());
info.GetReturnValue().Set(info.This());
} else {
const int argc = 1;
v8::Local<v8::Value> argv[argc] = {info[0]};
v8::Local<v8::Function> cons = Nan::New(constructor);
info.GetReturnValue().Set(cons->NewInstance(argc, argv));
}
}
// NAN_METHOD(MyObject::PlusOne) {
// MyObject* obj = Nan::ObjectWrap::Unwrap<MyObject>(info.This());
// obj->value_ += 1;
// info.GetReturnValue().Set(obj->value_);
// }
NAN_METHOD(MyObject::SetArray){
Nan::HandleScope scope;
vector<string> result;
Handle<Value> val;
Local<Array> arr = Nan::New<Array>();
MyObject* obj = ObjectWrap::Unwrap<MyObject>(info.Holder());
if (info[0]->IsArray()) {
Handle<Array> jsArray = Handle<Array>::Cast(info[0]);
for (unsigned int i = 0; i < jsArray->Length(); i++) {
val = jsArray->Get(i);
result.push_back(string(*String::Utf8Value(val)));
Nan::Set(arr, i, val);
}
}
info.GetReturnValue().Set(obj->value_);
}
NAN_METHOD(MyObject::arrY){
MyObject* obj = ObjectWrap::Unwrap<MyObject>(info.Holder());
info.GetReturnValue().Set(Local<Array>::Cast(obj->value_));
}
NAN_METHOD(MyObject::passArray) {
Nan::HandleScope scope;
vector<string> result;
Handle<Value> val;
Local<Array> arr = Nan::New<Array>();
if (info[0]->IsArray()) {
Handle<Array> jsArray = Handle<Array>::Cast(info[0]);
for (unsigned int i = 0; i < jsArray->Length(); i++) {
val = jsArray->Get(i);
result.push_back(string(*String::Utf8Value(val)));
Nan::Set(arr, i, val);
}
}
MyObject* obj = Nan::ObjectWrap::Unwrap<MyObject>(info.This());
obj->value_ = arr;
info.GetReturnValue().Set(obj->value_);
}
#ifndef NATIVE_EXTENSION_GRAB_H
#define NATIVE_EXTENSION_GRAB_H
#include <nan.h>
// Example top-level functions. These functions demonstrate how to return various js types.
// Implementations are in functions.cc
NAN_METHOD(nothing);
NAN_METHOD(aString);
NAN_METHOD(aBoolean);
NAN_METHOD(aNumber);
NAN_METHOD(anObject);
NAN_METHOD(anArray);
NAN_METHOD(callback);
// Example with node ObjectWrap
// Based on https://nodejs.org/api/addons.html#addons_wrapping_c_objects but using NAN
class MyObject : public Nan::ObjectWrap {
public:
static NAN_MODULE_INIT(Init);
private:
explicit MyObject(v8::Local<v8::Array> value);
~MyObject();
static NAN_METHOD(New);
static NAN_METHOD(PlusOne);
static NAN_METHOD(SetArray);
static NAN_METHOD(arrY);
static NAN_METHOD(passArray);
static Nan::Persistent<v8::Function> constructor;
v8::Local<v8::Array> value_;
};
#endif
var NativeExtension = require('bindings')('NativeExtension');
module.exports = NativeExtension;
console.log(NativeExtension.aString());
var obj = NativeExtension.MyObject([1,2,3]);
console.log(NativeExtension.aString());
console.log(obj.PassArray([1, 1, 3]));
console.log(obj.getArr());
console.log(obj.setArray())
For testing purposes code is definitely not DRY and it's based upon a non-stripped down version of the nan-boilerplate code which is provided via github which can be found here.
Upon rereading my own code I can definitely tell that my method naming is bad, so PassArr should set an array, and getArr should return the array passed by "PassArr". SetArray was a hackish attempt which I left in.
To reiterate, the functionality I'm attempting to achieve is:
Javascript Array -> C++ variable
C++ variable -> Javascript Array
but the currently functionality does not persist my variable. The outcome of running the index.js is as follows:
This is a thing.
This is a thing.
[ 1, 1, 3 ]
Console {
log: [Function: bound ],
info: [Function: bound ],
warn: [Function: bound ],
error: [Function: bound ],
dir: [Function: bound ],
time: [Function: bound ],
timeEnd: [Function: bound ],
trace: [Function: bound trace],
assert: [Function: bound ],
Console: [Function: Console] }
[]
Better late than never... There are two issues here:
The first is that MyObject::value_
is a local handle. It should be a persistent handle, which you need to reset in ~MyObject()
, or it will leak.
The second issue is that the Array arr
in MyObject::passArray
has length 0, you should construct it with the correct length.