Format the codebase by npm run format

Fix #None

Author: Minggang Wang

src/addon.cpp

@@ -29,19 +29,23 @@ void InitModule(v8::Local<v8::Object> exports) {
 
   for (uint32_t i = 0;
        i < rclnodejs::GetBindingMethodsCount(rclnodejs::binding_methods); i++) {
-    Nan::Set(exports,
-        Nan::New(rclnodejs::binding_methods[i].name).ToLocalChecked(),
+    Nan::Set(
+        exports, Nan::New(rclnodejs::binding_methods[i].name).ToLocalChecked(),
         Nan::New<v8::FunctionTemplate>(rclnodejs::binding_methods[i].function)
-            ->GetFunction(context).ToLocalChecked());
+            ->GetFunction(context)
+            .ToLocalChecked());
   }
 
-  for (uint32_t i = 0; i < rclnodejs::GetBindingMethodsCount(
-      rclnodejs::action_binding_methods); i++) {
-    Nan::Set(exports,
+  for (uint32_t i = 0;
+       i < rclnodejs::GetBindingMethodsCount(rclnodejs::action_binding_methods);
+       i++) {
+    Nan::Set(
+        exports,
         Nan::New(rclnodejs::action_binding_methods[i].name).ToLocalChecked(),
         Nan::New<v8::FunctionTemplate>(
             rclnodejs::action_binding_methods[i].function)
-                ->GetFunction(context).ToLocalChecked());
+            ->GetFunction(context)
+            .ToLocalChecked());
   }
 
   rclnodejs::ShadowNode::Init(exports);

src/executor.cpp

@@ -15,6 +15,7 @@
 #include "executor.hpp"
 
 #include <rcl/error_handling.h>
+
 #include <stdexcept>
 #include <string>
 
@@ -23,9 +24,9 @@
 #include "spdlog/spdlog.h"
 
 #ifdef WIN32
-    #define UNUSED
+#define UNUSED
 #else
-    #define UNUSED __attribute__((unused))
+#define UNUSED __attribute__((unused))
 #endif
 
 namespace rclnodejs {
@@ -64,16 +65,14 @@ void Executor::SpinOnce(rcl_context_t* context, int32_t time_out) {
   if (!running_.load()) {
     try {
       rcl_wait_set_t wait_set = rcl_get_zero_initialized_wait_set();
-      rcl_ret_t ret =
-          rcl_wait_set_init(&wait_set, 0, 2, 0, 0, 0, 0, context,
-                            rcl_get_default_allocator());
+      rcl_ret_t ret = rcl_wait_set_init(&wait_set, 0, 2, 0, 0, 0, 0, context,
+                                        rcl_get_default_allocator());
       if (ret != RCL_RET_OK) {
         throw std::runtime_error(std::string("Init waitset failed: ") +
                                  rcl_get_error_string().str);
       }
 
-      if (WaitForReadyCallbacks(&wait_set, time_out))
-        ExecuteReadyHandles();
+      if (WaitForReadyCallbacks(&wait_set, time_out)) ExecuteReadyHandles();
 
       if (rcl_wait_set_fini(&wait_set) != RCL_RET_OK) {
         std::string error_message =
@@ -105,8 +104,7 @@ void Executor::Stop() {
                  delete async;
                  handle_closed = true;
                });
-      while (!handle_closed)
-        uv_run(uv_default_loop(), UV_RUN_ONCE);
+      while (!handle_closed) uv_run(uv_default_loop(), UV_RUN_ONCE);
 
       SPDLOG_DEBUG(spdlog::get("rclnodejs"), "Background thread stopped.");
     }
@@ -158,10 +156,9 @@ void Executor::Run(void* arg) {
   }
 }
 
-bool Executor::WaitForReadyCallbacks(
-    rcl_wait_set_t* wait_set, int32_t time_out) {
-  if (handle_manager_->is_empty())
-    return false;
+bool Executor::WaitForReadyCallbacks(rcl_wait_set_t* wait_set,
+                                     int32_t time_out) {
+  if (handle_manager_->is_empty()) return false;
 
   size_t num_subscriptions = 0u;
   size_t num_guard_conditions = 0u;
@@ -170,19 +167,15 @@ bool Executor::WaitForReadyCallbacks(
   size_t num_services = 0u;
 
   if (!handle_manager_->GetEntityCounts(&num_subscriptions,
-                                        &num_guard_conditions,
-                                        &num_timers,
-                                        &num_clients,
-                                        &num_services)) {
+                                        &num_guard_conditions, &num_timers,
+                                        &num_clients, &num_services)) {
     std::string error_message = std::string("Failed to get entity counts: ") +
                                 std::string(rcl_get_error_string().str);
     throw std::runtime_error(error_message);
   }
 
   if (rcl_wait_set_resize(wait_set, num_subscriptions,
-                          num_guard_conditions + 1u,
-                          num_timers,
-                          num_clients,
+                          num_guard_conditions + 1u, num_timers, num_clients,
                           num_services,
                           // TODO(minggang): support events.
                           0u) != RCL_RET_OK) {
@@ -196,15 +189,15 @@ bool Executor::WaitForReadyCallbacks(
   }
 
   int ignored UNUSED =
-    rcl_wait_set_add_guard_condition(wait_set, g_sigint_gc, nullptr);
+      rcl_wait_set_add_guard_condition(wait_set, g_sigint_gc, nullptr);
 
   time_out = time_out < 0 ? -1 : RCL_MS_TO_NS(time_out);
 
   rcl_ret_t status = rcl_wait(wait_set, time_out);
   if (status == RCL_RET_WAIT_SET_EMPTY) {
   } else if (status != RCL_RET_OK && status != RCL_RET_TIMEOUT) {
     throw std::runtime_error(std::string("rcl_wait() failed: ") +
-                              rcl_get_error_string().str);
+                             rcl_get_error_string().str);
   } else {
     if (wait_set->size_of_guard_conditions == 1 &&
         wait_set->guard_conditions[0]) {
@@ -220,9 +213,8 @@ bool Executor::WaitForReadyCallbacks(
   }
 
   if (rcl_wait_set_clear(wait_set) != RCL_RET_OK) {
-    std::string error_message =
-        std::string("Failed to clear wait set: ") +
-        std::string(rcl_get_error_string().str);
+    std::string error_message = std::string("Failed to clear wait set: ") +
+                                std::string(rcl_get_error_string().str);
     throw std::runtime_error(error_message);
   }
 

src/executor.hpp

@@ -15,8 +15,8 @@
 #ifndef RCLNODEJS_EXECUTOR_HPP_
 #define RCLNODEJS_EXECUTOR_HPP_
 
-#include <uv.h>
 #include <rcl/wait.h>
+#include <uv.h>
 
 #include <atomic>
 #include <exception>
@@ -34,8 +34,7 @@ class Executor {
  public:
   class Delegate {
    public:
-    virtual void Execute(
-        const std::vector<rclnodejs::RclHandle *>& handles) = 0;
+    virtual void Execute(const std::vector<rclnodejs::RclHandle*>& handles) = 0;
     virtual void CatchException(std::exception_ptr e_ptr) = 0;
   };
 

src/handle_manager.cpp

@@ -15,6 +15,7 @@
 #include "handle_manager.hpp"
 
 #include <rcl_action/rcl_action.h>
+
 #include <vector>
 
 #include "spdlog/spdlog.h"
@@ -80,15 +81,11 @@ void HandleManager::CollectHandles(const v8::Local<v8::Object> node) {
   is_synchronizing_.store(false);
   uv_sem_post(&sem_);
 
-  SPDLOG_DEBUG(
-      spdlog::get("rclnodejs"),
-      "Add {0:d} timers, {1:d} subscriptions, {2:d} clients, " +
-          "{3:d} services, {4:d} guards.",
-      timers_.size(),
-      subscriptions_.size(),
-      clients_.size(),
-      services_.size(),
-      guard_conditions_.size());
+  SPDLOG_DEBUG(spdlog::get("rclnodejs"),
+               "Add {0:d} timers, {1:d} subscriptions, {2:d} clients, " +
+                   "{3:d} services, {4:d} guards.",
+               timers_.size(), subscriptions_.size(), clients_.size(),
+               services_.size(), guard_conditions_.size());
 }
 
 bool HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
@@ -98,7 +95,7 @@ bool HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
       return false;
   }
   for (auto& subscription : subscriptions_) {
-    rcl_subscription_t* rcl_subscription  =
+    rcl_subscription_t* rcl_subscription =
         reinterpret_cast<rcl_subscription_t*>(subscription->ptr());
     if (rcl_wait_set_add_subscription(wait_set, rcl_subscription, nullptr) !=
         RCL_RET_OK)
@@ -118,22 +115,22 @@ bool HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
   for (auto& guard_condition : guard_conditions_) {
     rcl_guard_condition_t* rcl_guard_condition =
         reinterpret_cast<rcl_guard_condition_t*>(guard_condition->ptr());
-    if (rcl_wait_set_add_guard_condition(wait_set, rcl_guard_condition, nullptr)
-        !=  RCL_RET_OK)
+    if (rcl_wait_set_add_guard_condition(wait_set, rcl_guard_condition,
+                                         nullptr) != RCL_RET_OK)
       return false;
   }
   for (auto& action_client : action_clients_) {
     rcl_action_client_t* rcl_action_client =
         reinterpret_cast<rcl_action_client_t*>(action_client->ptr());
     if (rcl_action_wait_set_add_action_client(wait_set, rcl_action_client,
-        nullptr, nullptr) !=  RCL_RET_OK)
+                                              nullptr, nullptr) != RCL_RET_OK)
       return false;
   }
   for (auto& action_server : action_servers_) {
     rcl_action_server_t* rcl_action_server =
         reinterpret_cast<rcl_action_server_t*>(action_server->ptr());
     if (rcl_action_wait_set_add_action_server(wait_set, rcl_action_server,
-        nullptr) != RCL_RET_OK)
+                                              nullptr) != RCL_RET_OK)
       return false;
   }
 
@@ -143,36 +140,25 @@ bool HandleManager::AddHandlesToWaitSet(rcl_wait_set_t* wait_set) {
 bool HandleManager::CollectReadyHandles(rcl_wait_set_t* wait_set) {
   ready_handles_.clear();
 
-  CollectReadyHandlesByType(
-    wait_set->subscriptions,
-    wait_set->size_of_subscriptions,
-    subscriptions_);
-  CollectReadyHandlesByType(
-    wait_set->clients,
-    wait_set->size_of_clients,
-    clients_);
-  CollectReadyHandlesByType(
-    wait_set->services,
-    wait_set->size_of_services,
-    services_);
-  CollectReadyHandlesByType(
-    wait_set->timers,
-    wait_set->size_of_timers,
-    timers_);
-  CollectReadyHandlesByType(
-    wait_set->guard_conditions,
-    wait_set->size_of_guard_conditions,
-    guard_conditions_);
+  CollectReadyHandlesByType(wait_set->subscriptions,
+                            wait_set->size_of_subscriptions, subscriptions_);
+  CollectReadyHandlesByType(wait_set->clients, wait_set->size_of_clients,
+                            clients_);
+  CollectReadyHandlesByType(wait_set->services, wait_set->size_of_services,
+                            services_);
+  CollectReadyHandlesByType(wait_set->timers, wait_set->size_of_timers,
+                            timers_);
+  CollectReadyHandlesByType(wait_set->guard_conditions,
+                            wait_set->size_of_guard_conditions,
+                            guard_conditions_);
 
   return CollectReadyActionHandles(wait_set);
 }
 
-bool HandleManager::GetEntityCounts(
-    size_t *subscriptions_size,
-    size_t *guard_conditions_size,
-    size_t *timers_size,
-    size_t *clients_size,
-    size_t *services_size) {
+bool HandleManager::GetEntityCounts(size_t* subscriptions_size,
+                                    size_t* guard_conditions_size,
+                                    size_t* timers_size, size_t* clients_size,
+                                    size_t* services_size) {
   size_t num_subscriptions = 0u;
   size_t num_guard_conditions = 0u;
   size_t num_timers = 0u;
@@ -183,12 +169,8 @@ bool HandleManager::GetEntityCounts(
     rcl_action_client_t* rcl_action_client =
         reinterpret_cast<rcl_action_client_t*>(action_client->ptr());
     rcl_ret_t ret = rcl_action_client_wait_set_get_num_entities(
-        rcl_action_client,
-        &num_subscriptions,
-        &num_guard_conditions,
-        &num_timers,
-        &num_clients,
-        &num_services);
+        rcl_action_client, &num_subscriptions, &num_guard_conditions,
+        &num_timers, &num_clients, &num_services);
     if (ret != RCL_RET_OK) {
       return false;
     }
@@ -204,12 +186,8 @@ bool HandleManager::GetEntityCounts(
     rcl_action_server_t* rcl_action_server =
         reinterpret_cast<rcl_action_server_t*>(action_server->ptr());
     rcl_ret_t ret = rcl_action_server_wait_set_get_num_entities(
-        rcl_action_server,
-        &num_subscriptions,
-        &num_guard_conditions,
-        &num_timers,
-        &num_clients,
-        &num_services);
+        rcl_action_server, &num_subscriptions, &num_guard_conditions,
+        &num_timers, &num_clients, &num_services);
     if (ret != RCL_RET_OK) {
       return false;
     }
@@ -246,13 +224,16 @@ void HandleManager::CollectHandlesByType(
   Nan::HandleScope scope;
 
   if (typeObject->IsArray()) {
-    uint32_t length = Nan::To<uint32_t>(
-        Nan::Get(typeObject, Nan::New("length").ToLocalChecked())
-            .ToLocalChecked()).FromJust();
+    uint32_t length =
+        Nan::To<uint32_t>(
+            Nan::Get(typeObject, Nan::New("length").ToLocalChecked())
+                .ToLocalChecked())
+            .FromJust();
 
     for (uint32_t index = 0; index < length; index++) {
-      v8::Local<v8::Object> obj = Nan::To<v8::Object>(
-          Nan::Get(typeObject, index).ToLocalChecked()).ToLocalChecked();
+      v8::Local<v8::Object> obj =
+          Nan::To<v8::Object>(Nan::Get(typeObject, index).ToLocalChecked())
+              .ToLocalChecked();
       Nan::MaybeLocal<v8::Value> handle =
           Nan::Get(obj, Nan::New("_handle").ToLocalChecked());
       rclnodejs::RclHandle* rcl_handle =
@@ -263,10 +244,9 @@ void HandleManager::CollectHandlesByType(
   }
 }
 
-template<typename T>
+template <typename T>
 void HandleManager::CollectReadyHandlesByType(
-    const T** struct_ptr,
-    size_t size,
+    const T** struct_ptr, size_t size,
     const std::vector<rclnodejs::RclHandle*>& handles) {
   for (size_t idx = 0; idx < size; ++idx) {
     if (struct_ptr[idx]) {
@@ -290,12 +270,8 @@ bool HandleManager::CollectReadyActionHandles(rcl_wait_set_t* wait_set) {
     rcl_action_client_t* rcl_action_client =
         reinterpret_cast<rcl_action_client_t*>(action_client->ptr());
     rcl_ret_t ret = rcl_action_client_wait_set_get_entities_ready(
-        wait_set,
-        rcl_action_client,
-        &is_feedback_ready,
-        &is_status_ready,
-        &is_goal_response_ready,
-        &is_cancel_response_ready,
+        wait_set, rcl_action_client, &is_feedback_ready, &is_status_ready,
+        &is_goal_response_ready, &is_cancel_response_ready,
         &is_result_response_ready);
     if (ret != RCL_RET_OK) {
       return false;
@@ -325,12 +301,8 @@ bool HandleManager::CollectReadyActionHandles(rcl_wait_set_t* wait_set) {
     rcl_action_server_t* rcl_action_server =
         reinterpret_cast<rcl_action_server_t*>(action_server->ptr());
     rcl_ret_t ret = rcl_action_server_wait_set_get_entities_ready(
-        wait_set,
-        rcl_action_server,
-        &is_goal_request_ready,
-        &is_cancel_request_ready,
-        &is_result_request_ready,
-        &is_goal_expired);
+        wait_set, rcl_action_server, &is_goal_request_ready,
+        &is_cancel_request_ready, &is_result_request_ready, &is_goal_expired);
     if (ret != RCL_RET_OK) {
       return false;
     }