rclnodejs 0.32.5 → 1.0.0

package/src/{rcl_utilities.hpp → rcl_utilities.h}

@@ -12,9 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_RCL_UTILITIES_HPP_
-#define SRC_RCL_UTILITIES_HPP_
+#ifndef SRC_RCL_UTILITIES_H_
+#define SRC_RCL_UTILITIES_H_
 
+#include <napi.h>
+#include <rcl/graph.h>
+#include <rmw/rmw.h>
+
+#include <memory>
 #include <string>
 
 struct rosidl_message_type_support_t;
@@ -35,6 +40,19 @@ const rosidl_action_type_support_t* GetActionTypeSupport(
 
 std::string GetErrorMessageAndClear();
 
+// Store a reference to the environment that can be used for error reporting.
+Napi::Env& GetEnv();
+void StoreEnv(Napi::Env current_env);
+
+std::unique_ptr<rmw_qos_profile_t> GetQoSProfile(Napi::Value qos);
+void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
+                          Napi::Array* result_list);
+
+Napi::Array ConvertToJSTopicEndpointInfoList(
+    Napi::Env env, const rmw_topic_endpoint_info_array_t* info_array);
+
+Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile);
+
 }  // namespace rclnodejs
 
-#endif  // SRC_RCL_UTILITIES_HPP_
+#endif  // SRC_RCL_UTILITIES_H_

package/src/shadow_node.cpp

@@ -12,47 +12,43 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "shadow_node.hpp"
+#include "shadow_node.h"
 
 #include <memory>
 #include <vector>
 
-#include "executor.hpp"
-#include "handle_manager.hpp"
-#include "rcl_handle.hpp"
+#include "executor.h"
+#include "handle_manager.h"
+#include "rcl_handle.h"
 
 namespace rclnodejs {
 
-Nan::Persistent<v8::Function> ShadowNode::constructor;
+Napi::FunctionReference ShadowNode::constructor;
 
-ShadowNode::ShadowNode() : handle_manager_(std::make_unique<HandleManager>()) {
-  executor_ = std::make_unique<Executor>(handle_manager_.get(), this);
+ShadowNode::ShadowNode(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<ShadowNode>(info),
+      handle_manager_(std::make_unique<HandleManager>()) {
+  executor_ =
+      std::make_unique<Executor>(info.Env(), handle_manager_.get(), this);
 }
 
-ShadowNode::~ShadowNode() {
-  Nan::HandleScope scope;
+ShadowNode::~ShadowNode() { StopRunning(); }
 
-  StopRunning();
-}
-
-void ShadowNode::Init(v8::Local<v8::Object> exports) {
-  Nan::HandleScope scope;
-
-  // Prepare constructor template
-  v8::Local<v8::FunctionTemplate> tpl = Nan::New<v8::FunctionTemplate>(New);
-  tpl->SetClassName(Nan::New("ShadowNode").ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+void ShadowNode::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
 
-  Nan::SetPrototypeMethod(tpl, "start", Start);
-  Nan::SetPrototypeMethod(tpl, "stop", Stop);
-  Nan::SetPrototypeMethod(tpl, "syncHandles", SyncHandles);
-  Nan::SetPrototypeMethod(tpl, "spinOnce", SpinOnce);
+  Napi::Function func =
+      DefineClass(env, "ShadowNode",
+                  {
+                      InstanceMethod("start", &ShadowNode::Start),
+                      InstanceMethod("stop", &ShadowNode::Stop),
+                      InstanceMethod("syncHandles", &ShadowNode::SyncHandles),
+                      InstanceMethod("spinOnce", &ShadowNode::SpinOnce),
+                  });
 
-  v8::Local<v8::Context> context = exports->GetIsolate()->GetCurrentContext();
-
-  constructor.Reset(tpl->GetFunction(context).ToLocalChecked());
-  Nan::Set(exports, Nan::New("ShadowNode").ToLocalChecked(),
-           tpl->GetFunction(context).ToLocalChecked());
+  constructor = Napi::Persistent(func);
+  constructor.SuppressDestruct();
+  exports.Set("ShadowNode", func);
 }
 
 void ShadowNode::StopRunning() {
@@ -61,82 +57,67 @@ void ShadowNode::StopRunning() {
 }
 
 void ShadowNode::StartRunning(rcl_context_t* context, int32_t timeout) {
-  handle_manager_->SynchronizeHandles(this->handle());
+  handle_manager_->SynchronizeHandles(this->Value());
   executor_->Start(context, timeout);
 }
 
 void ShadowNode::RunOnce(rcl_context_t* context, int32_t timeout) {
-  handle_manager_->SynchronizeHandles(this->handle());
+  handle_manager_->SynchronizeHandles(this->Value());
   executor_->SpinOnce(context, timeout);
 }
 
-NAN_METHOD(ShadowNode::Start) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  auto timeout = Nan::To<int32_t>(info[1]).FromJust();
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  if (me) me->StartRunning(context, timeout);
+Napi::Value ShadowNode::Start(const Napi::CallbackInfo& info) {
+  Napi::Object context_handle = info[0].As<Napi::Object>();
+  RclHandle* handle = RclHandle::Unwrap(context_handle);
+  int32_t timeout = info[1].As<Napi::Number>().Int32Value();
 
-  info.GetReturnValue().Set(Nan::Undefined());
-}
+  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
+  StartRunning(context, timeout);
 
-NAN_METHOD(ShadowNode::Stop) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  if (me) me->StopRunning();
+  return info.Env().Undefined();
+}
 
-  info.GetReturnValue().Set(Nan::Undefined());
+Napi::Value ShadowNode::Stop(const Napi::CallbackInfo& info) {
+  StopRunning();
+  return info.Env().Undefined();
 }
 
-NAN_METHOD(ShadowNode::SpinOnce) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  RclHandle* context_handle = RclHandle::Unwrap<RclHandle>(
-      Nan::To<v8::Object>(info[0]).ToLocalChecked());
-  auto timeout = Nan::To<int32_t>(info[1]).FromJust();
-  rcl_context_t* context =
-      reinterpret_cast<rcl_context_t*>(context_handle->ptr());
-  if (me) me->RunOnce(context, timeout);
+Napi::Value ShadowNode::SpinOnce(const Napi::CallbackInfo& info) {
+  Napi::Object context_handle = info[0].As<Napi::Object>();
+  RclHandle* handle = RclHandle::Unwrap(context_handle);
+  int32_t timeout = info[1].As<Napi::Number>().Int32Value();
+
+  rcl_context_t* context = reinterpret_cast<rcl_context_t*>(handle->ptr());
+  RunOnce(context, timeout);
 
-  info.GetReturnValue().Set(Nan::Undefined());
+  return info.Env().Undefined();
 }
 
-NAN_METHOD(ShadowNode::SyncHandles) {
-  auto* me = Nan::ObjectWrap::Unwrap<ShadowNode>(info.Holder());
-  if (me) {
-    me->handle_manager()->SynchronizeHandles(me->handle());
-  }
+Napi::Value ShadowNode::SyncHandles(const Napi::CallbackInfo& info) {
+  handle_manager()->SynchronizeHandles(this->Value());
+  return info.Env().Undefined();
 }
 
 void ShadowNode::Execute(const std::vector<rclnodejs::RclHandle*>& handles) {
-  Nan::HandleScope scope;
-  Nan::AsyncResource res("shadow_node");
+  Napi::Env env = Env();
+  Napi::HandleScope scope(env);
 
-  v8::Local<v8::Array> results = Nan::New<v8::Array>(handles.size());
+  Napi::Array results = Napi::Array::New(env, handles.size());
   for (size_t i = 0; i < handles.size(); ++i) {
     handles[i]->SyncProperties();
-    Nan::Set(results, i, handles[i]->handle());
+    results[i] = handles[i]->Value();
   }
 
-  v8::Local<v8::Value> argv[] = {results};
-
-  res.runInAsyncScope(Nan::New(this->persistent()), "execute", 1, argv);
+  Napi::Function execute =
+      Value().As<Napi::Object>().Get("execute").As<Napi::Function>();
+  execute.Call(Value(), {results});
 }
 
 void ShadowNode::CatchException(std::exception_ptr e_ptr) {
   try {
     std::rethrow_exception(e_ptr);
   } catch (const std::exception& e) {
-    Nan::ThrowError(e.what());
-  }
-}
-
-void ShadowNode::New(const Nan::FunctionCallbackInfo<v8::Value>& info) {
-  if (info.IsConstructCall()) {
-    // Invoked as constructor: `new ShadowNode(...)`
-    ShadowNode* obj = new ShadowNode();
-    obj->Wrap(info.This());
-    info.GetReturnValue().Set(info.This());
+    Napi::Error::New(Env(), e.what()).ThrowAsJavaScriptException();
   }
 }
 

package/src/{shadow_node.hpp → shadow_node.h}

@@ -12,25 +12,26 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef SRC_SHADOW_NODE_HPP_
-#define SRC_SHADOW_NODE_HPP_
+#ifndef SRC_SHADOW_NODE_H_
+#define SRC_SHADOW_NODE_H_
 
-#include <nan.h>
+#include <napi.h>
 
 #include <exception>
 #include <memory>
 #include <vector>
 
-#include "executor.hpp"
+#include "executor.h"
 
 namespace rclnodejs {
 
 class HandleManager;
 class Executor;
 
-class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
+class ShadowNode : public Napi::ObjectWrap<ShadowNode>,
+                   public Executor::Delegate {
  public:
-  static void Init(v8::Local<v8::Object> exports);
+  static void Init(Napi::Env env, Napi::Object exports);
   void StartRunning(rcl_context_t* context, int32_t timeout);
   void StopRunning();
   void RunOnce(rcl_context_t* context, int32_t timeout);
@@ -41,18 +42,18 @@ class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
   void Execute(const std::vector<rclnodejs::RclHandle*>& handles) override;
   void CatchException(std::exception_ptr e_ptr) override;
 
- private:
-  ShadowNode();
+  explicit ShadowNode(const Napi::CallbackInfo& info);
   ~ShadowNode();
 
-  static void New(const Nan::FunctionCallbackInfo<v8::Value>& info);
-  static Nan::Persistent<v8::Function> constructor;
-  static NAN_METHOD(Stop);
-  static NAN_METHOD(Start);
-  static NAN_METHOD(SyncHandles);
-  static NAN_METHOD(SpinOnce);
-  static NAN_GETTER(HandleGetter);
-  static NAN_SETTER(HandleSetter);
+ private:
+  static Napi::FunctionReference constructor;
+
+  Napi::Value Stop(const Napi::CallbackInfo& info);
+  Napi::Value Start(const Napi::CallbackInfo& info);
+  Napi::Value SyncHandles(const Napi::CallbackInfo& info);
+  Napi::Value SpinOnce(const Napi::CallbackInfo& info);
+  Napi::Value HandleGetter(const Napi::CallbackInfo& info);
+  void HandleSetter(const Napi::CallbackInfo& info, const Napi::Value& value);
 
   std::unique_ptr<HandleManager> handle_manager_;
   std::unique_ptr<Executor> executor_;
@@ -60,4 +61,4 @@ class ShadowNode : public Nan::ObjectWrap, public Executor::Delegate {
 
 }  // namespace rclnodejs
 
-#endif  // SRC_SHADOW_NODE_HPP_
+#endif  // SRC_SHADOW_NODE_H_

package/types/context.d.ts

@@ -87,5 +87,11 @@ declare module 'rclnodejs' {
      * @returns The default Context
      */
     static defaultContext(): Context;
+
+    /**
+     * Get the domain ID of this context.
+     * @returns domain ID of this context
+     */
+    domainId(): number;
   }
 }