Apply default GSG-based ROS2 format keeping blank lines.

Signed-off-by: Michel Hidalgo <michel@ekumenlabs.com>

rclcpp/include/rclcpp/allocator/allocator_common.hpp

@@ -26,10 +26,10 @@ namespace rclcpp
 namespace allocator
 {
 
-template<typename T, typename Alloc>
+template <typename T, typename Alloc>
 using AllocRebind = typename std::allocator_traits<Alloc>::template rebind_traits<T>;
 
-template<typename Alloc>
+template <typename Alloc>
 void * retyped_allocate(size_t size, void * untyped_allocator)
 {
   auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -39,7 +39,7 @@ void * retyped_allocate(size_t size, void * untyped_allocator)
   return std::allocator_traits<Alloc>::allocate(*typed_allocator, size);
 }
 
-template<typename T, typename Alloc>
+template <typename T, typename Alloc>
 void retyped_deallocate(void * untyped_pointer, void * untyped_allocator)
 {
   auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -50,7 +50,7 @@ void retyped_deallocate(void * untyped_pointer, void * untyped_allocator)
   std::allocator_traits<Alloc>::deallocate(*typed_allocator, typed_ptr, 1);
 }
 
-template<typename T, typename Alloc>
+template <typename T, typename Alloc>
 void * retyped_reallocate(void * untyped_pointer, size_t size, void * untyped_allocator)
 {
   auto typed_allocator = static_cast<Alloc *>(untyped_allocator);
@@ -62,11 +62,9 @@ void * retyped_reallocate(void * untyped_pointer, size_t size, void * untyped_al
   return std::allocator_traits<Alloc>::allocate(*typed_allocator, size);
 }
 
-
 // Convert a std::allocator_traits-formatted Allocator into an rcl allocator
-template<
-  typename T,
-  typename Alloc,
+template <
+  typename T, typename Alloc,
   typename std::enable_if<!std::is_same<Alloc, std::allocator<void>>::value>::type * = nullptr>
 rcl_allocator_t get_rcl_allocator(Alloc & allocator)
 {
@@ -83,9 +81,8 @@ rcl_allocator_t get_rcl_allocator(Alloc & allocator)
 }
 
 // TODO(jacquelinekay) Workaround for an incomplete implementation of std::allocator<void>
-template<
-  typename T,
-  typename Alloc,
+template <
+  typename T, typename Alloc,
   typename std::enable_if<std::is_same<Alloc, std::allocator<void>>::value>::type * = nullptr>
 rcl_allocator_t get_rcl_allocator(Alloc & allocator)
 {

rclcpp/include/rclcpp/allocator/allocator_deleter.hpp

@@ -23,30 +23,24 @@ namespace rclcpp
 namespace allocator
 {
 
-template<typename Allocator>
+template <typename Allocator>
 class AllocatorDeleter
 {
-  template<typename T>
+  template <typename T>
   using AllocRebind = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
 
 public:
-  AllocatorDeleter()
-  : allocator_(nullptr)
-  {
-  }
+  AllocatorDeleter() : allocator_(nullptr) {}
 
-  explicit AllocatorDeleter(Allocator * a)
-  : allocator_(a)
-  {
-  }
+  explicit AllocatorDeleter(Allocator * a) : allocator_(a) {}
 
-  template<typename T>
+  template <typename T>
   AllocatorDeleter(const AllocatorDeleter<T> & a)
   {
     allocator_ = a.get_allocator();
   }
 
-  template<typename T>
+  template <typename T>
   void operator()(T * ptr)
   {
     std::allocator_traits<AllocRebind<T>>::destroy(*allocator_, ptr);
@@ -54,36 +48,30 @@ public:
     ptr = nullptr;
   }
 
-  Allocator * get_allocator() const
-  {
-    return allocator_;
-  }
+  Allocator * get_allocator() const { return allocator_; }
 
-  void set_allocator(Allocator * alloc)
-  {
-    allocator_ = alloc;
-  }
+  void set_allocator(Allocator * alloc) { allocator_ = alloc; }
 
 private:
   Allocator * allocator_;
 };
 
-template<typename Alloc, typename T, typename D>
+template <typename Alloc, typename T, typename D>
 void set_allocator_for_deleter(D * deleter, Alloc * alloc)
 {
-  (void) alloc;
-  (void) deleter;
+  (void)alloc;
+  (void)deleter;
   throw std::runtime_error("Reached unexpected template specialization");
 }
 
-template<typename T, typename U>
+template <typename T, typename U>
 void set_allocator_for_deleter(std::default_delete<T> * deleter, std::allocator<U> * alloc)
 {
-  (void) deleter;
-  (void) alloc;
+  (void)deleter;
+  (void)alloc;
 }
 
-template<typename Alloc, typename T>
+template <typename Alloc, typename T>
 void set_allocator_for_deleter(AllocatorDeleter<T> * deleter, Alloc * alloc)
 {
   if (!deleter || !alloc) {
@@ -92,13 +80,12 @@ void set_allocator_for_deleter(AllocatorDeleter<T> * deleter, Alloc * alloc)
   deleter->set_allocator(alloc);
 }
 
-template<typename Alloc, typename T>
+template <typename Alloc, typename T>
 using Deleter = typename std::conditional<
-  std::is_same<typename std::allocator_traits<Alloc>::template rebind_alloc<T>,
-  typename std::allocator<void>::template rebind<T>::other>::value,
-  std::default_delete<T>,
-  AllocatorDeleter<Alloc>
-  >::type;
+  std::is_same<
+    typename std::allocator_traits<Alloc>::template rebind_alloc<T>,
+    typename std::allocator<void>::template rebind<T>::other>::value,
+  std::default_delete<T>, AllocatorDeleter<Alloc>>::type;
 }  // namespace allocator
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/any_service_callback.hpp

@@ -27,21 +27,16 @@
 namespace rclcpp
 {
 
-template<typename ServiceT>
+template <typename ServiceT>
 class AnyServiceCallback
 {
 private:
-  using SharedPtrCallback = std::function<
-    void (
-      const std::shared_ptr<typename ServiceT::Request>,
-      std::shared_ptr<typename ServiceT::Response>
-    )>;
-  using SharedPtrWithRequestHeaderCallback = std::function<
-    void (
-      const std::shared_ptr<rmw_request_id_t>,
-      const std::shared_ptr<typename ServiceT::Request>,
-      std::shared_ptr<typename ServiceT::Response>
-    )>;
+  using SharedPtrCallback = std::function<void(
+    const std::shared_ptr<typename ServiceT::Request>,
+    std::shared_ptr<typename ServiceT::Response>)>;
+  using SharedPtrWithRequestHeaderCallback = std::function<void(
+    const std::shared_ptr<rmw_request_id_t>, const std::shared_ptr<typename ServiceT::Request>,
+    std::shared_ptr<typename ServiceT::Response>)>;
 
   SharedPtrCallback shared_ptr_callback_;
   SharedPtrWithRequestHeaderCallback shared_ptr_with_request_header_callback_;
@@ -49,33 +44,22 @@ private:
 public:
   AnyServiceCallback()
   : shared_ptr_callback_(nullptr), shared_ptr_with_request_header_callback_(nullptr)
-  {}
+  {
+  }
 
   AnyServiceCallback(const AnyServiceCallback &) = default;
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, SharedPtrCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     shared_ptr_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrWithRequestHeaderCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, SharedPtrWithRequestHeaderCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     shared_ptr_with_request_header_callback_ = callback;

rclcpp/include/rclcpp/any_subscription_callback.hpp

@@ -30,7 +30,7 @@
 namespace rclcpp
 {
 
-template<typename MessageT, typename Alloc>
+template <typename MessageT, typename Alloc>
 class AnySubscriptionCallback
 {
   using MessageAllocTraits = allocator::AllocRebind<MessageT, Alloc>;
@@ -39,15 +39,15 @@ class AnySubscriptionCallback
   using ConstMessageSharedPtr = std::shared_ptr<const MessageT>;
   using MessageUniquePtr = std::unique_ptr<MessageT, MessageDeleter>;
 
-  using SharedPtrCallback = std::function<void (const std::shared_ptr<MessageT>)>;
+  using SharedPtrCallback = std::function<void(const std::shared_ptr<MessageT>)>;
   using SharedPtrWithInfoCallback =
-    std::function<void (const std::shared_ptr<MessageT>, const rmw_message_info_t &)>;
-  using ConstSharedPtrCallback = std::function<void (const std::shared_ptr<const MessageT>)>;
+    std::function<void(const std::shared_ptr<MessageT>, const rmw_message_info_t &)>;
+  using ConstSharedPtrCallback = std::function<void(const std::shared_ptr<const MessageT>)>;
   using ConstSharedPtrWithInfoCallback =
-    std::function<void (const std::shared_ptr<const MessageT>, const rmw_message_info_t &)>;
-  using UniquePtrCallback = std::function<void (MessageUniquePtr)>;
+    std::function<void(const std::shared_ptr<const MessageT>, const rmw_message_info_t &)>;
+  using UniquePtrCallback = std::function<void(MessageUniquePtr)>;
   using UniquePtrWithInfoCallback =
-    std::function<void (MessageUniquePtr, const rmw_message_info_t &)>;
+    std::function<void(MessageUniquePtr, const rmw_message_info_t &)>;
 
   SharedPtrCallback shared_ptr_callback_;
   SharedPtrWithInfoCallback shared_ptr_with_info_callback_;
@@ -58,9 +58,12 @@ class AnySubscriptionCallback
 
 public:
   explicit AnySubscriptionCallback(std::shared_ptr<Alloc> allocator)
-  : shared_ptr_callback_(nullptr), shared_ptr_with_info_callback_(nullptr),
-    const_shared_ptr_callback_(nullptr), const_shared_ptr_with_info_callback_(nullptr),
-    unique_ptr_callback_(nullptr), unique_ptr_with_info_callback_(nullptr)
+  : shared_ptr_callback_(nullptr),
+    shared_ptr_with_info_callback_(nullptr),
+    const_shared_ptr_callback_(nullptr),
+    const_shared_ptr_with_info_callback_(nullptr),
+    unique_ptr_callback_(nullptr),
+    unique_ptr_with_info_callback_(nullptr)
   {
     message_allocator_ = std::make_shared<MessageAlloc>(*allocator.get());
     allocator::set_allocator_for_deleter(&message_deleter_, message_allocator_.get());
@@ -68,92 +71,55 @@ public:
 
   AnySubscriptionCallback(const AnySubscriptionCallback &) = default;
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, SharedPtrCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     shared_ptr_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        SharedPtrWithInfoCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, SharedPtrWithInfoCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     shared_ptr_with_info_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        ConstSharedPtrCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, ConstSharedPtrCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     const_shared_ptr_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        ConstSharedPtrWithInfoCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, ConstSharedPtrWithInfoCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     const_shared_ptr_with_info_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        UniquePtrCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, UniquePtrCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     unique_ptr_callback_ = callback;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        UniquePtrWithInfoCallback
-      >::value
-    >::type * = nullptr
-  >
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, UniquePtrWithInfoCallback>::value>::type * = nullptr>
   void set(CallbackT callback)
   {
     unique_ptr_with_info_callback_ = callback;
   }
 
-  void dispatch(
-    std::shared_ptr<MessageT> message, const rmw_message_info_t & message_info)
+  void dispatch(std::shared_ptr<MessageT> message, const rmw_message_info_t & message_info)
   {
     if (shared_ptr_callback_) {
       shared_ptr_callback_(message);
@@ -185,20 +151,18 @@ public:
       const_shared_ptr_with_info_callback_(message, message_info);
     } else {
       if (
-        unique_ptr_callback_ || unique_ptr_with_info_callback_ ||
-        shared_ptr_callback_ || shared_ptr_with_info_callback_)
-      {
+        unique_ptr_callback_ || unique_ptr_with_info_callback_ || shared_ptr_callback_ ||
+        shared_ptr_with_info_callback_) {
         throw std::runtime_error(
-                "unexpected dispatch_intra_process const shared "
-                "message call with no const shared_ptr callback");
+          "unexpected dispatch_intra_process const shared "
+          "message call with no const shared_ptr callback");
       } else {
         throw std::runtime_error("unexpected message without any callback set");
       }
     }
   }
 
-  void dispatch_intra_process(
-    MessageUniquePtr message, const rmw_message_info_t & message_info)
+  void dispatch_intra_process(MessageUniquePtr message, const rmw_message_info_t & message_info)
   {
     if (shared_ptr_callback_) {
       typename std::shared_ptr<MessageT> shared_message = std::move(message);
@@ -212,8 +176,8 @@ public:
       unique_ptr_with_info_callback_(std::move(message), message_info);
     } else if (const_shared_ptr_callback_ || const_shared_ptr_with_info_callback_) {
       throw std::runtime_error(
-              "unexpected dispatch_intra_process unique message call"
-              " with const shared_ptr callback");
+        "unexpected dispatch_intra_process unique message call"
+        " with const shared_ptr callback");
     } else {
       throw std::runtime_error("unexpected message without any callback set");
     }

rclcpp/include/rclcpp/callback_group.hpp

@@ -43,11 +43,7 @@ class NodeWaitables;
 namespace callback_group
 {
 
-enum class CallbackGroupType
-{
-  MutuallyExclusive,
-  Reentrant
-};
+enum class CallbackGroupType { MutuallyExclusive, Reentrant };
 
 class CallbackGroup
 {
@@ -62,79 +58,65 @@ public:
   RCLCPP_PUBLIC
   explicit CallbackGroup(CallbackGroupType group_type);
 
-  template<typename Function>
-  rclcpp::SubscriptionBase::SharedPtr
-  find_subscription_ptrs_if(Function func) const
+  template <typename Function>
+  rclcpp::SubscriptionBase::SharedPtr find_subscription_ptrs_if(Function func) const
   {
     return _find_ptrs_if_impl<rclcpp::SubscriptionBase, Function>(func, subscription_ptrs_);
   }
 
-  template<typename Function>
-  rclcpp::TimerBase::SharedPtr
-  find_timer_ptrs_if(Function func) const
+  template <typename Function>
+  rclcpp::TimerBase::SharedPtr find_timer_ptrs_if(Function func) const
   {
     return _find_ptrs_if_impl<rclcpp::TimerBase, Function>(func, timer_ptrs_);
   }
 
-  template<typename Function>
-  rclcpp::ServiceBase::SharedPtr
-  find_service_ptrs_if(Function func) const
+  template <typename Function>
+  rclcpp::ServiceBase::SharedPtr find_service_ptrs_if(Function func) const
   {
     return _find_ptrs_if_impl<rclcpp::ServiceBase, Function>(func, service_ptrs_);
   }
 
-  template<typename Function>
-  rclcpp::ClientBase::SharedPtr
-  find_client_ptrs_if(Function func) const
+  template <typename Function>
+  rclcpp::ClientBase::SharedPtr find_client_ptrs_if(Function func) const
   {
     return _find_ptrs_if_impl<rclcpp::ClientBase, Function>(func, client_ptrs_);
   }
 
-  template<typename Function>
-  rclcpp::Waitable::SharedPtr
-  find_waitable_ptrs_if(Function func) const
+  template <typename Function>
+  rclcpp::Waitable::SharedPtr find_waitable_ptrs_if(Function func) const
   {
     return _find_ptrs_if_impl<rclcpp::Waitable, Function>(func, waitable_ptrs_);
   }
 
   RCLCPP_PUBLIC
-  std::atomic_bool &
-  can_be_taken_from();
+  std::atomic_bool & can_be_taken_from();
 
   RCLCPP_PUBLIC
-  const CallbackGroupType &
-  type() const;
+  const CallbackGroupType & type() const;
 
 protected:
   RCLCPP_DISABLE_COPY(CallbackGroup)
 
   RCLCPP_PUBLIC
-  void
-  add_publisher(const rclcpp::PublisherBase::SharedPtr publisher_ptr);
+  void add_publisher(const rclcpp::PublisherBase::SharedPtr publisher_ptr);
 
   RCLCPP_PUBLIC
-  void
-  add_subscription(const rclcpp::SubscriptionBase::SharedPtr subscription_ptr);
+  void add_subscription(const rclcpp::SubscriptionBase::SharedPtr subscription_ptr);
 
   RCLCPP_PUBLIC
-  void
-  add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr);
+  void add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr);
 
   RCLCPP_PUBLIC
-  void
-  add_service(const rclcpp::ServiceBase::SharedPtr service_ptr);
+  void add_service(const rclcpp::ServiceBase::SharedPtr service_ptr);
 
   RCLCPP_PUBLIC
-  void
-  add_client(const rclcpp::ClientBase::SharedPtr client_ptr);
+  void add_client(const rclcpp::ClientBase::SharedPtr client_ptr);
 
   RCLCPP_PUBLIC
-  void
-  add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr);
+  void add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr);
 
   RCLCPP_PUBLIC
-  void
-  remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept;
+  void remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept;
 
   CallbackGroupType type_;
   // Mutex to protect the subsequent vectors of pointers.
@@ -147,7 +129,7 @@ protected:
   std::atomic_bool can_be_taken_from_;
 
 private:
-  template<typename TypeT, typename Function>
+  template <typename TypeT, typename Function>
   typename TypeT::SharedPtr _find_ptrs_if_impl(
     Function func, const std::vector<typename TypeT::WeakPtr> & vect_ptrs) const
   {

rclcpp/include/rclcpp/client.hpp

@@ -28,12 +28,12 @@
 #include "rcl/wait.h"
 
 #include "rclcpp/exceptions.hpp"
+#include "rclcpp/expand_topic_or_service_name.hpp"
 #include "rclcpp/function_traits.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/node_interfaces/node_graph_interface.hpp"
 #include "rclcpp/type_support_decl.hpp"
 #include "rclcpp/utilities.hpp"
-#include "rclcpp/expand_topic_or_service_name.hpp"
 #include "rclcpp/visibility_control.hpp"
 
 #include "rcutils/logging_macros.h"
@@ -63,29 +63,23 @@ public:
   virtual ~ClientBase();
 
   RCLCPP_PUBLIC
-  const char *
-  get_service_name() const;
+  const char * get_service_name() const;
 
   RCLCPP_PUBLIC
-  std::shared_ptr<rcl_client_t>
-  get_client_handle();
+  std::shared_ptr<rcl_client_t> get_client_handle();
 
   RCLCPP_PUBLIC
-  std::shared_ptr<const rcl_client_t>
-  get_client_handle() const;
+  std::shared_ptr<const rcl_client_t> get_client_handle() const;
 
   RCLCPP_PUBLIC
-  bool
-  service_is_ready() const;
+  bool service_is_ready() const;
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
-  bool
-  wait_for_service(
+  template <typename RepT = int64_t, typename RatioT = std::milli>
+  bool wait_for_service(
     std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
   {
     return wait_for_service_nanoseconds(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
+      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout));
   }
 
   virtual std::shared_ptr<void> create_response() = 0;
@@ -97,16 +91,13 @@ protected:
   RCLCPP_DISABLE_COPY(ClientBase)
 
   RCLCPP_PUBLIC
-  bool
-  wait_for_service_nanoseconds(std::chrono::nanoseconds timeout);
+  bool wait_for_service_nanoseconds(std::chrono::nanoseconds timeout);
 
   RCLCPP_PUBLIC
-  rcl_node_t *
-  get_rcl_node_handle();
+  rcl_node_t * get_rcl_node_handle();
 
   RCLCPP_PUBLIC
-  const rcl_node_t *
-  get_rcl_node_handle() const;
+  const rcl_node_t * get_rcl_node_handle() const;
 
   rclcpp::node_interfaces::NodeGraphInterface::WeakPtr node_graph_;
   std::shared_ptr<rcl_node_t> node_handle_;
@@ -115,7 +106,7 @@ protected:
   std::shared_ptr<rcl_client_t> client_handle_;
 };
 
-template<typename ServiceT>
+template <typename ServiceT>
 class Client : public ClientBase
 {
 public:
@@ -131,73 +122,58 @@ public:
   using SharedFuture = std::shared_future<SharedResponse>;
   using SharedFutureWithRequest = std::shared_future<std::pair<SharedRequest, SharedResponse>>;
 
-  using CallbackType = std::function<void (SharedFuture)>;
-  using CallbackWithRequestType = std::function<void (SharedFutureWithRequest)>;
+  using CallbackType = std::function<void(SharedFuture)>;
+  using CallbackWithRequestType = std::function<void(SharedFutureWithRequest)>;
 
   RCLCPP_SMART_PTR_DEFINITIONS(Client)
 
   Client(
     rclcpp::node_interfaces::NodeBaseInterface * node_base,
     rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph,
-    const std::string & service_name,
-    rcl_client_options_t & client_options)
+    const std::string & service_name, rcl_client_options_t & client_options)
   : ClientBase(node_base, node_graph)
   {
     using rosidl_typesupport_cpp::get_service_type_support_handle;
-    auto service_type_support_handle =
-      get_service_type_support_handle<ServiceT>();
+    auto service_type_support_handle = get_service_type_support_handle<ServiceT>();
     rcl_ret_t ret = rcl_client_init(
-      this->get_client_handle().get(),
-      this->get_rcl_node_handle(),
-      service_type_support_handle,
-      service_name.c_str(),
-      &client_options);
+      this->get_client_handle().get(), this->get_rcl_node_handle(), service_type_support_handle,
+      service_name.c_str(), &client_options);
     if (ret != RCL_RET_OK) {
       if (ret == RCL_RET_SERVICE_NAME_INVALID) {
         auto rcl_node_handle = this->get_rcl_node_handle();
         // this will throw on any validation problem
         rcl_reset_error();
         expand_topic_or_service_name(
-          service_name,
-          rcl_node_get_name(rcl_node_handle),
-          rcl_node_get_namespace(rcl_node_handle),
+          service_name, rcl_node_get_name(rcl_node_handle), rcl_node_get_namespace(rcl_node_handle),
           true);
       }
       rclcpp::exceptions::throw_from_rcl_error(ret, "could not create client");
     }
   }
 
-  virtual ~Client()
-  {
-  }
+  virtual ~Client() {}
 
-  std::shared_ptr<void>
-  create_response() override
+  std::shared_ptr<void> create_response() override
   {
     return std::shared_ptr<void>(new typename ServiceT::Response());
   }
 
-  std::shared_ptr<rmw_request_id_t>
-  create_request_header() override
+  std::shared_ptr<rmw_request_id_t> create_request_header() override
   {
     // TODO(wjwwood): This should probably use rmw_request_id's allocator.
     //                (since it is a C type)
     return std::shared_ptr<rmw_request_id_t>(new rmw_request_id_t);
   }
 
-  void
-  handle_response(
-    std::shared_ptr<rmw_request_id_t> request_header,
-    std::shared_ptr<void> response) override
+  void handle_response(
+    std::shared_ptr<rmw_request_id_t> request_header, std::shared_ptr<void> response) override
   {
     std::unique_lock<std::mutex> lock(pending_requests_mutex_);
     auto typed_response = std::static_pointer_cast<typename ServiceT::Response>(response);
     int64_t sequence_number = request_header->sequence_number;
     // TODO(esteve) this should throw instead since it is not expected to happen in the first place
     if (this->pending_requests_.count(sequence_number) == 0) {
-      RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "Received invalid sequence number. Ignoring...");
+      RCUTILS_LOG_ERROR_NAMED("rclcpp", "Received invalid sequence number. Ignoring...");
       return;
     }
     auto tuple = this->pending_requests_[sequence_number];
@@ -212,23 +188,15 @@ public:
     callback(future);
   }
 
-  SharedFuture
-  async_send_request(SharedRequest request)
+  SharedFuture async_send_request(SharedRequest request)
   {
     return async_send_request(request, [](SharedFuture) {});
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        CallbackType
-      >::value
-    >::type * = nullptr
-  >
-  SharedFuture
-  async_send_request(SharedRequest request, CallbackT && cb)
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, CallbackType>::value>::type * = nullptr>
+  SharedFuture async_send_request(SharedRequest request, CallbackT && cb)
   {
     std::lock_guard<std::mutex> lock(pending_requests_mutex_);
     int64_t sequence_number;
@@ -244,26 +212,19 @@ public:
     return f;
   }
 
-  template<
-    typename CallbackT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<
-        CallbackT,
-        CallbackWithRequestType
-      >::value
-    >::type * = nullptr
-  >
-  SharedFutureWithRequest
-  async_send_request(SharedRequest request, CallbackT && cb)
+  template <
+    typename CallbackT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                          CallbackT, CallbackWithRequestType>::value>::type * = nullptr>
+  SharedFutureWithRequest async_send_request(SharedRequest request, CallbackT && cb)
   {
     SharedPromiseWithRequest promise = std::make_shared<PromiseWithRequest>();
     SharedFutureWithRequest future_with_request(promise->get_future());
 
     auto wrapping_cb = [future_with_request, promise, request, &cb](SharedFuture future) {
-        auto response = future.get();
-        promise->set_value(std::make_pair(request, response));
-        cb(future_with_request);
-      };
+      auto response = future.get();
+      promise->set_value(std::make_pair(request, response));
+      cb(future_with_request);
+    };
 
     async_send_request(request, wrapping_cb);
 

rclcpp/include/rclcpp/clock.hpp

@@ -33,12 +33,11 @@ class JumpHandler
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(JumpHandler)
 
-  using pre_callback_t = std::function<void ()>;
-  using post_callback_t = std::function<void (const rcl_time_jump_t &)>;
+  using pre_callback_t = std::function<void()>;
+  using post_callback_t = std::function<void(const rcl_time_jump_t &)>;
 
   JumpHandler(
-    pre_callback_t pre_callback,
-    post_callback_t post_callback,
+    pre_callback_t pre_callback, post_callback_t post_callback,
     const rcl_jump_threshold_t & threshold);
 
   pre_callback_t pre_callback;
@@ -71,8 +70,7 @@ public:
    * \throws anything rclcpp::exceptions::throw_from_rcl_error can throw.
    */
   RCLCPP_PUBLIC
-  Time
-  now();
+  Time now();
 
   /**
    * Returns the clock of the type `RCL_ROS_TIME` is active.
@@ -82,16 +80,13 @@ public:
    * the current clock does not have the clock_type `RCL_ROS_TIME`.
    */
   RCLCPP_PUBLIC
-  bool
-  ros_time_is_active();
+  bool ros_time_is_active();
 
   RCLCPP_PUBLIC
-  rcl_clock_t *
-  get_clock_handle() noexcept;
+  rcl_clock_t * get_clock_handle() noexcept;
 
   RCLCPP_PUBLIC
-  rcl_clock_type_t
-  get_clock_type() const noexcept;
+  rcl_clock_type_t get_clock_type() const noexcept;
 
   // Add a callback to invoke if the jump threshold is exceeded.
   /**
@@ -115,20 +110,15 @@ public:
    * JumpHandler.
    */
   RCLCPP_PUBLIC
-  JumpHandler::SharedPtr
-  create_jump_callback(
-    JumpHandler::pre_callback_t pre_callback,
-    JumpHandler::post_callback_t post_callback,
+  JumpHandler::SharedPtr create_jump_callback(
+    JumpHandler::pre_callback_t pre_callback, JumpHandler::post_callback_t post_callback,
     const rcl_jump_threshold_t & threshold);
 
 private:
   // Invoke time jump callback
   RCLCPP_PUBLIC
-  static void
-  on_time_jump(
-    const struct rcl_time_jump_t * time_jump,
-    bool before_jump,
-    void * user_data);
+  static void on_time_jump(
+    const struct rcl_time_jump_t * time_jump, bool before_jump, void * user_data);
 
   /// Internal storage backed by rcl
   rcl_clock_t rcl_clock_;

rclcpp/include/rclcpp/context.hpp

@@ -40,8 +40,7 @@ namespace rclcpp
 class ContextAlreadyInitialized : public std::runtime_error
 {
 public:
-  ContextAlreadyInitialized()
-  : std::runtime_error("context is already initialized") {}
+  ContextAlreadyInitialized() : std::runtime_error("context is already initialized") {}
 };
 
 /// Context which encapsulates shared state between nodes and other similar entities.
@@ -66,8 +65,7 @@ public:
   Context();
 
   RCLCPP_PUBLIC
-  virtual
-  ~Context();
+  virtual ~Context();
 
   /// Initialize the context, and the underlying elements like the rcl context.
   /**
@@ -102,11 +100,8 @@ public:
    * \throw ContextAlreadyInitialized if called if init is called more than once
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  init(
-    int argc,
-    char const * const argv[],
+  virtual void init(
+    int argc, char const * const argv[],
     const rclcpp::InitOptions & init_options = rclcpp::InitOptions());
 
   /// Return true if the context is valid, otherwise false.
@@ -120,26 +115,22 @@ public:
    * \return true if valid, otherwise false
    */
   RCLCPP_PUBLIC
-  bool
-  is_valid() const;
+  bool is_valid() const;
 
   /// Return the init options used during init.
   RCLCPP_PUBLIC
-  const rclcpp::InitOptions &
-  get_init_options() const;
+  const rclcpp::InitOptions & get_init_options() const;
 
   /// Return a copy of the init options used during init.
   RCLCPP_PUBLIC
-  rclcpp::InitOptions
-  get_init_options();
+  rclcpp::InitOptions get_init_options();
 
   /// Return the shutdown reason, or empty string if not shutdown.
   /**
    * This function is thread-safe.
    */
   RCLCPP_PUBLIC
-  std::string
-  shutdown_reason();
+  std::string shutdown_reason();
 
   /// Shutdown the context, making it uninitialized and therefore invalid for derived entities.
   /**
@@ -162,11 +153,9 @@ public:
    * \throw various exceptions derived from RCLErrorBase, if rcl_shutdown fails
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  shutdown(const std::string & reason);
+  virtual bool shutdown(const std::string & reason);
 
-  using OnShutdownCallback = std::function<void ()>;
+  using OnShutdownCallback = std::function<void()>;
 
   /// Add a on_shutdown callback to be called when shutdown is called for this context.
   /**
@@ -188,9 +177,7 @@ public:
    * \return the callback passed, for convenience when storing a passed lambda
    */
   RCLCPP_PUBLIC
-  virtual
-  OnShutdownCallback
-  on_shutdown(OnShutdownCallback callback);
+  virtual OnShutdownCallback on_shutdown(OnShutdownCallback callback);
 
   /// Return the shutdown callbacks as const.
   /**
@@ -198,8 +185,7 @@ public:
    * the list of "on shutdown" callbacks, i.e. on_shutdown().
    */
   RCLCPP_PUBLIC
-  const std::vector<OnShutdownCallback> &
-  get_on_shutdown_callbacks() const;
+  const std::vector<OnShutdownCallback> & get_on_shutdown_callbacks() const;
 
   /// Return the shutdown callbacks.
   /**
@@ -207,13 +193,11 @@ public:
    * the list of "on shutdown" callbacks, i.e. on_shutdown().
    */
   RCLCPP_PUBLIC
-  std::vector<OnShutdownCallback> &
-  get_on_shutdown_callbacks();
+  std::vector<OnShutdownCallback> & get_on_shutdown_callbacks();
 
   /// Return the internal rcl context.
   RCLCPP_PUBLIC
-  std::shared_ptr<rcl_context_t>
-  get_rcl_context();
+  std::shared_ptr<rcl_context_t> get_rcl_context();
 
   /// Sleep for a given period of time or until shutdown() is called.
   /**
@@ -228,14 +212,11 @@ public:
    * \return true if the condition variable did not timeout, i.e. you were interrupted.
    */
   RCLCPP_PUBLIC
-  bool
-  sleep_for(const std::chrono::nanoseconds & nanoseconds);
+  bool sleep_for(const std::chrono::nanoseconds & nanoseconds);
 
   /// Interrupt any blocking sleep_for calls, causing them to return immediately and return true.
   RCLCPP_PUBLIC
-  virtual
-  void
-  interrupt_all_sleep_for();
+  virtual void interrupt_all_sleep_for();
 
   /// Get a handle to the guard condition which is triggered when interrupted.
   /**
@@ -262,8 +243,7 @@ public:
    * \return Pointer to the guard condition.
    */
   RCLCPP_PUBLIC
-  rcl_guard_condition_t *
-  get_interrupt_guard_condition(rcl_wait_set_t * wait_set);
+  rcl_guard_condition_t * get_interrupt_guard_condition(rcl_wait_set_t * wait_set);
 
   /// Release the previously allocated guard condition which is triggered when interrupted.
   /**
@@ -281,24 +261,20 @@ public:
    *   resulting guard condition.
    */
   RCLCPP_PUBLIC
-  void
-  release_interrupt_guard_condition(rcl_wait_set_t * wait_set);
+  void release_interrupt_guard_condition(rcl_wait_set_t * wait_set);
 
   /// Nothrow version of release_interrupt_guard_condition(), logs to RCLCPP_ERROR instead.
   RCLCPP_PUBLIC
-  void
-  release_interrupt_guard_condition(rcl_wait_set_t * wait_set, const std::nothrow_t &) noexcept;
+  void release_interrupt_guard_condition(
+    rcl_wait_set_t * wait_set, const std::nothrow_t &) noexcept;
 
   /// Interrupt any blocking executors, or wait sets associated with this context.
   RCLCPP_PUBLIC
-  virtual
-  void
-  interrupt_all_wait_sets();
+  virtual void interrupt_all_wait_sets();
 
   /// Return a singleton instance for the SubContext type, constructing one if necessary.
-  template<typename SubContext, typename ... Args>
-  std::shared_ptr<SubContext>
-  get_sub_context(Args && ... args)
+  template <typename SubContext, typename... Args>
+  std::shared_ptr<SubContext> get_sub_context(Args &&... args)
   {
     std::lock_guard<std::recursive_mutex> lock(sub_contexts_mutex_);
 
@@ -308,10 +284,8 @@ public:
     if (it == sub_contexts_.end()) {
       // It doesn't exist yet, make it
       sub_context = std::shared_ptr<SubContext>(
-        new SubContext(std::forward<Args>(args) ...),
-        [](SubContext * sub_context_ptr) {
-          delete sub_context_ptr;
-        });
+        new SubContext(std::forward<Args>(args)...),
+        [](SubContext * sub_context_ptr) { delete sub_context_ptr; });
       sub_contexts_[type_i] = sub_context;
     } else {
       // It exists, get it out and cast it.
@@ -324,9 +298,7 @@ protected:
   // Called by constructor and destructor to clean up by finalizing the
   // shutdown rcl context and preparing for a new init cycle.
   RCLCPP_PUBLIC
-  virtual
-  void
-  clean_up();
+  virtual void clean_up();
 
 private:
   RCLCPP_DISABLE_COPY(Context)
@@ -362,8 +334,7 @@ private:
  * This function is thread-safe.
  */
 RCLCPP_PUBLIC
-std::vector<Context::SharedPtr>
-get_contexts();
+std::vector<Context::SharedPtr> get_contexts();
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/contexts/default_context.hpp

@@ -35,8 +35,7 @@ public:
 };
 
 RCLCPP_PUBLIC
-DefaultContext::SharedPtr
-get_global_default_context();
+DefaultContext::SharedPtr get_global_default_context();
 
 }  // namespace default_context
 }  // namespace contexts

rclcpp/include/rclcpp/create_client.hpp

@@ -27,24 +27,19 @@ namespace rclcpp
 
 /// Create a service client with a given type.
 /// \internal
-template<typename ServiceT>
-typename rclcpp::Client<ServiceT>::SharedPtr
-create_client(
+template <typename ServiceT>
+typename rclcpp::Client<ServiceT>::SharedPtr create_client(
   std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
   std::shared_ptr<node_interfaces::NodeGraphInterface> node_graph,
   std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
-  const std::string & service_name,
-  const rmw_qos_profile_t & qos_profile,
+  const std::string & service_name, const rmw_qos_profile_t & qos_profile,
   rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   rcl_client_options_t options = rcl_client_get_default_options();
   options.qos = qos_profile;
 
-  auto cli = rclcpp::Client<ServiceT>::make_shared(
-    node_base.get(),
-    node_graph,
-    service_name,
-    options);
+  auto cli =
+    rclcpp::Client<ServiceT>::make_shared(node_base.get(), node_graph, service_name, options);
 
   auto cli_base_ptr = std::dynamic_pointer_cast<rclcpp::ClientBase>(cli);
   node_services->add_client(cli_base_ptr, group);

rclcpp/include/rclcpp/create_publisher.hpp

@@ -29,30 +29,23 @@
 namespace rclcpp
 {
 
-template<
-  typename MessageT,
-  typename AllocatorT = std::allocator<void>,
+template <
+  typename MessageT, typename AllocatorT = std::allocator<void>,
   typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>>
 // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-[[deprecated("use alternative rclcpp::create_publisher() signatures")]]
-std::shared_ptr<PublisherT>
+[[deprecated("use alternative rclcpp::create_publisher() signatures")]] std::shared_ptr<PublisherT>
 create_publisher(
-  rclcpp::node_interfaces::NodeTopicsInterface * node_topics,
-  const std::string & topic_name,
-  const rmw_qos_profile_t & qos_profile,
-  const PublisherEventCallbacks & event_callbacks,
-  rclcpp::callback_group::CallbackGroup::SharedPtr group,
-  bool use_intra_process_comms,
-  std::shared_ptr<AllocatorT> allocator)
-{
+  rclcpp::node_interfaces::NodeTopicsInterface * node_topics, const std::string & topic_name,
+  const rmw_qos_profile_t & qos_profile, const PublisherEventCallbacks & event_callbacks,
+  rclcpp::callback_group::CallbackGroup::SharedPtr group, bool use_intra_process_comms,
+  std::shared_ptr<AllocatorT> allocator) {
   auto publisher_options = rcl_publisher_get_default_options();
   publisher_options.qos = qos_profile;
 
   auto pub = node_topics->create_publisher(
     topic_name,
     rclcpp::create_publisher_factory<MessageT, AllocatorT, PublisherT>(event_callbacks, allocator),
-    publisher_options,
-    use_intra_process_comms);
+    publisher_options, use_intra_process_comms);
 
   node_topics->add_publisher(pub, group);
 
@@ -64,19 +57,13 @@ create_publisher(
  * The NodeT type only needs to have a method called get_node_topics_interface()
  * which returns a shared_ptr to a NodeTopicsInterface.
  */
-template<
-  typename MessageT,
-  typename AllocatorT = std::allocator<void>,
-  typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>,
-  typename NodeT>
-std::shared_ptr<PublisherT>
-create_publisher(
-  NodeT & node,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::PublisherOptionsWithAllocator<AllocatorT>()
-))
+template <
+  typename MessageT, typename AllocatorT = std::allocator<void>,
+  typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>, typename NodeT>
+std::shared_ptr<PublisherT> create_publisher(
+  NodeT & node, const std::string & topic_name, const rclcpp::QoS & qos,
+  const rclcpp::PublisherOptionsWithAllocator<AllocatorT> & options =
+    (rclcpp::PublisherOptionsWithAllocator<AllocatorT>()))
 {
   using rclcpp::node_interfaces::get_node_topics_interface;
   auto node_topics = get_node_topics_interface(node);
@@ -106,12 +93,8 @@ create_publisher(
   auto pub = node_topics->create_publisher(
     topic_name,
     rclcpp::create_publisher_factory<MessageT, AllocatorT, PublisherT>(
-      options.event_callbacks,
-      allocator
-    ),
-    options.template to_rcl_publisher_options<MessageT>(qos),
-    use_intra_process
-  );
+      options.event_callbacks, allocator),
+    options.template to_rcl_publisher_options<MessageT>(qos), use_intra_process);
   node_topics->add_publisher(pub, options.callback_group);
   return std::dynamic_pointer_cast<PublisherT>(pub);
 }

rclcpp/include/rclcpp/create_service.hpp

@@ -29,14 +29,11 @@ namespace rclcpp
 
 /// Create a service with a given type.
 /// \internal
-template<typename ServiceT, typename CallbackT>
-typename rclcpp::Service<ServiceT>::SharedPtr
-create_service(
+template <typename ServiceT, typename CallbackT>
+typename rclcpp::Service<ServiceT>::SharedPtr create_service(
   std::shared_ptr<node_interfaces::NodeBaseInterface> node_base,
   std::shared_ptr<node_interfaces::NodeServicesInterface> node_services,
-  const std::string & service_name,
-  CallbackT && callback,
-  const rmw_qos_profile_t & qos_profile,
+  const std::string & service_name, CallbackT && callback, const rmw_qos_profile_t & qos_profile,
   rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   rclcpp::AnyServiceCallback<ServiceT> any_service_callback;
@@ -46,8 +43,7 @@ create_service(
   service_options.qos = qos_profile;
 
   auto serv = Service<ServiceT>::make_shared(
-    node_base->get_shared_rcl_node_handle(),
-    service_name, any_service_callback, service_options);
+    node_base->get_shared_rcl_node_handle(), service_name, any_service_callback, service_options);
   auto serv_base_ptr = std::dynamic_pointer_cast<ServiceBase>(serv);
   node_services->add_service(serv_base_ptr, group);
   return serv;

rclcpp/include/rclcpp/create_subscription.hpp

@@ -21,53 +21,40 @@
 
 #include "rclcpp/node_interfaces/get_node_topics_interface.hpp"
 #include "rclcpp/node_interfaces/node_topics_interface.hpp"
+#include "rclcpp/qos.hpp"
 #include "rclcpp/subscription_factory.hpp"
 #include "rclcpp/subscription_options.hpp"
-#include "rclcpp/qos.hpp"
 #include "rmw/qos_profiles.h"
 
 namespace rclcpp
 {
 
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename AllocatorT,
-  typename CallbackMessageT,
+template <
+  typename MessageT, typename CallbackT, typename AllocatorT, typename CallbackMessageT,
   typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>>
 // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
 [[deprecated("use alternative rclcpp::create_subscription() signatures")]]
-typename std::shared_ptr<SubscriptionT>
-create_subscription(
-  rclcpp::node_interfaces::NodeTopicsInterface * node_topics,
-  const std::string & topic_name,
-  CallbackT && callback,
-  const rmw_qos_profile_t & qos_profile,
-  const SubscriptionEventCallbacks & event_callbacks,
-  rclcpp::callback_group::CallbackGroup::SharedPtr group,
-  bool ignore_local_publications,
-  bool use_intra_process_comms,
-  typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
-    CallbackMessageT, AllocatorT>::SharedPtr
-  msg_mem_strat,
-  typename std::shared_ptr<AllocatorT> allocator)
+  typename std::shared_ptr<SubscriptionT>
+  create_subscription(
+    rclcpp::node_interfaces::NodeTopicsInterface * node_topics, const std::string & topic_name,
+    CallbackT && callback, const rmw_qos_profile_t & qos_profile,
+    const SubscriptionEventCallbacks & event_callbacks,
+    rclcpp::callback_group::CallbackGroup::SharedPtr group, bool ignore_local_publications,
+    bool use_intra_process_comms,
+    typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
+      CallbackMessageT, AllocatorT>::SharedPtr msg_mem_strat,
+    typename std::shared_ptr<AllocatorT> allocator)
 {
   auto subscription_options = rcl_subscription_get_default_options();
   subscription_options.qos = qos_profile;
   subscription_options.ignore_local_publications = ignore_local_publications;
 
-  auto factory = rclcpp::create_subscription_factory
-    <MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT>(
-    std::forward<CallbackT>(callback),
-    event_callbacks,
-    msg_mem_strat,
-    allocator);
+  auto factory = rclcpp::create_subscription_factory<
+    MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT>(
+    std::forward<CallbackT>(callback), event_callbacks, msg_mem_strat, allocator);
 
   auto sub = node_topics->create_subscription(
-    topic_name,
-    factory,
-    subscription_options,
-    use_intra_process_comms);
+    topic_name, factory, subscription_options, use_intra_process_comms);
   node_topics->add_subscription(sub, group);
   return std::dynamic_pointer_cast<SubscriptionT>(sub);
 }
@@ -78,26 +65,17 @@ create_subscription(
  * which returns a shared_ptr to a NodeTopicsInterface, or be a
  * NodeTopicsInterface pointer itself.
  */
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename AllocatorT = std::allocator<void>,
+template <
+  typename MessageT, typename CallbackT, typename AllocatorT = std::allocator<void>,
   typename CallbackMessageT =
-  typename rclcpp::subscription_traits::has_message_type<CallbackT>::type,
-  typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>,
-  typename NodeT>
-typename std::shared_ptr<SubscriptionT>
-create_subscription(
-  NodeT && node,
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  CallbackT && callback,
-  const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-    rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ),
+    typename rclcpp::subscription_traits::has_message_type<CallbackT>::type,
+  typename SubscriptionT = rclcpp::Subscription<CallbackMessageT, AllocatorT>, typename NodeT>
+typename std::shared_ptr<SubscriptionT> create_subscription(
+  NodeT && node, const std::string & topic_name, const rclcpp::QoS & qos, CallbackT && callback,
+  const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options =
+    (rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()),
   typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
-    CallbackMessageT, AllocatorT>::SharedPtr
-  msg_mem_strat = nullptr)
+    CallbackMessageT, AllocatorT>::SharedPtr msg_mem_strat = nullptr)
 {
   using rclcpp::node_interfaces::get_node_topics_interface;
   auto node_topics = get_node_topics_interface(std::forward<NodeT>(node));
@@ -111,8 +89,8 @@ create_subscription(
   if (!allocator) {
     allocator = std::make_shared<AllocatorT>();
   }
-  auto factory = rclcpp::create_subscription_factory
-    <MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT>(
+  auto factory = rclcpp::create_subscription_factory<
+    MessageT, CallbackT, AllocatorT, CallbackMessageT, SubscriptionT>(
     std::forward<CallbackT>(callback), options.event_callbacks, msg_mem_strat, allocator);
 
   bool use_intra_process;
@@ -133,9 +111,7 @@ create_subscription(
 
   // TODO(wjwwood): convert all of the interfaces to use QoS and SubscriptionOptionsBase
   auto sub = node_topics->create_subscription(
-    topic_name,
-    factory,
-    options.template to_rcl_subscription_options<MessageT>(qos),
+    topic_name, factory, options.template to_rcl_subscription_options<MessageT>(qos),
     use_intra_process);
   node_topics->add_subscription(sub, options.callback_group);
   return std::dynamic_pointer_cast<SubscriptionT>(sub);

rclcpp/include/rclcpp/create_timer.hpp

@@ -29,20 +29,15 @@ namespace rclcpp
 {
 /// Create a timer with a given clock
 /// \internal
-template<typename CallbackT>
-typename rclcpp::TimerBase::SharedPtr
-create_timer(
+template <typename CallbackT>
+typename rclcpp::TimerBase::SharedPtr create_timer(
   node_interfaces::NodeBaseInterface * node_base,
-  node_interfaces::NodeTimersInterface * node_timers,
-  rclcpp::Clock::SharedPtr clock,
-  rclcpp::Duration period,
-  CallbackT && callback,
+  node_interfaces::NodeTimersInterface * node_timers, rclcpp::Clock::SharedPtr clock,
+  rclcpp::Duration period, CallbackT && callback,
   rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr)
 {
   auto timer = rclcpp::GenericTimer<CallbackT>::make_shared(
-    clock,
-    period.to_chrono<std::chrono::nanoseconds>(),
-    std::forward<CallbackT>(callback),
+    clock, period.to_chrono<std::chrono::nanoseconds>(), std::forward<CallbackT>(callback),
     node_base->get_context());
 
   node_timers->add_timer(timer, group);
@@ -50,22 +45,15 @@ create_timer(
 }
 
 /// Create a timer with a given clock
-template<typename NodeT, typename CallbackT>
-typename rclcpp::TimerBase::SharedPtr
-create_timer(
-  NodeT node,
-  rclcpp::Clock::SharedPtr clock,
-  rclcpp::Duration period,
-  CallbackT && callback,
+template <typename NodeT, typename CallbackT>
+typename rclcpp::TimerBase::SharedPtr create_timer(
+  NodeT node, rclcpp::Clock::SharedPtr clock, rclcpp::Duration period, CallbackT && callback,
   rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr)
 {
   return create_timer(
     rclcpp::node_interfaces::get_node_base_interface(node),
-    rclcpp::node_interfaces::get_node_timers_interface(node),
-    clock,
-    period,
-    std::forward<CallbackT>(callback),
-    group);
+    rclcpp::node_interfaces::get_node_timers_interface(node), clock, period,
+    std::forward<CallbackT>(callback), group);
 }
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/duration.hpp

@@ -35,11 +35,12 @@ public:
 
   // This constructor matches any std::chrono value other than nanoseconds
   // intentionally not using explicit to create a conversion constructor
-  template<class Rep, class Period>
+  template <class Rep, class Period>
   // cppcheck-suppress noExplicitConstructor
   Duration(const std::chrono::duration<Rep, Period> & duration)  // NOLINT(runtime/explicit)
   : Duration(std::chrono::duration_cast<std::chrono::nanoseconds>(duration))
-  {}
+  {
+  }
 
   // cppcheck-suppress noExplicitConstructor
   Duration(const builtin_interfaces::msg::Duration & duration_msg);  // NOLINT(runtime/explicit)
@@ -53,62 +54,45 @@ public:
   operator builtin_interfaces::msg::Duration() const;
 
   // cppcheck-suppress operatorEq // this is a false positive from cppcheck
-  Duration &
-  operator=(const Duration & rhs);
+  Duration & operator=(const Duration & rhs);
 
-  Duration &
-  operator=(const builtin_interfaces::msg::Duration & Duration_msg);
+  Duration & operator=(const builtin_interfaces::msg::Duration & Duration_msg);
 
-  bool
-  operator==(const rclcpp::Duration & rhs) const;
+  bool operator==(const rclcpp::Duration & rhs) const;
 
-  bool
-  operator<(const rclcpp::Duration & rhs) const;
+  bool operator<(const rclcpp::Duration & rhs) const;
 
-  bool
-  operator<=(const rclcpp::Duration & rhs) const;
+  bool operator<=(const rclcpp::Duration & rhs) const;
 
-  bool
-  operator>=(const rclcpp::Duration & rhs) const;
+  bool operator>=(const rclcpp::Duration & rhs) const;
 
-  bool
-  operator>(const rclcpp::Duration & rhs) const;
+  bool operator>(const rclcpp::Duration & rhs) const;
 
-  Duration
-  operator+(const rclcpp::Duration & rhs) const;
+  Duration operator+(const rclcpp::Duration & rhs) const;
 
-  Duration
-  operator-(const rclcpp::Duration & rhs) const;
+  Duration operator-(const rclcpp::Duration & rhs) const;
 
-  static
-  Duration
-  max();
+  static Duration max();
 
-  Duration
-  operator*(double scale) const;
+  Duration operator*(double scale) const;
 
-  rcl_duration_value_t
-  nanoseconds() const;
+  rcl_duration_value_t nanoseconds() const;
 
   /// \return the duration in seconds as a floating point number.
   /// \warning Depending on sizeof(double) there could be significant precision loss.
   /// When an exact time is required use nanoseconds() instead.
-  double
-  seconds() const;
+  double seconds() const;
 
   // Create a duration object from a floating point number representing seconds
-  static Duration
-  from_seconds(double seconds);
+  static Duration from_seconds(double seconds);
 
-  template<class DurationT>
-  DurationT
-  to_chrono() const
+  template <class DurationT>
+  DurationT to_chrono() const
   {
     return std::chrono::duration_cast<DurationT>(std::chrono::nanoseconds(this->nanoseconds()));
   }
 
-  rmw_time_t
-  to_rmw_time() const;
+  rmw_time_t to_rmw_time() const;
 
 private:
   rcl_duration_t rcl_duration_;

rclcpp/include/rclcpp/event.hpp

@@ -33,16 +33,13 @@ public:
   Event();
 
   RCLCPP_PUBLIC
-  bool
-  set();
+  bool set();
 
   RCLCPP_PUBLIC
-  bool
-  check();
+  bool check();
 
   RCLCPP_PUBLIC
-  bool
-  check_and_clear();
+  bool check_and_clear();
 
 private:
   RCLCPP_DISABLE_COPY(Event)

rclcpp/include/rclcpp/exceptions.hpp

@@ -34,8 +34,7 @@ namespace exceptions
 class InvalidNodeError : public std::runtime_error
 {
 public:
-  InvalidNodeError()
-  : std::runtime_error("node is invalid") {}
+  InvalidNodeError() : std::runtime_error("node is invalid") {}
 };
 
 /// Thrown when a any kind of name (node, namespace, topic, etc.) is invalid.
@@ -43,20 +42,17 @@ class NameValidationError : public std::invalid_argument
 {
 public:
   NameValidationError(
-    const char * name_type_,
-    const char * name_,
-    const char * error_msg_,
-    size_t invalid_index_)
+    const char * name_type_, const char * name_, const char * error_msg_, size_t invalid_index_)
   : std::invalid_argument(format_error(name_type_, name_, error_msg_, invalid_index_)),
-    name_type(name_type_), name(name_), error_msg(error_msg_), invalid_index(invalid_index_)
-  {}
+    name_type(name_type_),
+    name(name_),
+    error_msg(error_msg_),
+    invalid_index(invalid_index_)
+  {
+  }
 
-  static std::string
-  format_error(
-    const char * name_type,
-    const char * name,
-    const char * error_msg,
-    size_t invalid_index);
+  static std::string format_error(
+    const char * name_type, const char * name, const char * error_msg, size_t invalid_index);
 
   const std::string name_type;
   const std::string name;
@@ -70,7 +66,8 @@ class InvalidNodeNameError : public NameValidationError
 public:
   InvalidNodeNameError(const char * node_name, const char * error_msg, size_t invalid_index)
   : NameValidationError("node name", node_name, error_msg, invalid_index)
-  {}
+  {
+  }
 };
 
 /// Thrown when a node namespace is invalid.
@@ -79,7 +76,8 @@ class InvalidNamespaceError : public NameValidationError
 public:
   InvalidNamespaceError(const char * namespace_, const char * error_msg, size_t invalid_index)
   : NameValidationError("namespace", namespace_, error_msg, invalid_index)
-  {}
+  {
+  }
 };
 
 /// Thrown when a topic name is invalid.
@@ -88,7 +86,8 @@ class InvalidTopicNameError : public NameValidationError
 public:
   InvalidTopicNameError(const char * namespace_, const char * error_msg, size_t invalid_index)
   : NameValidationError("topic name", namespace_, error_msg, invalid_index)
-  {}
+  {
+  }
 };
 
 /// Thrown when a service name is invalid.
@@ -97,7 +96,8 @@ class InvalidServiceNameError : public NameValidationError
 public:
   InvalidServiceNameError(const char * namespace_, const char * error_msg, size_t invalid_index)
   : NameValidationError("service name", namespace_, error_msg, invalid_index)
-  {}
+  {
+  }
 };
 
 /// Throw a C++ std::exception which was created based on an rcl error.
@@ -115,12 +115,9 @@ public:
  */
 /* *INDENT-OFF* */  // Uncrustify cannot yet understand [[noreturn]] properly
 RCLCPP_PUBLIC
-void
-throw_from_rcl_error [[noreturn]] (
-  rcl_ret_t ret,
-  const std::string & prefix = "",
-  const rcl_error_state_t * error_state = nullptr,
-  void (* reset_error)() = rcl_reset_error);
+void throw_from_rcl_error[[noreturn]](
+  rcl_ret_t ret, const std::string & prefix = "", const rcl_error_state_t * error_state = nullptr,
+  void (*reset_error)() = rcl_reset_error);
 /* *INDENT-ON* */
 
 class RCLErrorBase
@@ -163,9 +160,7 @@ class RCLInvalidArgument : public RCLErrorBase, public std::invalid_argument
 public:
   RCLCPP_PUBLIC
   RCLInvalidArgument(
-    rcl_ret_t ret,
-    const rcl_error_state_t * error_state,
-    const std::string & prefix);
+    rcl_ret_t ret, const rcl_error_state_t * error_state, const std::string & prefix);
   RCLCPP_PUBLIC
   RCLInvalidArgument(const RCLErrorBase & base_exc, const std::string & prefix);
 };
@@ -199,16 +194,14 @@ public:
 class InvalidEventError : public std::runtime_error
 {
 public:
-  InvalidEventError()
-  : std::runtime_error("event is invalid") {}
+  InvalidEventError() : std::runtime_error("event is invalid") {}
 };
 
 /// Thrown when an unregistered rclcpp::Event is encountered where a registered one was expected.
 class EventNotRegisteredError : public std::runtime_error
 {
 public:
-  EventNotRegisteredError()
-  : std::runtime_error("event already registered") {}
+  EventNotRegisteredError() : std::runtime_error("event already registered") {}
 };
 
 /// Thrown if passed parameters are inconsistent or invalid

rclcpp/include/rclcpp/executor.hpp

@@ -52,15 +52,13 @@ namespace executor
  * INTERRUPTED: The future is not complete, spinning was interrupted by Ctrl-C or another error.
  * TIMEOUT: Spinning timed out.
  */
-enum class FutureReturnCode {SUCCESS, INTERRUPTED, TIMEOUT};
+enum class FutureReturnCode { SUCCESS, INTERRUPTED, TIMEOUT };
 
 RCLCPP_PUBLIC
-std::ostream &
-operator<<(std::ostream & os, const FutureReturnCode & future_return_code);
+std::ostream & operator<<(std::ostream & os, const FutureReturnCode & future_return_code);
 
 RCLCPP_PUBLIC
-std::string
-to_string(const FutureReturnCode & future_return_code);
+std::string to_string(const FutureReturnCode & future_return_code);
 
 ///
 /**
@@ -72,17 +70,15 @@ struct ExecutorArgs
   : memory_strategy(memory_strategies::create_default_strategy()),
     context(rclcpp::contexts::default_context::get_global_default_context()),
     max_conditions(0)
-  {}
+  {
+  }
 
   memory_strategy::MemoryStrategy::SharedPtr memory_strategy;
   std::shared_ptr<rclcpp::Context> context;
   size_t max_conditions;
 };
 
-static inline ExecutorArgs create_default_executor_arguments()
-{
-  return ExecutorArgs();
-}
+static inline ExecutorArgs create_default_executor_arguments() { return ExecutorArgs(); }
 
 /// Coordinate the order and timing of available communication tasks.
 /**
@@ -110,8 +106,7 @@ public:
 
   /// Do work periodically as it becomes available to us. Blocking call, may block indefinitely.
   // It is up to the implementation of Executor to implement spin.
-  virtual void
-  spin() = 0;
+  virtual void spin() = 0;
 
   /// Add a node to the executor.
   /**
@@ -122,13 +117,12 @@ public:
    * node was added, it will wake up.
    */
   RCLCPP_PUBLIC
-  virtual void
-  add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);
+  virtual void add_node(
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);
 
   /// Convenience function which takes Node and forwards NodeBaseInterface.
   RCLCPP_PUBLIC
-  virtual void
-  add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);
+  virtual void add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);
 
   /// Remove a node from the executor.
   /**
@@ -138,13 +132,12 @@ public:
    * waiting for work in another thread, because otherwise the executor would never be notified.
    */
   RCLCPP_PUBLIC
-  virtual void
-  remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);
+  virtual void remove_node(
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify = true);
 
   /// Convenience function which takes Node and forwards NodeBaseInterface.
   RCLCPP_PUBLIC
-  virtual void
-  remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);
+  virtual void remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify = true);
 
   /// Add a node to executor, execute the next available unit of work, and remove the node.
   /**
@@ -153,29 +146,24 @@ public:
    * spin_node_once to block indefinitely (the default behavior). A timeout of 0 causes this
    * function to be non-blocking.
    */
-  template<typename RepT = int64_t, typename T = std::milli>
-  void
-  spin_node_once(
+  template <typename RepT = int64_t, typename T = std::milli>
+  void spin_node_once(
     rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
     std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))
   {
     return spin_node_once_nanoseconds(
-      node,
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
+      node, std::chrono::duration_cast<std::chrono::nanoseconds>(timeout));
   }
 
   /// Convenience function which takes Node and forwards NodeBaseInterface.
-  template<typename NodeT = rclcpp::Node, typename RepT = int64_t, typename T = std::milli>
-  void
-  spin_node_once(
+  template <typename NodeT = rclcpp::Node, typename RepT = int64_t, typename T = std::milli>
+  void spin_node_once(
     std::shared_ptr<NodeT> node,
     std::chrono::duration<RepT, T> timeout = std::chrono::duration<RepT, T>(-1))
   {
     return spin_node_once_nanoseconds(
       node->get_node_base_interface(),
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
+      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout));
   }
 
   /// Add a node, complete all immediately available work, and remove the node.
@@ -183,13 +171,11 @@ public:
    * \param[in] node Shared pointer to the node to add.
    */
   RCLCPP_PUBLIC
-  void
-  spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node);
+  void spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node);
 
   /// Convenience function which takes Node and forwards NodeBaseInterface.
   RCLCPP_PUBLIC
-  void
-  spin_node_some(std::shared_ptr<rclcpp::Node> node);
+  void spin_node_some(std::shared_ptr<rclcpp::Node> node);
 
   /// Complete all available queued work without blocking.
   /**
@@ -203,12 +189,10 @@ public:
    * been exceeded.
    */
   RCLCPP_PUBLIC
-  virtual void
-  spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0));
+  virtual void spin_some(std::chrono::nanoseconds max_duration = std::chrono::nanoseconds(0));
 
   RCLCPP_PUBLIC
-  virtual void
-  spin_once(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
+  virtual void spin_once(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
 
   /// Spin (blocking) until the future is complete, it times out waiting, or rclcpp is interrupted.
   /**
@@ -220,9 +204,8 @@ public:
    *   code.
    * \return The return code, one of `SUCCESS`, `INTERRUPTED`, or `TIMEOUT`.
    */
-  template<typename ResponseT, typename TimeRepT = int64_t, typename TimeT = std::milli>
-  FutureReturnCode
-  spin_until_future_complete(
+  template <typename ResponseT, typename TimeRepT = int64_t, typename TimeT = std::milli>
+  FutureReturnCode spin_until_future_complete(
     std::shared_future<ResponseT> & future,
     std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
   {
@@ -237,8 +220,8 @@ public:
     }
 
     auto end_time = std::chrono::steady_clock::now();
-    std::chrono::nanoseconds timeout_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
-      timeout);
+    std::chrono::nanoseconds timeout_ns =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout);
     if (timeout_ns > std::chrono::nanoseconds::zero()) {
       end_time += timeout_ns;
     }
@@ -272,8 +255,7 @@ public:
   /// Cancel any running spin* function, causing it to return.
   /* This function can be called asynchonously from any thread. */
   RCLCPP_PUBLIC
-  void
-  cancel();
+  void cancel();
 
   /// Support dynamic switching of the memory strategy.
   /**
@@ -282,69 +264,54 @@ public:
    * \param[in] memory_strategy Shared pointer to the memory strategy to set.
    */
   RCLCPP_PUBLIC
-  void
-  set_memory_strategy(memory_strategy::MemoryStrategy::SharedPtr memory_strategy);
+  void set_memory_strategy(memory_strategy::MemoryStrategy::SharedPtr memory_strategy);
 
 protected:
   RCLCPP_PUBLIC
-  void
-  spin_node_once_nanoseconds(
-    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
-    std::chrono::nanoseconds timeout);
+  void spin_node_once_nanoseconds(
+    rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node, std::chrono::nanoseconds timeout);
 
   /// Find the next available executable and do the work associated with it.
   /** \param[in] any_exec Union structure that can hold any executable type (timer, subscription,
    * service, client).
    */
   RCLCPP_PUBLIC
-  void
-  execute_any_executable(AnyExecutable & any_exec);
+  void execute_any_executable(AnyExecutable & any_exec);
 
   RCLCPP_PUBLIC
-  static void
-  execute_subscription(
-    rclcpp::SubscriptionBase::SharedPtr subscription);
+  static void execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription);
 
   RCLCPP_PUBLIC
-  static void
-  execute_intra_process_subscription(
-    rclcpp::SubscriptionBase::SharedPtr subscription);
+  static void execute_intra_process_subscription(rclcpp::SubscriptionBase::SharedPtr subscription);
 
   RCLCPP_PUBLIC
-  static void
-  execute_timer(rclcpp::TimerBase::SharedPtr timer);
+  static void execute_timer(rclcpp::TimerBase::SharedPtr timer);
 
   RCLCPP_PUBLIC
-  static void
-  execute_service(rclcpp::ServiceBase::SharedPtr service);
+  static void execute_service(rclcpp::ServiceBase::SharedPtr service);
 
   RCLCPP_PUBLIC
-  static void
-  execute_client(rclcpp::ClientBase::SharedPtr client);
+  static void execute_client(rclcpp::ClientBase::SharedPtr client);
 
   RCLCPP_PUBLIC
-  void
-  wait_for_work(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
+  void wait_for_work(std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
 
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
-  get_node_by_group(rclcpp::callback_group::CallbackGroup::SharedPtr group);
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr get_node_by_group(
+    rclcpp::callback_group::CallbackGroup::SharedPtr group);
 
   RCLCPP_PUBLIC
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_group_by_timer(rclcpp::TimerBase::SharedPtr timer);
+  rclcpp::callback_group::CallbackGroup::SharedPtr get_group_by_timer(
+    rclcpp::TimerBase::SharedPtr timer);
 
   RCLCPP_PUBLIC
-  void
-  get_next_timer(AnyExecutable & any_exec);
+  void get_next_timer(AnyExecutable & any_exec);
 
   RCLCPP_PUBLIC
-  bool
-  get_next_ready_executable(AnyExecutable & any_executable);
+  bool get_next_ready_executable(AnyExecutable & any_executable);
 
   RCLCPP_PUBLIC
-  bool
-  get_next_executable(
+  bool get_next_executable(
     AnyExecutable & any_executable,
     std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
 

rclcpp/include/rclcpp/executors.hpp

@@ -30,22 +30,18 @@ namespace rclcpp
 /// Create a default single-threaded executor and execute any immediately available work.
 /** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
-void
-spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);
+void spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);
 
 RCLCPP_PUBLIC
-void
-spin_some(rclcpp::Node::SharedPtr node_ptr);
+void spin_some(rclcpp::Node::SharedPtr node_ptr);
 
 /// Create a default single-threaded executor and spin the specified node.
 /** \param[in] node_ptr Shared pointer to the node to spin. */
 RCLCPP_PUBLIC
-void
-spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);
+void spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr);
 
 RCLCPP_PUBLIC
-void
-spin(rclcpp::Node::SharedPtr node_ptr);
+void spin(rclcpp::Node::SharedPtr node_ptr);
 
 namespace executors
 {
@@ -65,9 +61,8 @@ using rclcpp::executors::SingleThreadedExecutor;
  *   If the time spent inside the blocking loop exceeds this timeout, return a `TIMEOUT` return code.
  * \return The return code, one of `SUCCESS`, `INTERRUPTED`, or `TIMEOUT`.
  */
-template<typename ResponseT, typename TimeRepT = int64_t, typename TimeT = std::milli>
-rclcpp::executor::FutureReturnCode
-spin_node_until_future_complete(
+template <typename ResponseT, typename TimeRepT = int64_t, typename TimeT = std::milli>
+rclcpp::executor::FutureReturnCode spin_node_until_future_complete(
   rclcpp::executor::Executor & executor,
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   std::shared_future<ResponseT> & future,
@@ -81,27 +76,22 @@ spin_node_until_future_complete(
   return retcode;
 }
 
-template<typename NodeT = rclcpp::Node, typename ResponseT, typename TimeRepT = int64_t,
+template <
+  typename NodeT = rclcpp::Node, typename ResponseT, typename TimeRepT = int64_t,
   typename TimeT = std::milli>
-rclcpp::executor::FutureReturnCode
-spin_node_until_future_complete(
-  rclcpp::executor::Executor & executor,
-  std::shared_ptr<NodeT> node_ptr,
+rclcpp::executor::FutureReturnCode spin_node_until_future_complete(
+  rclcpp::executor::Executor & executor, std::shared_ptr<NodeT> node_ptr,
   std::shared_future<ResponseT> & future,
   std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
   return rclcpp::executors::spin_node_until_future_complete(
-    executor,
-    node_ptr->get_node_base_interface(),
-    future,
-    timeout);
+    executor, node_ptr->get_node_base_interface(), future, timeout);
 }
 
 }  // namespace executors
 
-template<typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
-rclcpp::executor::FutureReturnCode
-spin_until_future_complete(
+template <typename FutureT, typename TimeRepT = int64_t, typename TimeT = std::milli>
+rclcpp::executor::FutureReturnCode spin_until_future_complete(
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr,
   std::shared_future<FutureT> & future,
   std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
@@ -110,12 +100,11 @@ spin_until_future_complete(
   return executors::spin_node_until_future_complete<FutureT>(executor, node_ptr, future, timeout);
 }
 
-template<typename NodeT = rclcpp::Node, typename FutureT, typename TimeRepT = int64_t,
+template <
+  typename NodeT = rclcpp::Node, typename FutureT, typename TimeRepT = int64_t,
   typename TimeT = std::milli>
-rclcpp::executor::FutureReturnCode
-spin_until_future_complete(
-  std::shared_ptr<NodeT> node_ptr,
-  std::shared_future<FutureT> & future,
+rclcpp::executor::FutureReturnCode spin_until_future_complete(
+  std::shared_ptr<NodeT> node_ptr, std::shared_future<FutureT> & future,
   std::chrono::duration<TimeRepT, TimeT> timeout = std::chrono::duration<TimeRepT, TimeT>(-1))
 {
   return rclcpp::spin_until_future_complete(node_ptr->get_node_base_interface(), future, timeout);

rclcpp/include/rclcpp/executors/multi_threaded_executor.hpp

@@ -52,8 +52,7 @@ public:
    */
   RCLCPP_PUBLIC
   MultiThreadedExecutor(
-    const executor::ExecutorArgs & args = executor::ExecutorArgs(),
-    size_t number_of_threads = 0,
+    const executor::ExecutorArgs & args = executor::ExecutorArgs(), size_t number_of_threads = 0,
     bool yield_before_execute = false,
     std::chrono::nanoseconds timeout = std::chrono::nanoseconds(-1));
 
@@ -61,17 +60,14 @@ public:
   virtual ~MultiThreadedExecutor();
 
   RCLCPP_PUBLIC
-  void
-  spin();
+  void spin();
 
   RCLCPP_PUBLIC
-  size_t
-  get_number_of_threads();
+  size_t get_number_of_threads();
 
 protected:
   RCLCPP_PUBLIC
-  void
-  run(size_t this_thread_number);
+  void run(size_t this_thread_number);
 
 private:
   RCLCPP_DISABLE_COPY(MultiThreadedExecutor)

rclcpp/include/rclcpp/executors/single_threaded_executor.hpp

@@ -26,8 +26,8 @@
 #include "rclcpp/macros.hpp"
 #include "rclcpp/memory_strategies.hpp"
 #include "rclcpp/node.hpp"
-#include "rclcpp/utilities.hpp"
 #include "rclcpp/rate.hpp"
+#include "rclcpp/utilities.hpp"
 #include "rclcpp/visibility_control.hpp"
 
 namespace rclcpp
@@ -44,8 +44,7 @@ public:
 
   /// Default constructor. See the default constructor for Executor.
   RCLCPP_PUBLIC
-  SingleThreadedExecutor(
-    const executor::ExecutorArgs & args = executor::ExecutorArgs());
+  SingleThreadedExecutor(const executor::ExecutorArgs & args = executor::ExecutorArgs());
 
   /// Default destrcutor.
   RCLCPP_PUBLIC
@@ -55,8 +54,7 @@ public:
   // This function will block until work comes in, execute it, and keep blocking.
   // It will only be interrupt by a CTRL-C (managed by the global signal handler).
   RCLCPP_PUBLIC
-  void
-  spin();
+  void spin();
 
 private:
   RCLCPP_DISABLE_COPY(SingleThreadedExecutor)

rclcpp/include/rclcpp/expand_topic_or_service_name.hpp

@@ -51,11 +51,8 @@ namespace rclcpp
  * \throws RCLError if an unexpect error occurs
  */
 RCLCPP_PUBLIC
-std::string
-expand_topic_or_service_name(
-  const std::string & name,
-  const std::string & node_name,
-  const std::string & namespace_,
+std::string expand_topic_or_service_name(
+  const std::string & name, const std::string & node_name, const std::string & namespace_,
   bool is_service = false);
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/function_traits.hpp

@@ -35,134 +35,139 @@ namespace function_traits
  */
 
 // Remove the first item in a tuple
-template<typename T>
+template <typename T>
 struct tuple_tail;
 
-template<typename Head, typename ... Tail>
-struct tuple_tail<std::tuple<Head, Tail ...>>
+template <typename Head, typename... Tail>
+struct tuple_tail<std::tuple<Head, Tail...>>
 {
-  using type = std::tuple<Tail ...>;
+  using type = std::tuple<Tail...>;
 };
 
 // std::function
-template<typename FunctionT>
+template <typename FunctionT>
 struct function_traits
 {
   using arguments = typename tuple_tail<
-    typename function_traits<decltype( &FunctionT::operator())>::arguments>::type;
+    typename function_traits<decltype(&FunctionT::operator())>::arguments>::type;
 
   static constexpr std::size_t arity = std::tuple_size<arguments>::value;
 
-  template<std::size_t N>
+  template <std::size_t N>
   using argument_type = typename std::tuple_element<N, arguments>::type;
 
-  using return_type = typename function_traits<decltype( &FunctionT::operator())>::return_type;
+  using return_type = typename function_traits<decltype(&FunctionT::operator())>::return_type;
 };
 
 // Free functions
-template<typename ReturnTypeT, typename ... Args>
-struct function_traits<ReturnTypeT(Args ...)>
+template <typename ReturnTypeT, typename... Args>
+struct function_traits<ReturnTypeT(Args...)>
 {
-  using arguments = std::tuple<Args ...>;
+  using arguments = std::tuple<Args...>;
 
   static constexpr std::size_t arity = std::tuple_size<arguments>::value;
 
-  template<std::size_t N>
+  template <std::size_t N>
   using argument_type = typename std::tuple_element<N, arguments>::type;
 
   using return_type = ReturnTypeT;
 };
 
 // Function pointers
-template<typename ReturnTypeT, typename ... Args>
-struct function_traits<ReturnTypeT (*)(Args ...)>: function_traits<ReturnTypeT(Args ...)>
-{};
+template <typename ReturnTypeT, typename... Args>
+struct function_traits<ReturnTypeT (*)(Args...)> : function_traits<ReturnTypeT(Args...)>
+{
+};
 
 // std::bind for object methods
-template<typename ClassT, typename ReturnTypeT, typename ... Args, typename ... FArgs>
+template <typename ClassT, typename ReturnTypeT, typename... Args, typename... FArgs>
 #if defined _LIBCPP_VERSION  // libc++ (Clang)
-struct function_traits<std::__bind<ReturnTypeT (ClassT::*)(Args ...), FArgs ...>>
+struct function_traits<std::__bind<ReturnTypeT (ClassT::*)(Args...), FArgs...>>
 #elif defined _GLIBCXX_RELEASE  // glibc++ (GNU C++ >= 7.1)
-struct function_traits<std::_Bind<ReturnTypeT(ClassT::*(FArgs ...))(Args ...)>>
-#elif defined __GLIBCXX__  // glibc++ (GNU C++)
-struct function_traits<std::_Bind<std::_Mem_fn<ReturnTypeT (ClassT::*)(Args ...)>(FArgs ...)>>
-#elif defined _MSC_VER  // MS Visual Studio
+struct function_traits<std::_Bind<ReturnTypeT (ClassT::*(FArgs...))(Args...)>>
+#elif defined __GLIBCXX__       // glibc++ (GNU C++)
+struct function_traits<std::_Bind<std::_Mem_fn<ReturnTypeT (ClassT::*)(Args...)>(FArgs...)>>
+#elif defined _MSC_VER          // MS Visual Studio
 struct function_traits<
-  std::_Binder<std::_Unforced, ReturnTypeT(__cdecl ClassT::*)(Args ...), FArgs ...>
->
+  std::_Binder<std::_Unforced, ReturnTypeT (__cdecl ClassT::*)(Args...), FArgs...>>
 #else
 #error "Unsupported C++ compiler / standard library"
 #endif
-  : function_traits<ReturnTypeT(Args ...)>
-{};
+: function_traits<ReturnTypeT(Args...)>
+{
+};
 
 // std::bind for object const methods
-template<typename ClassT, typename ReturnTypeT, typename ... Args, typename ... FArgs>
+template <typename ClassT, typename ReturnTypeT, typename... Args, typename... FArgs>
 #if defined _LIBCPP_VERSION  // libc++ (Clang)
-struct function_traits<std::__bind<ReturnTypeT (ClassT::*)(Args ...) const, FArgs ...>>
+struct function_traits<std::__bind<ReturnTypeT (ClassT::*)(Args...) const, FArgs...>>
 #elif defined _GLIBCXX_RELEASE  // glibc++ (GNU C++ >= 7.1)
-struct function_traits<std::_Bind<ReturnTypeT(ClassT::*(FArgs ...))(Args ...) const>>
-#elif defined __GLIBCXX__  // glibc++ (GNU C++)
-struct function_traits<std::_Bind<std::_Mem_fn<ReturnTypeT (ClassT::*)(Args ...) const>(FArgs ...)>>
-#elif defined _MSC_VER  // MS Visual Studio
+struct function_traits<std::_Bind<ReturnTypeT (ClassT::*(FArgs...))(Args...) const>>
+#elif defined __GLIBCXX__       // glibc++ (GNU C++)
+struct function_traits<std::_Bind<std::_Mem_fn<ReturnTypeT (ClassT::*)(Args...) const>(FArgs...)>>
+#elif defined _MSC_VER          // MS Visual Studio
 struct function_traits<
-  std::_Binder<std::_Unforced, ReturnTypeT(__cdecl ClassT::*)(Args ...) const, FArgs ...>
->
+  std::_Binder<std::_Unforced, ReturnTypeT (__cdecl ClassT::*)(Args...) const, FArgs...>>
 #else
 #error "Unsupported C++ compiler / standard library"
 #endif
-  : function_traits<ReturnTypeT(Args ...)>
-{};
+: function_traits<ReturnTypeT(Args...)>
+{
+};
 
 // std::bind for free functions
-template<typename ReturnTypeT, typename ... Args, typename ... FArgs>
+template <typename ReturnTypeT, typename... Args, typename... FArgs>
 #if defined _LIBCPP_VERSION  // libc++ (Clang)
-struct function_traits<std::__bind<ReturnTypeT( &)(Args ...), FArgs ...>>
+struct function_traits<std::__bind<ReturnTypeT (&)(Args...), FArgs...>>
 #elif defined __GLIBCXX__  // glibc++ (GNU C++)
-struct function_traits<std::_Bind<ReturnTypeT(*(FArgs ...))(Args ...)>>
-#elif defined _MSC_VER  // MS Visual Studio
-struct function_traits<std::_Binder<std::_Unforced, ReturnTypeT(__cdecl &)(Args ...), FArgs ...>>
+struct function_traits<std::_Bind<ReturnTypeT (*(FArgs...))(Args...)>>
+#elif defined _MSC_VER     // MS Visual Studio
+struct function_traits<std::_Binder<std::_Unforced, ReturnTypeT(__cdecl &)(Args...), FArgs...>>
 #else
 #error "Unsupported C++ compiler / standard library"
 #endif
-  : function_traits<ReturnTypeT(Args ...)>
-{};
+: function_traits<ReturnTypeT(Args...)>
+{
+};
 
 // Lambdas
-template<typename ClassT, typename ReturnTypeT, typename ... Args>
-struct function_traits<ReturnTypeT (ClassT::*)(Args ...) const>
-  : function_traits<ReturnTypeT(ClassT &, Args ...)>
-{};
+template <typename ClassT, typename ReturnTypeT, typename... Args>
+struct function_traits<ReturnTypeT (ClassT::*)(Args...) const>
+: function_traits<ReturnTypeT(ClassT &, Args...)>
+{
+};
 
-template<typename FunctionT>
-struct function_traits<FunctionT &>: function_traits<FunctionT>
-{};
+template <typename FunctionT>
+struct function_traits<FunctionT &> : function_traits<FunctionT>
+{
+};
 
-template<typename FunctionT>
-struct function_traits<FunctionT &&>: function_traits<FunctionT>
-{};
+template <typename FunctionT>
+struct function_traits<FunctionT &&> : function_traits<FunctionT>
+{
+};
 
 /* NOTE(esteve):
  * VS2015 does not support expression SFINAE, so we're using this template to evaluate
  * the arity of a function.
  */
-template<std::size_t Arity, typename FunctorT>
-struct arity_comparator : std::integral_constant<
-    bool, (Arity == function_traits<FunctorT>::arity)> {};
+template <std::size_t Arity, typename FunctorT>
+struct arity_comparator : std::integral_constant<bool, (Arity == function_traits<FunctorT>::arity)>
+{
+};
 
-template<typename FunctorT, typename ... Args>
-struct check_arguments : std::is_same<
-    typename function_traits<FunctorT>::arguments,
-    std::tuple<Args ...>
->
-{};
+template <typename FunctorT, typename... Args>
+struct check_arguments
+: std::is_same<typename function_traits<FunctorT>::arguments, std::tuple<Args...>>
+{
+};
 
-template<typename FunctorAT, typename FunctorBT>
-struct same_arguments : std::is_same<
-    typename function_traits<FunctorAT>::arguments,
-    typename function_traits<FunctorBT>::arguments
->
-{};
+template <typename FunctorAT, typename FunctorBT>
+struct same_arguments
+: std::is_same<
+    typename function_traits<FunctorAT>::arguments, typename function_traits<FunctorBT>::arguments>
+{
+};
 
 }  // namespace function_traits
 

rclcpp/include/rclcpp/graph_listener.hpp

@@ -38,24 +38,21 @@ namespace graph_listener
 class GraphListenerShutdownError : public std::runtime_error
 {
 public:
-  GraphListenerShutdownError()
-  : std::runtime_error("GraphListener already shutdown") {}
+  GraphListenerShutdownError() : std::runtime_error("GraphListener already shutdown") {}
 };
 
 /// Thrown when a node has already been added to the GraphListener.
 class NodeAlreadyAddedError : public std::runtime_error
 {
 public:
-  NodeAlreadyAddedError()
-  : std::runtime_error("node already added") {}
+  NodeAlreadyAddedError() : std::runtime_error("node already added") {}
 };
 
 /// Thrown when the given node is not in the GraphListener.
 class NodeNotFoundError : public std::runtime_error
 {
 public:
-  NodeNotFoundError()
-  : std::runtime_error("node not found") {}
+  NodeNotFoundError() : std::runtime_error("node not found") {}
 };
 
 /// Notifies many nodes of graph changes by listening in a thread.
@@ -75,9 +72,7 @@ public:
    * \throws GraphListenerShutdownError if the GraphListener is shutdown
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  start_if_not_started();
+  virtual void start_if_not_started();
 
   /// Add a node to the graph listener's list of nodes.
   /**
@@ -87,9 +82,7 @@ public:
    * \throws std::system_error anything std::mutex::lock() throws
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
+  virtual void add_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
 
   /// Return true if the given node is in the graph listener's list of nodes.
   /**
@@ -98,9 +91,7 @@ public:
    * \throws std::system_error anything std::mutex::lock() throws
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  has_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
+  virtual bool has_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
 
   /// Remove a node from the graph listener's list of nodes.
   /**
@@ -110,9 +101,7 @@ public:
    * \throws std::system_error anything std::mutex::lock() throws
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  remove_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
+  virtual void remove_node(rclcpp::node_interfaces::NodeGraphInterface * node_graph);
 
   /// Stop the listening thread.
   /**
@@ -130,40 +119,29 @@ public:
    * \throws std::system_error anything std::mutex::lock() throws
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  shutdown();
+  virtual void shutdown();
 
   /// Nothrow version of shutdown(), logs to RCLCPP_ERROR instead.
   RCLCPP_PUBLIC
-  virtual
-  void
-  shutdown(const std::nothrow_t &) noexcept;
+  virtual void shutdown(const std::nothrow_t &) noexcept;
 
   /// Return true if shutdown() has been called, else false.
   RCLCPP_PUBLIC
-  virtual
-  bool
-  is_shutdown();
+  virtual bool is_shutdown();
 
 protected:
   /// Main function for the listening thread.
   RCLCPP_PUBLIC
-  virtual
-  void
-  run();
+  virtual void run();
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  run_loop();
+  virtual void run_loop();
 
 private:
   RCLCPP_DISABLE_COPY(GraphListener)
 
   /** \internal */
-  void
-  __shutdown(bool);
+  void __shutdown(bool);
 
   rclcpp::Context::SharedPtr parent_context_;
 

rclcpp/include/rclcpp/init_options.hpp

@@ -44,21 +44,17 @@ public:
 
   /// Assignment operator.
   RCLCPP_PUBLIC
-  InitOptions &
-  operator=(const InitOptions & other);
+  InitOptions & operator=(const InitOptions & other);
 
   RCLCPP_PUBLIC
-  virtual
-  ~InitOptions();
+  virtual ~InitOptions();
 
   /// Return the rcl init options.
   RCLCPP_PUBLIC
-  const rcl_init_options_t *
-  get_rcl_init_options() const;
+  const rcl_init_options_t * get_rcl_init_options() const;
 
 protected:
-  void
-  finalize_init_options();
+  void finalize_init_options();
 
 private:
   std::unique_ptr<rcl_init_options_t> init_options_;

rclcpp/include/rclcpp/intra_process_manager.hpp

@@ -24,14 +24,14 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <set>
 #include <unordered_map>
 #include <utility>
-#include <set>
 
 #include "rclcpp/allocator/allocator_deleter.hpp"
 #include "rclcpp/intra_process_manager_impl.hpp"
-#include "rclcpp/mapped_ring_buffer.hpp"
 #include "rclcpp/macros.hpp"
+#include "rclcpp/mapped_ring_buffer.hpp"
 #include "rclcpp/publisher_base.hpp"
 #include "rclcpp/subscription_base.hpp"
 #include "rclcpp/visibility_control.hpp"
@@ -149,8 +149,7 @@ public:
    * \return an unsigned 64-bit integer which is the subscription's unique id.
    */
   RCLCPP_PUBLIC
-  uint64_t
-  add_subscription(SubscriptionBase::SharedPtr subscription);
+  uint64_t add_subscription(SubscriptionBase::SharedPtr subscription);
 
   /// Unregister a subscription using the subscription's unique id.
   /**
@@ -159,8 +158,7 @@ public:
    * \param intra_process_subscription_id id of the subscription to remove.
    */
   RCLCPP_PUBLIC
-  void
-  remove_subscription(uint64_t intra_process_subscription_id);
+  void remove_subscription(uint64_t intra_process_subscription_id);
 
   /// Register a publisher with the manager, returns the publisher unique id.
   /**
@@ -186,10 +184,7 @@ public:
    * \return an unsigned 64-bit integer which is the publisher's unique id.
    */
   RCLCPP_PUBLIC
-  uint64_t
-  add_publisher(
-    rclcpp::PublisherBase::SharedPtr publisher,
-    size_t buffer_size = 0);
+  uint64_t add_publisher(rclcpp::PublisherBase::SharedPtr publisher, size_t buffer_size = 0);
 
   /// Unregister a publisher using the publisher's unique id.
   /**
@@ -198,8 +193,7 @@ public:
    * \param intra_process_publisher_id id of the publisher to remove.
    */
   RCLCPP_PUBLIC
-  void
-  remove_publisher(uint64_t intra_process_publisher_id);
+  void remove_publisher(uint64_t intra_process_publisher_id);
 
   /// Store a message in the manager, and return the message sequence number.
   /**
@@ -232,18 +226,15 @@ public:
    * \param message the message that is being stored.
    * \return the message sequence number.
    */
-  template<
-    typename MessageT, typename Alloc = std::allocator<void>>
-  uint64_t
-  store_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    std::shared_ptr<const MessageT> message)
+  template <typename MessageT, typename Alloc = std::allocator<void>>
+  uint64_t store_intra_process_message(
+    uint64_t intra_process_publisher_id, std::shared_ptr<const MessageT> message)
   {
     using MRBMessageAlloc = typename std::allocator_traits<Alloc>::template rebind_alloc<MessageT>;
     using TypedMRB = typename mapped_ring_buffer::MappedRingBuffer<MessageT, MRBMessageAlloc>;
     uint64_t message_seq = 0;
-    mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer = impl_->get_publisher_info_for_id(
-      intra_process_publisher_id, message_seq);
+    mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer =
+      impl_->get_publisher_info_for_id(intra_process_publisher_id, message_seq);
     typename TypedMRB::SharedPtr typed_buffer = std::static_pointer_cast<TypedMRB>(buffer);
     if (!typed_buffer) {
       throw std::runtime_error("Typecast failed due to incorrect message type");
@@ -260,19 +251,17 @@ public:
     return message_seq;
   }
 
-  template<
+  template <
     typename MessageT, typename Alloc = std::allocator<void>,
     typename Deleter = std::default_delete<MessageT>>
-  uint64_t
-  store_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    std::unique_ptr<MessageT, Deleter> message)
+  uint64_t store_intra_process_message(
+    uint64_t intra_process_publisher_id, std::unique_ptr<MessageT, Deleter> message)
   {
     using MRBMessageAlloc = typename std::allocator_traits<Alloc>::template rebind_alloc<MessageT>;
     using TypedMRB = typename mapped_ring_buffer::MappedRingBuffer<MessageT, MRBMessageAlloc>;
     uint64_t message_seq = 0;
-    mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer = impl_->get_publisher_info_for_id(
-      intra_process_publisher_id, message_seq);
+    mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer =
+      impl_->get_publisher_info_for_id(intra_process_publisher_id, message_seq);
     typename TypedMRB::SharedPtr typed_buffer = std::static_pointer_cast<TypedMRB>(buffer);
     if (!typed_buffer) {
       throw std::runtime_error("Typecast failed due to incorrect message type");
@@ -324,13 +313,11 @@ public:
    * \param requesting_subscriptions_intra_process_id the subscription's id.
    * \param message the message typed unique_ptr used to return the message.
    */
-  template<
+  template <
     typename MessageT, typename Alloc = std::allocator<void>,
     typename Deleter = std::default_delete<MessageT>>
-  void
-  take_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    uint64_t message_sequence_number,
+  void take_intra_process_message(
+    uint64_t intra_process_publisher_id, uint64_t message_sequence_number,
     uint64_t requesting_subscriptions_intra_process_id,
     std::unique_ptr<MessageT, Deleter> & message)
   {
@@ -341,11 +328,8 @@ public:
     size_t target_subs_size = 0;
     std::lock_guard<std::mutex> lock(take_mutex_);
     mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer = impl_->take_intra_process_message(
-      intra_process_publisher_id,
-      message_sequence_number,
-      requesting_subscriptions_intra_process_id,
-      target_subs_size
-    );
+      intra_process_publisher_id, message_sequence_number,
+      requesting_subscriptions_intra_process_id, target_subs_size);
     typename TypedMRB::SharedPtr typed_buffer = std::static_pointer_cast<TypedMRB>(buffer);
     if (!typed_buffer) {
       return;
@@ -360,14 +344,10 @@ public:
     }
   }
 
-  template<
-    typename MessageT, typename Alloc = std::allocator<void>>
-  void
-  take_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    uint64_t message_sequence_number,
-    uint64_t requesting_subscriptions_intra_process_id,
-    std::shared_ptr<const MessageT> & message)
+  template <typename MessageT, typename Alloc = std::allocator<void>>
+  void take_intra_process_message(
+    uint64_t intra_process_publisher_id, uint64_t message_sequence_number,
+    uint64_t requesting_subscriptions_intra_process_id, std::shared_ptr<const MessageT> & message)
   {
     using MRBMessageAlloc = typename std::allocator_traits<Alloc>::template rebind_alloc<MessageT>;
     using TypedMRB = mapped_ring_buffer::MappedRingBuffer<MessageT, MRBMessageAlloc>;
@@ -376,11 +356,8 @@ public:
     size_t target_subs_size = 0;
     std::lock_guard<std::mutex> lock(take_mutex_);
     mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer = impl_->take_intra_process_message(
-      intra_process_publisher_id,
-      message_sequence_number,
-      requesting_subscriptions_intra_process_id,
-      target_subs_size
-    );
+      intra_process_publisher_id, message_sequence_number,
+      requesting_subscriptions_intra_process_id, target_subs_size);
     typename TypedMRB::SharedPtr typed_buffer = std::static_pointer_cast<TypedMRB>(buffer);
     if (!typed_buffer) {
       return;
@@ -397,18 +374,15 @@ public:
 
   /// Return true if the given rmw_gid_t matches any stored Publishers.
   RCLCPP_PUBLIC
-  bool
-  matches_any_publishers(const rmw_gid_t * id) const;
+  bool matches_any_publishers(const rmw_gid_t * id) const;
 
   /// Return the number of intraprocess subscriptions to a topic, given the publisher id.
   RCLCPP_PUBLIC
-  size_t
-  get_subscription_count(uint64_t intra_process_publisher_id) const;
+  size_t get_subscription_count(uint64_t intra_process_publisher_id) const;
 
 private:
   RCLCPP_PUBLIC
-  static uint64_t
-  get_next_unique_id();
+  static uint64_t get_next_unique_id();
 
   IntraProcessManagerImplBase::SharedPtr impl_;
   std::mutex take_mutex_;

rclcpp/include/rclcpp/intra_process_manager_impl.hpp

@@ -51,62 +51,48 @@ public:
   IntraProcessManagerImplBase() = default;
   virtual ~IntraProcessManagerImplBase() = default;
 
-  virtual void
-  add_subscription(uint64_t id, SubscriptionBase::SharedPtr subscription) = 0;
+  virtual void add_subscription(uint64_t id, SubscriptionBase::SharedPtr subscription) = 0;
 
-  virtual void
-  remove_subscription(uint64_t intra_process_subscription_id) = 0;
+  virtual void remove_subscription(uint64_t intra_process_subscription_id) = 0;
 
   virtual void add_publisher(
-    uint64_t id,
-    PublisherBase::WeakPtr publisher,
-    mapped_ring_buffer::MappedRingBufferBase::SharedPtr mrb,
-    size_t size) = 0;
+    uint64_t id, PublisherBase::WeakPtr publisher,
+    mapped_ring_buffer::MappedRingBufferBase::SharedPtr mrb, size_t size) = 0;
 
-  virtual void
-  remove_publisher(uint64_t intra_process_publisher_id) = 0;
+  virtual void remove_publisher(uint64_t intra_process_publisher_id) = 0;
 
-  virtual mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  get_publisher_info_for_id(
-    uint64_t intra_process_publisher_id,
-    uint64_t & message_seq) = 0;
+  virtual mapped_ring_buffer::MappedRingBufferBase::SharedPtr get_publisher_info_for_id(
+    uint64_t intra_process_publisher_id, uint64_t & message_seq) = 0;
 
-  virtual void
-  store_intra_process_message(uint64_t intra_process_publisher_id, uint64_t message_seq) = 0;
+  virtual void store_intra_process_message(
+    uint64_t intra_process_publisher_id, uint64_t message_seq) = 0;
 
-  virtual mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  take_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    uint64_t message_sequence_number,
-    uint64_t requesting_subscriptions_intra_process_id,
-    size_t & size) = 0;
+  virtual mapped_ring_buffer::MappedRingBufferBase::SharedPtr take_intra_process_message(
+    uint64_t intra_process_publisher_id, uint64_t message_sequence_number,
+    uint64_t requesting_subscriptions_intra_process_id, size_t & size) = 0;
 
-  virtual bool
-  matches_any_publishers(const rmw_gid_t * id) const = 0;
+  virtual bool matches_any_publishers(const rmw_gid_t * id) const = 0;
 
-  virtual size_t
-  get_subscription_count(uint64_t intra_process_publisher_id) const = 0;
+  virtual size_t get_subscription_count(uint64_t intra_process_publisher_id) const = 0;
 
 private:
   RCLCPP_DISABLE_COPY(IntraProcessManagerImplBase)
 };
 
-template<typename Allocator = std::allocator<void>>
+template <typename Allocator = std::allocator<void>>
 class IntraProcessManagerImpl : public IntraProcessManagerImplBase
 {
 public:
   IntraProcessManagerImpl() = default;
   ~IntraProcessManagerImpl() = default;
 
-  void
-  add_subscription(uint64_t id, SubscriptionBase::SharedPtr subscription)
+  void add_subscription(uint64_t id, SubscriptionBase::SharedPtr subscription)
   {
     subscriptions_[id] = subscription;
     subscription_ids_by_topic_[fixed_size_string(subscription->get_topic_name())].insert(id);
   }
 
-  void
-  remove_subscription(uint64_t intra_process_subscription_id)
+  void remove_subscription(uint64_t intra_process_subscription_id)
   {
     subscriptions_.erase(intra_process_subscription_id);
     for (auto & pair : subscription_ids_by_topic_) {
@@ -122,10 +108,8 @@ public:
   }
 
   void add_publisher(
-    uint64_t id,
-    PublisherBase::WeakPtr publisher,
-    mapped_ring_buffer::MappedRingBufferBase::SharedPtr mrb,
-    size_t size)
+    uint64_t id, PublisherBase::WeakPtr publisher,
+    mapped_ring_buffer::MappedRingBufferBase::SharedPtr mrb, size_t size)
   {
     publishers_[id].publisher = publisher;
     // As long as the size of the ring buffer is less than the max sequence number, we're safe.
@@ -138,17 +122,14 @@ public:
     publishers_[id].target_subscriptions_by_message_sequence.reserve(size);
   }
 
-  void
-  remove_publisher(uint64_t intra_process_publisher_id)
+  void remove_publisher(uint64_t intra_process_publisher_id)
   {
     publishers_.erase(intra_process_publisher_id);
   }
 
   // return message_seq and mrb
-  mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  get_publisher_info_for_id(
-    uint64_t intra_process_publisher_id,
-    uint64_t & message_seq)
+  mapped_ring_buffer::MappedRingBufferBase::SharedPtr get_publisher_info_for_id(
+    uint64_t intra_process_publisher_id, uint64_t & message_seq)
   {
     std::lock_guard<std::mutex> lock(runtime_mutex_);
     auto it = publishers_.find(intra_process_publisher_id);
@@ -162,8 +143,7 @@ public:
     return info.buffer;
   }
 
-  void
-  store_intra_process_message(uint64_t intra_process_publisher_id, uint64_t message_seq)
+  void store_intra_process_message(uint64_t intra_process_publisher_id, uint64_t message_seq)
   {
     std::lock_guard<std::mutex> lock(runtime_mutex_);
     auto it = publishers_.find(intra_process_publisher_id);
@@ -192,18 +172,12 @@ public:
       std::inserter(
         info.target_subscriptions_by_message_sequence[message_seq],
         // This ends up only being a hint to std::set, could also be .begin().
-        info.target_subscriptions_by_message_sequence[message_seq].end()
-      )
-    );
+        info.target_subscriptions_by_message_sequence[message_seq].end()));
   }
 
-  mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  take_intra_process_message(
-    uint64_t intra_process_publisher_id,
-    uint64_t message_sequence_number,
-    uint64_t requesting_subscriptions_intra_process_id,
-    size_t & size
-  )
+  mapped_ring_buffer::MappedRingBufferBase::SharedPtr take_intra_process_message(
+    uint64_t intra_process_publisher_id, uint64_t message_sequence_number,
+    uint64_t requesting_subscriptions_intra_process_id, size_t & size)
   {
     std::lock_guard<std::mutex> lock(runtime_mutex_);
     PublisherInfo * info;
@@ -227,8 +201,7 @@ public:
     }
     {
       auto it = std::find(
-        target_subs->begin(), target_subs->end(),
-        requesting_subscriptions_intra_process_id);
+        target_subs->begin(), target_subs->end(), requesting_subscriptions_intra_process_id);
       if (it == target_subs->end()) {
         // This publisher id/message seq pair was not intended for this subscription.
         return 0;
@@ -239,8 +212,7 @@ public:
     return info->buffer;
   }
 
-  bool
-  matches_any_publishers(const rmw_gid_t * id) const
+  bool matches_any_publishers(const rmw_gid_t * id) const
   {
     for (auto & publisher_pair : publishers_) {
       auto publisher = publisher_pair.second.publisher.lock();
@@ -254,8 +226,7 @@ public:
     return false;
   }
 
-  size_t
-  get_subscription_count(uint64_t intra_process_publisher_id) const
+  size_t get_subscription_count(uint64_t intra_process_publisher_id) const
   {
     auto publisher_it = publishers_.find(intra_process_publisher_id);
     if (publisher_it == publishers_.end()) {
@@ -280,8 +251,7 @@ private:
 
   using FixedSizeString = std::array<char, RMW_TOPIC_MAX_NAME_LENGTH + 1>;
 
-  FixedSizeString
-  fixed_size_string(const char * str) const
+  FixedSizeString fixed_size_string(const char * str) const
   {
     FixedSizeString ret;
     size_t size = std::strlen(str) + 1;
@@ -293,28 +263,24 @@ private:
   }
   struct strcmp_wrapper
   {
-    bool
-    operator()(const FixedSizeString lhs, const FixedSizeString rhs) const
+    bool operator()(const FixedSizeString lhs, const FixedSizeString rhs) const
     {
       return std::strcmp(lhs.data(), rhs.data()) < 0;
     }
   };
 
-  template<typename T>
+  template <typename T>
   using RebindAlloc = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
 
   RebindAlloc<uint64_t> uint64_allocator;
 
   using AllocSet = std::set<uint64_t, std::less<uint64_t>, RebindAlloc<uint64_t>>;
   using SubscriptionMap = std::unordered_map<
-    uint64_t, SubscriptionBase::WeakPtr,
-    std::hash<uint64_t>, std::equal_to<uint64_t>,
+    uint64_t, SubscriptionBase::WeakPtr, std::hash<uint64_t>, std::equal_to<uint64_t>,
     RebindAlloc<std::pair<const uint64_t, SubscriptionBase::WeakPtr>>>;
 
   using IDTopicMap = std::map<
-    FixedSizeString,
-    AllocSet,
-    strcmp_wrapper,
+    FixedSizeString, AllocSet, strcmp_wrapper,
     RebindAlloc<std::pair<const FixedSizeString, AllocSet>>>;
 
   SubscriptionMap subscriptions_;
@@ -332,15 +298,13 @@ private:
     mapped_ring_buffer::MappedRingBufferBase::SharedPtr buffer;
 
     using TargetSubscriptionsMap = std::unordered_map<
-      uint64_t, AllocSet,
-      std::hash<uint64_t>, std::equal_to<uint64_t>,
+      uint64_t, AllocSet, std::hash<uint64_t>, std::equal_to<uint64_t>,
       RebindAlloc<std::pair<const uint64_t, AllocSet>>>;
     TargetSubscriptionsMap target_subscriptions_by_message_sequence;
   };
 
   using PublisherMap = std::unordered_map<
-    uint64_t, PublisherInfo,
-    std::hash<uint64_t>, std::equal_to<uint64_t>,
+    uint64_t, PublisherInfo, std::hash<uint64_t>, std::equal_to<uint64_t>,
     RebindAlloc<std::pair<const uint64_t, PublisherInfo>>>;
 
   PublisherMap publishers_;
@@ -349,8 +313,7 @@ private:
 };
 
 RCLCPP_PUBLIC
-IntraProcessManagerImplBase::SharedPtr
-create_default_impl();
+IntraProcessManagerImplBase::SharedPtr create_default_impl();
 
 }  // namespace intra_process_manager
 }  // namespace rclcpp

rclcpp/include/rclcpp/intra_process_setting.hpp

@@ -19,8 +19,7 @@ namespace rclcpp
 {
 
 /// Used as argument in create_publisher and create_subscriber.
-enum class IntraProcessSetting
-{
+enum class IntraProcessSetting {
   /// Explicitly enable intraprocess comm at publisher/subscription level.
   Enable,
   /// Explicitly disable intraprocess comm at publisher/subscription level.

rclcpp/include/rclcpp/logger.hpp

@@ -59,8 +59,7 @@ class Logger;
  * \return a dummy logger if logging is disabled.
  */
 RCLCPP_PUBLIC
-Logger
-get_logger(const std::string & name);
+Logger get_logger(const std::string & name);
 
 /// Return a named logger using an rcl_node_t.
 /**
@@ -71,8 +70,7 @@ get_logger(const std::string & name);
  * \return a logger based on the node name, or "rclcpp" if there's an error
  */
 RCLCPP_PUBLIC
-Logger
-get_node_logger(const rcl_node_t * node);
+Logger get_node_logger(const rcl_node_t * node);
 
 class Logger
 {
@@ -85,15 +83,13 @@ private:
    * This is used when logging is disabled: see `RCLCPP_LOGGING_ENABLED`.
    * This cannot be called directly, see `rclcpp::get_logger` instead.
    */
-  Logger()
-  : name_(nullptr) {}
+  Logger() : name_(nullptr) {}
 
   /// Constructor of a named logger.
   /**
    * This cannot be called directly, see `rclcpp::get_logger` instead.
    */
-  explicit Logger(const std::string & name)
-  : name_(new std::string(name)) {}
+  explicit Logger(const std::string & name) : name_(new std::string(name)) {}
 
   std::shared_ptr<const std::string> name_;
 
@@ -108,8 +104,7 @@ public:
    *   disabled).
    */
   RCLCPP_PUBLIC
-  const char *
-  get_name() const
+  const char * get_name() const
   {
     if (!name_) {
       return nullptr;
@@ -130,8 +125,7 @@ public:
    *   disabled).
    */
   RCLCPP_PUBLIC
-  Logger
-  get_child(const std::string & suffix)
+  Logger get_child(const std::string & suffix)
   {
     if (!name_) {
       return Logger();

rclcpp/include/rclcpp/macros.hpp

@@ -23,7 +23,7 @@
  *
  * Use in the private section of the class.
  */
-#define RCLCPP_DISABLE_COPY(...) \
+#define RCLCPP_DISABLE_COPY(...)             \
   __VA_ARGS__(const __VA_ARGS__ &) = delete; \
   __VA_ARGS__ & operator=(const __VA_ARGS__ &) = delete;
 
@@ -33,9 +33,9 @@
  * Use in the public section of the class.
  * Make sure to include `<memory>` in the header when using this.
  */
-#define RCLCPP_SMART_PTR_DEFINITIONS(...) \
+#define RCLCPP_SMART_PTR_DEFINITIONS(...)    \
   RCLCPP_SHARED_PTR_DEFINITIONS(__VA_ARGS__) \
-  RCLCPP_WEAK_PTR_DEFINITIONS(__VA_ARGS__) \
+  RCLCPP_WEAK_PTR_DEFINITIONS(__VA_ARGS__)   \
   RCLCPP_UNIQUE_PTR_DEFINITIONS(__VA_ARGS__)
 
 /**
@@ -49,8 +49,8 @@
  * Make sure to include `<memory>` in the header when using this.
  */
 #define RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(...) \
-  RCLCPP_SHARED_PTR_DEFINITIONS(__VA_ARGS__) \
-  RCLCPP_WEAK_PTR_DEFINITIONS(__VA_ARGS__) \
+  RCLCPP_SHARED_PTR_DEFINITIONS(__VA_ARGS__)           \
+  RCLCPP_WEAK_PTR_DEFINITIONS(__VA_ARGS__)             \
   __RCLCPP_UNIQUE_PTR_ALIAS(__VA_ARGS__)
 
 /**
@@ -64,28 +64,27 @@
  * Make sure to include `<memory>` in the header when using this.
  */
 #define RCLCPP_SMART_PTR_ALIASES_ONLY(...) \
-  __RCLCPP_SHARED_PTR_ALIAS(__VA_ARGS__) \
-  __RCLCPP_WEAK_PTR_ALIAS(__VA_ARGS__) \
+  __RCLCPP_SHARED_PTR_ALIAS(__VA_ARGS__)   \
+  __RCLCPP_WEAK_PTR_ALIAS(__VA_ARGS__)     \
   __RCLCPP_MAKE_SHARED_DEFINITION(__VA_ARGS__)
 
-#define __RCLCPP_SHARED_PTR_ALIAS(...) \
+#define __RCLCPP_SHARED_PTR_ALIAS(...)            \
   using SharedPtr = std::shared_ptr<__VA_ARGS__>; \
   using ConstSharedPtr = std::shared_ptr<const __VA_ARGS__>;
 
-#define __RCLCPP_MAKE_SHARED_DEFINITION(...) \
-  template<typename ... Args> \
-  static std::shared_ptr<__VA_ARGS__> \
-  make_shared(Args && ... args) \
-  { \
-    return std::make_shared<__VA_ARGS__>(std::forward<Args>(args) ...); \
+#define __RCLCPP_MAKE_SHARED_DEFINITION(...)                           \
+  template <typename... Args>                                          \
+  static std::shared_ptr<__VA_ARGS__> make_shared(Args &&... args)     \
+  {                                                                    \
+    return std::make_shared<__VA_ARGS__>(std::forward<Args>(args)...); \
   }
 
 /// Defines aliases and static functions for using the Class with shared_ptrs.
 #define RCLCPP_SHARED_PTR_DEFINITIONS(...) \
-  __RCLCPP_SHARED_PTR_ALIAS(__VA_ARGS__) \
+  __RCLCPP_SHARED_PTR_ALIAS(__VA_ARGS__)   \
   __RCLCPP_MAKE_SHARED_DEFINITION(__VA_ARGS__)
 
-#define __RCLCPP_WEAK_PTR_ALIAS(...) \
+#define __RCLCPP_WEAK_PTR_ALIAS(...)          \
   using WeakPtr = std::weak_ptr<__VA_ARGS__>; \
   using ConstWeakPtr = std::weak_ptr<const __VA_ARGS__>;
 
@@ -94,20 +93,19 @@
 
 #define __RCLCPP_UNIQUE_PTR_ALIAS(...) using UniquePtr = std::unique_ptr<__VA_ARGS__>;
 
-#define __RCLCPP_MAKE_UNIQUE_DEFINITION(...) \
-  template<typename ... Args> \
-  static std::unique_ptr<__VA_ARGS__> \
-  make_unique(Args && ... args) \
-  { \
-    return std::unique_ptr<__VA_ARGS__>(new __VA_ARGS__(std::forward<Args>(args) ...)); \
+#define __RCLCPP_MAKE_UNIQUE_DEFINITION(...)                                           \
+  template <typename... Args>                                                          \
+  static std::unique_ptr<__VA_ARGS__> make_unique(Args &&... args)                     \
+  {                                                                                    \
+    return std::unique_ptr<__VA_ARGS__>(new __VA_ARGS__(std::forward<Args>(args)...)); \
   }
 
 /// Defines aliases and static functions for using the Class with unique_ptrs.
 #define RCLCPP_UNIQUE_PTR_DEFINITIONS(...) \
-  __RCLCPP_UNIQUE_PTR_ALIAS(__VA_ARGS__) \
+  __RCLCPP_UNIQUE_PTR_ALIAS(__VA_ARGS__)   \
   __RCLCPP_MAKE_UNIQUE_DEFINITION(__VA_ARGS__)
 
 #define RCLCPP_STRING_JOIN(arg1, arg2) RCLCPP_DO_STRING_JOIN(arg1, arg2)
-#define RCLCPP_DO_STRING_JOIN(arg1, arg2) arg1 ## arg2
+#define RCLCPP_DO_STRING_JOIN(arg1, arg2) arg1##arg2
 
 #endif  // RCLCPP__MACROS_HPP_

rclcpp/include/rclcpp/mapped_ring_buffer.hpp

@@ -56,7 +56,7 @@ public:
  * there is no guarantee on which value is returned if a key is used multiple
  * times.
  */
-template<typename T, typename Alloc = std::allocator<void>>
+template <typename T, typename Alloc = std::allocator<void>>
 class MappedRingBuffer : public MappedRingBufferBase
 {
 public:
@@ -102,8 +102,7 @@ public:
    * \param key the key associated with the stored value
    * \param value if the key is found, the value is stored in this parameter
    */
-  void
-  get(uint64_t key, ElemUniquePtr & value)
+  void get(uint64_t key, ElemUniquePtr & value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     auto it = get_iterator_of_key(key);
@@ -140,8 +139,7 @@ public:
    * \param key the key associated with the stored value
    * \param value if the key is found, the value is stored in this parameter
    */
-  void
-  get(uint64_t key, ConstElemSharedPtr & value)
+  void get(uint64_t key, ConstElemSharedPtr & value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     auto it = get_iterator_of_key(key);
@@ -175,8 +173,7 @@ public:
    * \param key the key associated with the stored value
    * \param value if the key is found, the value is stored in this parameter
    */
-  void
-  pop(uint64_t key, ElemUniquePtr & value)
+  void pop(uint64_t key, ElemUniquePtr & value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     auto it = get_iterator_of_key(key);
@@ -212,8 +209,7 @@ public:
    * \param key the key associated with the stored value
    * \param value if the key is found, the value is stored in this parameter
    */
-  void
-  pop(uint64_t key, ConstElemSharedPtr & value)
+  void pop(uint64_t key, ConstElemSharedPtr & value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     auto it = get_iterator_of_key(key);
@@ -241,8 +237,7 @@ public:
    * \param key the key associated with the value to be stored
    * \param value the value to store, and optionally the value displaced
    */
-  bool
-  push_and_replace(uint64_t key, ConstElemSharedPtr value)
+  bool push_and_replace(uint64_t key, ConstElemSharedPtr value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     bool did_replace = elements_[head_].in_use;
@@ -260,8 +255,7 @@ public:
   /**
    * See `bool push_and_replace(uint64_t key, const ConstElemSharedPtr & value)`.
    */
-  bool
-  push_and_replace(uint64_t key, ElemUniquePtr value)
+  bool push_and_replace(uint64_t key, ElemUniquePtr value)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     bool did_replace = elements_[head_].in_use;
@@ -276,8 +270,7 @@ public:
   }
 
   /// Return true if the key is found in the ring buffer, otherwise false.
-  bool
-  has_key(uint64_t key)
+  bool has_key(uint64_t key)
   {
     std::lock_guard<std::mutex> lock(data_mutex_);
     return elements_.end() != get_iterator_of_key(key);
@@ -296,14 +289,11 @@ private:
 
   using VectorAlloc = typename std::allocator_traits<Alloc>::template rebind_alloc<Element>;
 
-  typename std::vector<Element, VectorAlloc>::iterator
-  get_iterator_of_key(uint64_t key)
+  typename std::vector<Element, VectorAlloc>::iterator get_iterator_of_key(uint64_t key)
   {
-    auto it = std::find_if(
-      elements_.begin(), elements_.end(),
-      [key](Element & e) -> bool {
-        return e.key == key && e.in_use;
-      });
+    auto it = std::find_if(elements_.begin(), elements_.end(), [key](Element & e) -> bool {
+      return e.key == key && e.in_use;
+    });
     return it;
   }
 

rclcpp/include/rclcpp/memory_strategies.hpp

@@ -24,8 +24,7 @@ namespace memory_strategies
 {
 
 RCLCPP_PUBLIC
-memory_strategy::MemoryStrategy::SharedPtr
-create_default_strategy();
+memory_strategy::MemoryStrategy::SharedPtr create_default_strategy();
 
 }  // namespace memory_strategies
 }  // namespace rclcpp

rclcpp/include/rclcpp/memory_strategy.hpp

@@ -64,68 +64,43 @@ public:
 
   virtual void remove_guard_condition(const rcl_guard_condition_t * guard_condition) = 0;
 
-  virtual void
-  get_next_subscription(
-    rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+  virtual void get_next_subscription(
+    rclcpp::executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes) = 0;
 
-  virtual void
-  get_next_service(
-    rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+  virtual void get_next_service(
+    rclcpp::executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes) = 0;
 
-  virtual void
-  get_next_client(
-    rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+  virtual void get_next_client(
+    rclcpp::executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes) = 0;
 
-  virtual void
-  get_next_waitable(
-    rclcpp::executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes) = 0;
+  virtual void get_next_waitable(
+    rclcpp::executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes) = 0;
 
-  virtual rcl_allocator_t
-  get_allocator() = 0;
+  virtual rcl_allocator_t get_allocator() = 0;
 
-  static rclcpp::SubscriptionBase::SharedPtr
-  get_subscription_by_handle(
-    std::shared_ptr<const rcl_subscription_t> subscriber_handle,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::SubscriptionBase::SharedPtr get_subscription_by_handle(
+    std::shared_ptr<const rcl_subscription_t> subscriber_handle, const WeakNodeList & weak_nodes);
 
-  static rclcpp::ServiceBase::SharedPtr
-  get_service_by_handle(
-    std::shared_ptr<const rcl_service_t> service_handle,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::ServiceBase::SharedPtr get_service_by_handle(
+    std::shared_ptr<const rcl_service_t> service_handle, const WeakNodeList & weak_nodes);
 
-  static rclcpp::ClientBase::SharedPtr
-  get_client_by_handle(
-    std::shared_ptr<const rcl_client_t> client_handle,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::ClientBase::SharedPtr get_client_by_handle(
+    std::shared_ptr<const rcl_client_t> client_handle, const WeakNodeList & weak_nodes);
 
-  static rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
-  get_node_by_group(
-    rclcpp::callback_group::CallbackGroup::SharedPtr group,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::node_interfaces::NodeBaseInterface::SharedPtr get_node_by_group(
+    rclcpp::callback_group::CallbackGroup::SharedPtr group, const WeakNodeList & weak_nodes);
 
-  static rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_group_by_subscription(
-    rclcpp::SubscriptionBase::SharedPtr subscription,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::callback_group::CallbackGroup::SharedPtr get_group_by_subscription(
+    rclcpp::SubscriptionBase::SharedPtr subscription, const WeakNodeList & weak_nodes);
 
-  static rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_group_by_service(
-    rclcpp::ServiceBase::SharedPtr service,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::callback_group::CallbackGroup::SharedPtr get_group_by_service(
+    rclcpp::ServiceBase::SharedPtr service, const WeakNodeList & weak_nodes);
 
-  static rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_group_by_client(
-    rclcpp::ClientBase::SharedPtr client,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::callback_group::CallbackGroup::SharedPtr get_group_by_client(
+    rclcpp::ClientBase::SharedPtr client, const WeakNodeList & weak_nodes);
 
-  static rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_group_by_waitable(
-    rclcpp::Waitable::SharedPtr waitable,
-    const WeakNodeList & weak_nodes);
+  static rclcpp::callback_group::CallbackGroup::SharedPtr get_group_by_waitable(
+    rclcpp::Waitable::SharedPtr waitable, const WeakNodeList & weak_nodes);
 };
 
 }  // namespace memory_strategy

rclcpp/include/rclcpp/message_memory_strategy.hpp

@@ -36,7 +36,7 @@ namespace message_memory_strategy
 
 /// Default allocation strategy for messages received by subscriptions.
 /** A message memory strategy must be templated on the type of the subscription it belongs to. */
-template<typename MessageT, typename Alloc = std::allocator<void>>
+template <typename MessageT, typename Alloc = std::allocator<void>>
 class MessageMemoryStrategy
 {
 public:
@@ -95,15 +95,13 @@ public:
       rclcpp::exceptions::throw_from_rcl_error(ret);
     }
 
-    auto serialized_msg = std::shared_ptr<rcl_serialized_message_t>(
-      msg,
-      [](rmw_serialized_message_t * msg) {
+    auto serialized_msg =
+      std::shared_ptr<rcl_serialized_message_t>(msg, [](rmw_serialized_message_t * msg) {
         auto ret = rmw_serialized_message_fini(msg);
         delete msg;
         if (ret != RCL_RET_OK) {
           RCUTILS_LOG_ERROR_NAMED(
-            "rclcpp",
-            "failed to destroy serialized message: %s", rcl_get_error_string().str);
+            "rclcpp", "failed to destroy serialized message: %s", rcl_get_error_string().str);
         }
       });
 
@@ -115,17 +113,11 @@ public:
     return borrow_serialized_message(default_buffer_capacity_);
   }
 
-  virtual void set_default_buffer_capacity(size_t capacity)
-  {
-    default_buffer_capacity_ = capacity;
-  }
+  virtual void set_default_buffer_capacity(size_t capacity) { default_buffer_capacity_ = capacity; }
 
   /// Release ownership of the message, which will deallocate it if it has no more owners.
   /** \param[in] msg Shared pointer to the message we are returning. */
-  virtual void return_message(std::shared_ptr<MessageT> & msg)
-  {
-    msg.reset();
-  }
+  virtual void return_message(std::shared_ptr<MessageT> & msg) { msg.reset(); }
 
   virtual void return_serialized_message(std::shared_ptr<rcl_serialized_message_t> & serialized_msg)
   {

rclcpp/include/rclcpp/node.hpp

@@ -80,9 +80,7 @@ public:
    * \param[in] options Additional options to control creation of the node.
    */
   RCLCPP_PUBLIC
-  explicit Node(
-    const std::string & node_name,
-    const NodeOptions & options = NodeOptions());
+  explicit Node(const std::string & node_name, const NodeOptions & options = NodeOptions());
 
   /// Create a new node with the specified name.
   /**
@@ -92,8 +90,7 @@ public:
    */
   RCLCPP_PUBLIC
   explicit Node(
-    const std::string & node_name,
-    const std::string & namespace_,
+    const std::string & node_name, const std::string & namespace_,
     const NodeOptions & options = NodeOptions());
 
   RCLCPP_PUBLIC
@@ -102,8 +99,7 @@ public:
   /// Get the name of the node.
   /** \return The name of the node. */
   RCLCPP_PUBLIC
-  const char *
-  get_name() const;
+  const char * get_name() const;
 
   /// Get the namespace of the node.
   /**
@@ -116,32 +112,28 @@ public:
    * \return The namespace of the node.
    */
   RCLCPP_PUBLIC
-  const char *
-  get_namespace() const;
+  const char * get_namespace() const;
 
   /// Get the fully-qualified name of the node.
   /**
    * The fully-qualified name includes the local namespace and name of the node.
    */
   RCLCPP_PUBLIC
-  const char *
-  get_fully_qualified_name() const;
+  const char * get_fully_qualified_name() const;
 
   /// Get the logger of the node.
   /** \return The logger of the node. */
   RCLCPP_PUBLIC
-  rclcpp::Logger
-  get_logger() const;
+  rclcpp::Logger get_logger() const;
 
   /// Create and return a callback group.
   RCLCPP_PUBLIC
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  create_callback_group(rclcpp::callback_group::CallbackGroupType group_type);
+  rclcpp::callback_group::CallbackGroup::SharedPtr create_callback_group(
+    rclcpp::callback_group::CallbackGroupType group_type);
 
   /// Return the list of callback groups in the node.
   RCLCPP_PUBLIC
-  const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> &
-  get_callback_groups() const;
+  const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> & get_callback_groups() const;
 
   /// Create and return a Publisher.
   /**
@@ -171,17 +163,13 @@ public:
    * \param[in] options Additional options for the created Publisher.
    * \return Shared pointer to the created publisher.
    */
-  template<
-    typename MessageT,
-    typename AllocatorT = std::allocator<void>,
+  template <
+    typename MessageT, typename AllocatorT = std::allocator<void>,
     typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>>
-  std::shared_ptr<PublisherT>
-  create_publisher(
-    const std::string & topic_name,
-    const rclcpp::QoS & qos,
+  std::shared_ptr<PublisherT> create_publisher(
+    const std::string & topic_name, const rclcpp::QoS & qos,
     const PublisherOptionsWithAllocator<AllocatorT> & options =
-    PublisherOptionsWithAllocator<AllocatorT>()
-  );
+      PublisherOptionsWithAllocator<AllocatorT>());
 
   /// Create and return a Publisher.
   /**
@@ -190,17 +178,16 @@ public:
    * \param[in] allocator Custom allocator.
    * \return Shared pointer to the created publisher.
    */
-  template<
-    typename MessageT,
-    typename AllocatorT = std::allocator<void>,
+  template <
+    typename MessageT, typename AllocatorT = std::allocator<void>,
     typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>>
   // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use create_publisher(const std::string &, const rclcpp::QoS &, ...) instead")]]
-  std::shared_ptr<PublisherT>
-  create_publisher(
-    const std::string & topic_name,
-    size_t qos_history_depth,
-    std::shared_ptr<AllocatorT> allocator);
+  [[deprecated(
+    "use create_publisher(const std::string &, const rclcpp::QoS &, ...) instead")]] std::
+    shared_ptr<PublisherT>
+    create_publisher(
+      const std::string & topic_name, size_t qos_history_depth,
+      std::shared_ptr<AllocatorT> allocator);
 
   /// Create and return a Publisher.
   /**
@@ -209,17 +196,17 @@ public:
    * \param[in] allocator Optional custom allocator.
    * \return Shared pointer to the created publisher.
    */
-  template<
-    typename MessageT,
-    typename AllocatorT = std::allocator<void>,
+  template <
+    typename MessageT, typename AllocatorT = std::allocator<void>,
     typename PublisherT = ::rclcpp::Publisher<MessageT, AllocatorT>>
   // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use create_publisher(const std::string &, const rclcpp::QoS &, ...) instead")]]
-  std::shared_ptr<PublisherT>
-  create_publisher(
-    const std::string & topic_name,
-    const rmw_qos_profile_t & qos_profile = rmw_qos_profile_default,
-    std::shared_ptr<AllocatorT> allocator = nullptr);
+  [[deprecated(
+    "use create_publisher(const std::string &, const rclcpp::QoS &, ...) instead")]] std::
+    shared_ptr<PublisherT>
+    create_publisher(
+      const std::string & topic_name,
+      const rmw_qos_profile_t & qos_profile = rmw_qos_profile_default,
+      std::shared_ptr<AllocatorT> allocator = nullptr);
 
   /// Create and return a Subscription.
   /**
@@ -234,23 +221,17 @@ public:
      Windows build breaks when static member function passed as default
      argument to msg_mem_strat, nullptr is a workaround.
    */
-  template<
-    typename MessageT,
-    typename CallbackT,
-    typename AllocatorT = std::allocator<void>,
+  template <
+    typename MessageT, typename CallbackT, typename AllocatorT = std::allocator<void>,
     typename SubscriptionT = rclcpp::Subscription<
       typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, AllocatorT>>
-  std::shared_ptr<SubscriptionT>
-  create_subscription(
-    const std::string & topic_name,
-    const rclcpp::QoS & qos,
-    CallbackT && callback,
+  std::shared_ptr<SubscriptionT> create_subscription(
+    const std::string & topic_name, const rclcpp::QoS & qos, CallbackT && callback,
     const SubscriptionOptionsWithAllocator<AllocatorT> & options =
-    SubscriptionOptionsWithAllocator<AllocatorT>(),
+      SubscriptionOptionsWithAllocator<AllocatorT>(),
     typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
-      typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, AllocatorT
-    >::SharedPtr
-    msg_mem_strat = nullptr);
+      typename rclcpp::subscription_traits::has_message_type<CallbackT>::type,
+      AllocatorT>::SharedPtr msg_mem_strat = nullptr);
 
   /// Create and return a Subscription.
   /**
@@ -267,26 +248,22 @@ public:
      Windows build breaks when static member function passed as default
      argument to msg_mem_strat, nullptr is a workaround.
    */
-  template<
-    typename MessageT,
-    typename CallbackT,
-    typename Alloc = std::allocator<void>,
+  template <
+    typename MessageT, typename CallbackT, typename Alloc = std::allocator<void>,
     typename SubscriptionT = rclcpp::Subscription<
       typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>>
   // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated(
-    "use create_subscription(const std::string &, const rclcpp::QoS &, CallbackT, ...) instead"
-  )]]
-  std::shared_ptr<SubscriptionT>
+  [
+    [deprecated("use create_subscription(const std::string &, const rclcpp::QoS &, CallbackT, ...) "
+                "instead")]] std::shared_ptr<SubscriptionT>
   create_subscription(
-    const std::string & topic_name,
-    CallbackT && callback,
+    const std::string & topic_name, CallbackT && callback,
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_default,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr,
     bool ignore_local_publications = false,
     typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
       typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>::SharedPtr
-    msg_mem_strat = nullptr,
+      msg_mem_strat = nullptr,
     std::shared_ptr<Alloc> allocator = nullptr);
 
   /// Create and return a Subscription.
@@ -304,26 +281,21 @@ public:
      Windows build breaks when static member function passed as default
      argument to msg_mem_strat, nullptr is a workaround.
    */
-  template<
-    typename MessageT,
-    typename CallbackT,
-    typename Alloc = std::allocator<void>,
+  template <
+    typename MessageT, typename CallbackT, typename Alloc = std::allocator<void>,
     typename SubscriptionT = rclcpp::Subscription<
       typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>>
   // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated(
-    "use create_subscription(const std::string &, const rclcpp::QoS &, CallbackT, ...) instead"
-  )]]
-  std::shared_ptr<SubscriptionT>
+  [
+    [deprecated("use create_subscription(const std::string &, const rclcpp::QoS &, CallbackT, ...) "
+                "instead")]] std::shared_ptr<SubscriptionT>
   create_subscription(
-    const std::string & topic_name,
-    CallbackT && callback,
-    size_t qos_history_depth,
+    const std::string & topic_name, CallbackT && callback, size_t qos_history_depth,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr,
     bool ignore_local_publications = false,
     typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
       typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>::SharedPtr
-    msg_mem_strat = nullptr,
+      msg_mem_strat = nullptr,
     std::shared_ptr<Alloc> allocator = nullptr);
 
   /// Create a timer.
@@ -332,27 +304,22 @@ public:
    * \param[in] callback User-defined callback function.
    * \param[in] group Callback group to execute this timer's callback in.
    */
-  template<typename DurationRepT = int64_t, typename DurationT = std::milli, typename CallbackT>
-  typename rclcpp::WallTimer<CallbackT>::SharedPtr
-  create_wall_timer(
-    std::chrono::duration<DurationRepT, DurationT> period,
-    CallbackT callback,
+  template <typename DurationRepT = int64_t, typename DurationT = std::milli, typename CallbackT>
+  typename rclcpp::WallTimer<CallbackT>::SharedPtr create_wall_timer(
+    std::chrono::duration<DurationRepT, DurationT> period, CallbackT callback,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
   /* Create and return a Client. */
-  template<typename ServiceT>
-  typename rclcpp::Client<ServiceT>::SharedPtr
-  create_client(
+  template <typename ServiceT>
+  typename rclcpp::Client<ServiceT>::SharedPtr create_client(
     const std::string & service_name,
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_services_default,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
   /* Create and return a Service. */
-  template<typename ServiceT, typename CallbackT>
-  typename rclcpp::Service<ServiceT>::SharedPtr
-  create_service(
-    const std::string & service_name,
-    CallbackT && callback,
+  template <typename ServiceT, typename CallbackT>
+  typename rclcpp::Service<ServiceT>::SharedPtr create_service(
+    const std::string & service_name, CallbackT && callback,
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_services_default,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
@@ -397,12 +364,11 @@ public:
    *   value fails to be set.
    */
   RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(
+  const rclcpp::ParameterValue & declare_parameter(
     const std::string & name,
     const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
+      rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
   /// Declare and initialize a parameter with a type.
@@ -426,13 +392,11 @@ public:
    *   - https://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/
    *   - https://www.youtube.com/watch?v=uQyT-5iWUow (cppnow 2018 presentation)
    */
-  template<typename ParameterT>
-  auto
-  declare_parameter(
-    const std::string & name,
-    const ParameterT & default_value,
+  template <typename ParameterT>
+  auto declare_parameter(
+    const std::string & name, const ParameterT & default_value,
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
+      rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
   /// Declare and initialize several parameters with the same namespace and type.
@@ -471,11 +435,9 @@ public:
    * \throws rclcpp::exceptions::InvalidParameterValueException if initial
    *   value fails to be set.
    */
-  template<typename ParameterT>
-  std::vector<ParameterT>
-  declare_parameters(
-    const std::string & namespace_,
-    const std::map<std::string, ParameterT> & parameters,
+  template <typename ParameterT>
+  std::vector<ParameterT> declare_parameters(
+    const std::string & namespace_, const std::map<std::string, ParameterT> & parameters,
     bool ignore_overrides = false);
 
   /// Declare and initialize several parameters with the same namespace and type.
@@ -485,14 +447,11 @@ public:
    *
    * See the simpler declare_parameters() on this class for more details.
    */
-  template<typename ParameterT>
-  std::vector<ParameterT>
-  declare_parameters(
+  template <typename ParameterT>
+  std::vector<ParameterT> declare_parameters(
     const std::string & namespace_,
-    const std::map<
-      std::string,
-      std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor>
-    > & parameters,
+    const std::map<std::string, std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor>> &
+      parameters,
     bool ignore_overrides = false);
 
   /// Undeclare a previously declared parameter.
@@ -507,8 +466,7 @@ public:
    *   was create as read_only (immutable).
    */
   RCLCPP_PUBLIC
-  void
-  undeclare_parameter(const std::string & name);
+  void undeclare_parameter(const std::string & name);
 
   /// Return true if a given parameter is declared.
   /**
@@ -516,8 +474,7 @@ public:
    * \return true if the parameter name has been declared, otherwise false.
    */
   RCLCPP_PUBLIC
-  bool
-  has_parameter(const std::string & name) const;
+  bool has_parameter(const std::string & name) const;
 
   /// Set a single parameter.
   /**
@@ -549,8 +506,7 @@ public:
    *   has not been declared and undeclared parameters are not allowed.
    */
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameter(const rclcpp::Parameter & parameter);
+  rcl_interfaces::msg::SetParametersResult set_parameter(const rclcpp::Parameter & parameter);
 
   /// Set one or more parameters, one at a time.
   /**
@@ -587,8 +543,8 @@ public:
    *   has not been declared and undeclared parameters are not allowed.
    */
   RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(const std::vector<rclcpp::Parameter> & parameters);
+  std::vector<rcl_interfaces::msg::SetParametersResult> set_parameters(
+    const std::vector<rclcpp::Parameter> & parameters);
 
   /// Set one or more parameters, all at once.
   /**
@@ -621,8 +577,8 @@ public:
    *   has not been declared and undeclared parameters are not allowed.
    */
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(const std::vector<rclcpp::Parameter> & parameters);
+  rcl_interfaces::msg::SetParametersResult set_parameters_atomically(
+    const std::vector<rclcpp::Parameter> & parameters);
 
   /// Set one parameter, unless that parameter has already been set.
   /**
@@ -633,11 +589,10 @@ public:
    * \param[in] parameters The vector of parameters to be set.
    * \return The result of each set action as a vector.
    */
-  template<typename ParameterT>
+  template <typename ParameterT>
   // cppcheck-suppress syntaxError // bug in cppcheck 1.82 for [[deprecated]] on templated function
-  [[deprecated("use declare_parameter() instead")]]
-  void
-  set_parameter_if_not_set(const std::string & name, const ParameterT & value);
+  [[deprecated("use declare_parameter() instead")]] void set_parameter_if_not_set(
+    const std::string & name, const ParameterT & value);
 
   /// Set a map of parameters with the same prefix.
   /**
@@ -649,12 +604,9 @@ public:
    * \param[in] name The prefix of the parameters to set.
    * \param[in] values The parameters to set in the given prefix.
    */
-  template<typename ParameterT>
-  [[deprecated("use declare_parameters() instead")]]
-  void
-  set_parameters_if_not_set(
-    const std::string & name,
-    const std::map<std::string, ParameterT> & values);
+  template <typename ParameterT>
+  [[deprecated("use declare_parameters() instead")]] void set_parameters_if_not_set(
+    const std::string & name, const std::map<std::string, ParameterT> & values);
 
   /// Return the parameter by the given name.
   /**
@@ -673,8 +625,7 @@ public:
    *   has not been declared and undeclared parameters are not allowed.
    */
   RCLCPP_PUBLIC
-  rclcpp::Parameter
-  get_parameter(const std::string & name) const;
+  rclcpp::Parameter get_parameter(const std::string & name) const;
 
   /// Get the value of a parameter by the given name, and return true if it was set.
   /**
@@ -692,8 +643,7 @@ public:
    * \return true if the parameter was previously declared, otherwise false.
    */
   RCLCPP_PUBLIC
-  bool
-  get_parameter(const std::string & name, rclcpp::Parameter & parameter) const;
+  bool get_parameter(const std::string & name, rclcpp::Parameter & parameter) const;
 
   /// Get the value of a parameter by the given name, and return true if it was set.
   /**
@@ -708,9 +658,8 @@ public:
    * \throws rclcpp::ParameterTypeException if the requested type does not
    *   match the value of the parameter which is stored.
    */
-  template<typename ParameterT>
-  bool
-  get_parameter(const std::string & name, ParameterT & parameter) const;
+  template <typename ParameterT>
+  bool get_parameter(const std::string & name, ParameterT & parameter) const;
 
   /// Get the parameter value, or the "alternative_value" if not set, and assign it to "parameter".
   /**
@@ -727,12 +676,9 @@ public:
    * \param[in] alternative_value Value to be stored in output if the parameter was not set.
    * \returns true if the parameter was set, false otherwise.
    */
-  template<typename ParameterT>
-  bool
-  get_parameter_or(
-    const std::string & name,
-    ParameterT & parameter,
-    const ParameterT & alternative_value) const;
+  template <typename ParameterT>
+  bool get_parameter_or(
+    const std::string & name, ParameterT & parameter, const ParameterT & alternative_value) const;
 
   /// Return the parameters by the given parameter names.
   /**
@@ -753,8 +699,7 @@ public:
    *   allowed.
    */
   RCLCPP_PUBLIC
-  std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & names) const;
+  std::vector<rclcpp::Parameter> get_parameters(const std::vector<std::string> & names) const;
 
   /// Get the parameter values for all parameters that have a given prefix.
   /**
@@ -793,11 +738,8 @@ public:
    * \throws rclcpp::ParameterTypeException if the requested type does not
    *   match the value of the parameter which is stored.
    */
-  template<typename ParameterT>
-  bool
-  get_parameters(
-    const std::string & prefix,
-    std::map<std::string, ParameterT> & values) const;
+  template <typename ParameterT>
+  bool get_parameters(const std::string & prefix, std::map<std::string, ParameterT> & values) const;
 
   /// Get the parameter value; if not set, set the "alternative value" and store it in the node.
   /**
@@ -813,13 +755,9 @@ public:
    * \param[out] value The output where the value of the parameter should be assigned.
    * \param[in] alternative_value Value to be used if the parameter was not set.
    */
-  template<typename ParameterT>
-  [[deprecated("use declare_parameter() and it's return value instead")]]
-  void
-  get_parameter_or_set(
-    const std::string & name,
-    ParameterT & value,
-    const ParameterT & alternative_value);
+  template <typename ParameterT>
+  [[deprecated("use declare_parameter() and it's return value instead")]] void get_parameter_or_set(
+    const std::string & name, ParameterT & value, const ParameterT & alternative_value);
 
   /// Return the parameter descriptor for the given parameter name.
   /**
@@ -838,8 +776,7 @@ public:
    *   allowed.
    */
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ParameterDescriptor
-  describe_parameter(const std::string & name) const;
+  rcl_interfaces::msg::ParameterDescriptor describe_parameter(const std::string & name) const;
 
   /// Return a vector of parameter descriptors, one for each of the given names.
   /**
@@ -860,8 +797,8 @@ public:
    *   allowed.
    */
   RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(const std::vector<std::string> & names) const;
+  std::vector<rcl_interfaces::msg::ParameterDescriptor> describe_parameters(
+    const std::vector<std::string> & names) const;
 
   /// Return a vector of parameter types, one for each of the given names.
   /**
@@ -880,19 +817,17 @@ public:
    *   allowed.
    */
   RCLCPP_PUBLIC
-  std::vector<uint8_t>
-  get_parameter_types(const std::vector<std::string> & names) const;
+  std::vector<uint8_t> get_parameter_types(const std::vector<std::string> & names) const;
 
   /// Return a list of parameters with any of the given prefixes, up to the given depth.
   /**
    * \todo: properly document and test this method.
    */
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ListParametersResult
-  list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const;
+  rcl_interfaces::msg::ListParametersResult list_parameters(
+    const std::vector<std::string> & prefixes, uint64_t depth) const;
 
-  using OnSetParametersCallbackHandle =
-    rclcpp::node_interfaces::OnSetParametersCallbackHandle;
+  using OnSetParametersCallbackHandle = rclcpp::node_interfaces::OnSetParametersCallbackHandle;
   using OnParametersSetCallbackType =
     rclcpp::node_interfaces::NodeParametersInterface::OnParametersSetCallbackType;
 
@@ -958,8 +893,8 @@ public:
    * \throws std::bad_alloc if the allocation of the OnSetParametersCallbackHandle fails.
    */
   RCLCPP_PUBLIC
-  OnSetParametersCallbackHandle::SharedPtr
-  add_on_set_parameters_callback(OnParametersSetCallbackType callback);
+  OnSetParametersCallbackHandle::SharedPtr add_on_set_parameters_callback(
+    OnParametersSetCallbackType callback);
 
   /// Remove a callback registered with `add_on_set_parameters_callback`.
   /**
@@ -985,8 +920,7 @@ public:
    *   or if it has been removed before.
    */
   RCLCPP_PUBLIC
-  void
-  remove_on_set_parameters_callback(const OnSetParametersCallbackHandle * const handler);
+  void remove_on_set_parameters_callback(const OnSetParametersCallbackHandle * const handler);
 
   /// Register a callback to be called anytime a parameter is about to be changed.
   /**
@@ -1003,8 +937,8 @@ public:
    *   otherwise nullptr.
    */
   RCLCPP_PUBLIC
-  OnParametersSetCallbackType
-  set_on_parameters_set_callback(rclcpp::Node::OnParametersSetCallbackType callback);
+  OnParametersSetCallbackType set_on_parameters_set_callback(
+    rclcpp::Node::OnParametersSetCallbackType callback);
 
   /// Register the callback for parameter changes
   /**
@@ -1012,9 +946,8 @@ public:
    *   It is expected to atomically set parameters.
    * \note Repeated invocations of this function will overwrite previous callbacks.
    */
-  template<typename CallbackT>
-  [[deprecated("use set_on_parameters_set_callback() instead")]]
-  void
+  template <typename CallbackT>
+  [[deprecated("use set_on_parameters_set_callback() instead")]] void
   register_param_change_callback(CallbackT && callback);
 
   /// Get the fully-qualified names of all available nodes.
@@ -1023,24 +956,19 @@ public:
    * \return A vector of fully-qualified names of nodes.
    */
   RCLCPP_PUBLIC
-  std::vector<std::string>
-  get_node_names() const;
+  std::vector<std::string> get_node_names() const;
 
   RCLCPP_PUBLIC
-  std::map<std::string, std::vector<std::string>>
-  get_topic_names_and_types() const;
+  std::map<std::string, std::vector<std::string>> get_topic_names_and_types() const;
 
   RCLCPP_PUBLIC
-  std::map<std::string, std::vector<std::string>>
-  get_service_names_and_types() const;
+  std::map<std::string, std::vector<std::string>> get_service_names_and_types() const;
 
   RCLCPP_PUBLIC
-  size_t
-  count_publishers(const std::string & topic_name) const;
+  size_t count_publishers(const std::string & topic_name) const;
 
   RCLCPP_PUBLIC
-  size_t
-  count_subscribers(const std::string & topic_name) const;
+  size_t count_subscribers(const std::string & topic_name) const;
 
   /// Return a graph event, which will be set anytime a graph change occurs.
   /* The graph Event object is a loan which must be returned.
@@ -1048,8 +976,7 @@ public:
    * out of scope.
    */
   RCLCPP_PUBLIC
-  rclcpp::Event::SharedPtr
-  get_graph_event();
+  rclcpp::Event::SharedPtr get_graph_event();
 
   /// Wait for a graph event to occur by waiting on an Event to become set.
   /**
@@ -1060,68 +987,53 @@ public:
    *   get_graph_event().
    */
   RCLCPP_PUBLIC
-  void
-  wait_for_graph_change(
-    rclcpp::Event::SharedPtr event,
-    std::chrono::nanoseconds timeout);
+  void wait_for_graph_change(rclcpp::Event::SharedPtr event, std::chrono::nanoseconds timeout);
 
   RCLCPP_PUBLIC
-  rclcpp::Clock::SharedPtr
-  get_clock();
+  rclcpp::Clock::SharedPtr get_clock();
 
   RCLCPP_PUBLIC
-  Time
-  now();
+  Time now();
 
   /// Return the Node's internal NodeBaseInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
-  get_node_base_interface();
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr get_node_base_interface();
 
   /// Return the Node's internal NodeClockInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeClockInterface::SharedPtr
-  get_node_clock_interface();
+  rclcpp::node_interfaces::NodeClockInterface::SharedPtr get_node_clock_interface();
 
   /// Return the Node's internal NodeGraphInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeGraphInterface::SharedPtr
-  get_node_graph_interface();
+  rclcpp::node_interfaces::NodeGraphInterface::SharedPtr get_node_graph_interface();
 
   /// Return the Node's internal NodeLoggingInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr
-  get_node_logging_interface();
+  rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr get_node_logging_interface();
 
   /// Return the Node's internal NodeTimersInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeTimersInterface::SharedPtr
-  get_node_timers_interface();
+  rclcpp::node_interfaces::NodeTimersInterface::SharedPtr get_node_timers_interface();
 
   /// Return the Node's internal NodeTopicsInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr
-  get_node_topics_interface();
+  rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr get_node_topics_interface();
 
   /// Return the Node's internal NodeServicesInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeServicesInterface::SharedPtr
-  get_node_services_interface();
+  rclcpp::node_interfaces::NodeServicesInterface::SharedPtr get_node_services_interface();
 
   /// Return the Node's internal NodeWaitablesInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeWaitablesInterface::SharedPtr
-  get_node_waitables_interface();
+  rclcpp::node_interfaces::NodeWaitablesInterface::SharedPtr get_node_waitables_interface();
 
   /// Return the Node's internal NodeParametersInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr
-  get_node_parameters_interface();
+  rclcpp::node_interfaces::NodeParametersInterface::SharedPtr get_node_parameters_interface();
 
   /// Return the Node's internal NodeParametersInterface implementation.
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeTimeSourceInterface::SharedPtr
-  get_node_time_source_interface();
+  rclcpp::node_interfaces::NodeTimeSourceInterface::SharedPtr get_node_time_source_interface();
 
   /// Return the sub-namespace, if this is a sub-node, otherwise an empty string.
   /**
@@ -1152,8 +1064,7 @@ public:
    * \return the sub-namespace string, not including the node's original namespace
    */
   RCLCPP_PUBLIC
-  const std::string &
-  get_sub_namespace() const;
+  const std::string & get_sub_namespace() const;
 
   /// Return the effective namespace that is used when creating entities.
   /**
@@ -1180,8 +1091,7 @@ public:
    * \return the sub-namespace string, not including the node's original namespace
    */
   RCLCPP_PUBLIC
-  const std::string &
-  get_effective_namespace() const;
+  const std::string & get_effective_namespace() const;
 
   /// Create a sub-node, which will extend the namespace of all entities created with it.
   /**
@@ -1222,13 +1132,11 @@ public:
    *   with a leading '/'.
    */
   RCLCPP_PUBLIC
-  rclcpp::Node::SharedPtr
-  create_sub_node(const std::string & sub_namespace);
+  rclcpp::Node::SharedPtr create_sub_node(const std::string & sub_namespace);
 
   /// Return the NodeOptions used when creating this node.
   RCLCPP_PUBLIC
-  const rclcpp::NodeOptions &
-  get_node_options() const;
+  const rclcpp::NodeOptions & get_node_options() const;
 
   /// Manually assert that this Node is alive (for RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE).
   /**
@@ -1240,8 +1148,7 @@ public:
    */
   RCLCPP_PUBLIC
   RCUTILS_WARN_UNUSED
-  bool
-  assert_liveliness() const;
+  bool assert_liveliness() const;
 
 protected:
   /// Construct a sub-node, which will extend the namespace of all entities created with it.
@@ -1252,16 +1159,13 @@ protected:
    * \param[in] sub_namespace The sub-namespace of the sub-node.
    */
   RCLCPP_PUBLIC
-  Node(
-    const Node & other,
-    const std::string & sub_namespace);
+  Node(const Node & other, const std::string & sub_namespace);
 
 private:
   RCLCPP_DISABLE_COPY(Node)
 
   RCLCPP_PUBLIC
-  bool
-  group_in_node(callback_group::CallbackGroup::SharedPtr group);
+  bool group_in_node(callback_group::CallbackGroup::SharedPtr group);
 
   rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base_;
   rclcpp::node_interfaces::NodeGraphInterface::SharedPtr node_graph_;

rclcpp/include/rclcpp/node_impl.hpp

@@ -54,9 +54,8 @@ namespace rclcpp
 {
 
 RCLCPP_LOCAL
-inline
-std::string
-extend_name_with_sub_namespace(const std::string & name, const std::string & sub_namespace)
+inline std::string extend_name_with_sub_namespace(
+  const std::string & name, const std::string & sub_namespace)
 {
   std::string name_with_sub_namespace(name);
   if (sub_namespace != "" && name.front() != '/' && name.front() != '~') {
@@ -65,26 +64,18 @@ extend_name_with_sub_namespace(const std::string & name, const std::string & sub
   return name_with_sub_namespace;
 }
 
-template<typename MessageT, typename AllocatorT, typename PublisherT>
-std::shared_ptr<PublisherT>
-Node::create_publisher(
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
+template <typename MessageT, typename AllocatorT, typename PublisherT>
+std::shared_ptr<PublisherT> Node::create_publisher(
+  const std::string & topic_name, const rclcpp::QoS & qos,
   const PublisherOptionsWithAllocator<AllocatorT> & options)
 {
   return rclcpp::create_publisher<MessageT, AllocatorT, PublisherT>(
-    *this,
-    extend_name_with_sub_namespace(topic_name, this->get_sub_namespace()),
-    qos,
-    options);
+    *this, extend_name_with_sub_namespace(topic_name, this->get_sub_namespace()), qos, options);
 }
 
-template<typename MessageT, typename AllocatorT, typename PublisherT>
-std::shared_ptr<PublisherT>
-Node::create_publisher(
-  const std::string & topic_name,
-  size_t qos_history_depth,
-  std::shared_ptr<AllocatorT> allocator)
+template <typename MessageT, typename AllocatorT, typename PublisherT>
+std::shared_ptr<PublisherT> Node::create_publisher(
+  const std::string & topic_name, size_t qos_history_depth, std::shared_ptr<AllocatorT> allocator)
 {
   PublisherOptionsWithAllocator<AllocatorT> pub_options;
   pub_options.allocator = allocator;
@@ -92,11 +83,9 @@ Node::create_publisher(
     topic_name, rclcpp::QoS(rclcpp::KeepLast(qos_history_depth)), pub_options);
 }
 
-template<typename MessageT, typename AllocatorT, typename PublisherT>
-std::shared_ptr<PublisherT>
-Node::create_publisher(
-  const std::string & topic_name,
-  const rmw_qos_profile_t & qos_profile,
+template <typename MessageT, typename AllocatorT, typename PublisherT>
+std::shared_ptr<PublisherT> Node::create_publisher(
+  const std::string & topic_name, const rmw_qos_profile_t & qos_profile,
   std::shared_ptr<AllocatorT> allocator)
 {
   rclcpp::QoS qos(rclcpp::QoSInitialization::from_rmw(qos_profile));
@@ -107,45 +96,26 @@ Node::create_publisher(
   return this->create_publisher<MessageT, AllocatorT, PublisherT>(topic_name, qos, pub_options);
 }
 
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename AllocatorT,
-  typename SubscriptionT>
-std::shared_ptr<SubscriptionT>
-Node::create_subscription(
-  const std::string & topic_name,
-  const rclcpp::QoS & qos,
-  CallbackT && callback,
+template <typename MessageT, typename CallbackT, typename AllocatorT, typename SubscriptionT>
+std::shared_ptr<SubscriptionT> Node::create_subscription(
+  const std::string & topic_name, const rclcpp::QoS & qos, CallbackT && callback,
   const SubscriptionOptionsWithAllocator<AllocatorT> & options,
   typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
     typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, AllocatorT>::SharedPtr
-  msg_mem_strat)
+    msg_mem_strat)
 {
   return rclcpp::create_subscription<MessageT>(
-    *this,
-    extend_name_with_sub_namespace(topic_name, this->get_sub_namespace()),
-    qos,
-    std::forward<CallbackT>(callback),
-    options,
-    msg_mem_strat);
+    *this, extend_name_with_sub_namespace(topic_name, this->get_sub_namespace()), qos,
+    std::forward<CallbackT>(callback), options, msg_mem_strat);
 }
 
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename Alloc,
-  typename SubscriptionT>
-std::shared_ptr<SubscriptionT>
-Node::create_subscription(
-  const std::string & topic_name,
-  CallbackT && callback,
-  const rmw_qos_profile_t & qos_profile,
-  rclcpp::callback_group::CallbackGroup::SharedPtr group,
-  bool ignore_local_publications,
+template <typename MessageT, typename CallbackT, typename Alloc, typename SubscriptionT>
+std::shared_ptr<SubscriptionT> Node::create_subscription(
+  const std::string & topic_name, CallbackT && callback, const rmw_qos_profile_t & qos_profile,
+  rclcpp::callback_group::CallbackGroup::SharedPtr group, bool ignore_local_publications,
   typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
     typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>::SharedPtr
-  msg_mem_strat,
+    msg_mem_strat,
   std::shared_ptr<Alloc> allocator)
 {
   rclcpp::QoS qos(rclcpp::QoSInitialization::from_rmw(qos_profile));
@@ -160,21 +130,13 @@ Node::create_subscription(
     topic_name, qos, std::forward<CallbackT>(callback), sub_options, msg_mem_strat);
 }
 
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename Alloc,
-  typename SubscriptionT>
-std::shared_ptr<SubscriptionT>
-Node::create_subscription(
-  const std::string & topic_name,
-  CallbackT && callback,
-  size_t qos_history_depth,
-  rclcpp::callback_group::CallbackGroup::SharedPtr group,
-  bool ignore_local_publications,
+template <typename MessageT, typename CallbackT, typename Alloc, typename SubscriptionT>
+std::shared_ptr<SubscriptionT> Node::create_subscription(
+  const std::string & topic_name, CallbackT && callback, size_t qos_history_depth,
+  rclcpp::callback_group::CallbackGroup::SharedPtr group, bool ignore_local_publications,
   typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
     typename rclcpp::subscription_traits::has_message_type<CallbackT>::type, Alloc>::SharedPtr
-  msg_mem_strat,
+    msg_mem_strat,
   std::shared_ptr<Alloc> allocator)
 {
   SubscriptionOptionsWithAllocator<Alloc> sub_options;
@@ -183,82 +145,57 @@ Node::create_subscription(
   sub_options.allocator = allocator;
 
   return this->create_subscription<MessageT, CallbackT, Alloc, SubscriptionT>(
-    topic_name,
-    rclcpp::QoS(rclcpp::KeepLast(qos_history_depth)),
-    std::forward<CallbackT>(callback),
-    sub_options,
-    msg_mem_strat);
+    topic_name, rclcpp::QoS(rclcpp::KeepLast(qos_history_depth)), std::forward<CallbackT>(callback),
+    sub_options, msg_mem_strat);
 }
 
-template<typename DurationRepT, typename DurationT, typename CallbackT>
-typename rclcpp::WallTimer<CallbackT>::SharedPtr
-Node::create_wall_timer(
-  std::chrono::duration<DurationRepT, DurationT> period,
-  CallbackT callback,
+template <typename DurationRepT, typename DurationT, typename CallbackT>
+typename rclcpp::WallTimer<CallbackT>::SharedPtr Node::create_wall_timer(
+  std::chrono::duration<DurationRepT, DurationT> period, CallbackT callback,
   rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   auto timer = rclcpp::WallTimer<CallbackT>::make_shared(
-    std::chrono::duration_cast<std::chrono::nanoseconds>(period),
-    std::move(callback),
+    std::chrono::duration_cast<std::chrono::nanoseconds>(period), std::move(callback),
     this->node_base_->get_context());
   node_timers_->add_timer(timer, group);
   return timer;
 }
 
-template<typename ServiceT>
-typename Client<ServiceT>::SharedPtr
-Node::create_client(
-  const std::string & service_name,
-  const rmw_qos_profile_t & qos_profile,
+template <typename ServiceT>
+typename Client<ServiceT>::SharedPtr Node::create_client(
+  const std::string & service_name, const rmw_qos_profile_t & qos_profile,
   rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   return rclcpp::create_client<ServiceT>(
-    node_base_,
-    node_graph_,
-    node_services_,
-    extend_name_with_sub_namespace(service_name, this->get_sub_namespace()),
-    qos_profile,
-    group);
+    node_base_, node_graph_, node_services_,
+    extend_name_with_sub_namespace(service_name, this->get_sub_namespace()), qos_profile, group);
 }
 
-template<typename ServiceT, typename CallbackT>
-typename rclcpp::Service<ServiceT>::SharedPtr
-Node::create_service(
-  const std::string & service_name,
-  CallbackT && callback,
-  const rmw_qos_profile_t & qos_profile,
+template <typename ServiceT, typename CallbackT>
+typename rclcpp::Service<ServiceT>::SharedPtr Node::create_service(
+  const std::string & service_name, CallbackT && callback, const rmw_qos_profile_t & qos_profile,
   rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   return rclcpp::create_service<ServiceT, CallbackT>(
-    node_base_,
-    node_services_,
+    node_base_, node_services_,
     extend_name_with_sub_namespace(service_name, this->get_sub_namespace()),
-    std::forward<CallbackT>(callback),
-    qos_profile,
-    group);
+    std::forward<CallbackT>(callback), qos_profile, group);
 }
 
-template<typename ParameterT>
-auto
-Node::declare_parameter(
-  const std::string & name,
-  const ParameterT & default_value,
-  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-  bool ignore_override)
+template <typename ParameterT>
+auto Node::declare_parameter(
+  const std::string & name, const ParameterT & default_value,
+  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor, bool ignore_override)
 {
-  return this->declare_parameter(
-    name,
-    rclcpp::ParameterValue(default_value),
-    parameter_descriptor,
-    ignore_override
-  ).get<ParameterT>();
+  return this
+    ->declare_parameter(
+      name, rclcpp::ParameterValue(default_value), parameter_descriptor, ignore_override)
+    .get<ParameterT>();
 }
 
-template<typename ParameterT>
-std::vector<ParameterT>
-Node::declare_parameters(
-  const std::string & namespace_,
-  const std::map<std::string, ParameterT> & parameters,
+template <typename ParameterT>
+std::vector<ParameterT> Node::declare_parameters(
+  const std::string & namespace_, const std::map<std::string, ParameterT> & parameters,
   bool ignore_overrides)
 {
   std::vector<ParameterT> result;
@@ -267,23 +204,17 @@ Node::declare_parameters(
     parameters.begin(), parameters.end(), std::back_inserter(result),
     [this, &normalized_namespace, ignore_overrides](auto element) {
       return this->declare_parameter(
-        normalized_namespace + element.first,
-        element.second,
-        rcl_interfaces::msg::ParameterDescriptor(),
-        ignore_overrides);
-    }
-  );
+        normalized_namespace + element.first, element.second,
+        rcl_interfaces::msg::ParameterDescriptor(), ignore_overrides);
+    });
   return result;
 }
 
-template<typename ParameterT>
-std::vector<ParameterT>
-Node::declare_parameters(
+template <typename ParameterT>
+std::vector<ParameterT> Node::declare_parameters(
   const std::string & namespace_,
-  const std::map<
-    std::string,
-    std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor>
-  > & parameters,
+  const std::map<std::string, std::pair<ParameterT, rcl_interfaces::msg::ParameterDescriptor> > &
+    parameters,
   bool ignore_overrides)
 {
   std::vector<ParameterT> result;
@@ -291,28 +222,17 @@ Node::declare_parameters(
   std::transform(
     parameters.begin(), parameters.end(), std::back_inserter(result),
     [this, &normalized_namespace, ignore_overrides](auto element) {
-      return static_cast<ParameterT>(
-        this->declare_parameter(
-          normalized_namespace + element.first,
-          element.second.first,
-          element.second.second,
-          ignore_overrides)
-      );
-    }
-  );
+      return static_cast<ParameterT>(this->declare_parameter(
+        normalized_namespace + element.first, element.second.first, element.second.second,
+        ignore_overrides));
+    });
   return result;
 }
 
-template<typename ParameterT>
-void
-Node::set_parameter_if_not_set(
-  const std::string & name,
-  const ParameterT & value)
+template <typename ParameterT>
+void Node::set_parameter_if_not_set(const std::string & name, const ParameterT & value)
 {
-  if (
-    !this->has_parameter(name) ||
-    this->describe_parameter(name).type == PARAMETER_NOT_SET)
-  {
+  if (!this->has_parameter(name) || this->describe_parameter(name).type == PARAMETER_NOT_SET) {
     this->set_parameter(rclcpp::Parameter(name, value));
   }
 }
@@ -320,11 +240,9 @@ Node::set_parameter_if_not_set(
 // this is a partially-specialized version of set_parameter_if_not_set above,
 // where our concrete type for ParameterT is std::map, but the to-be-determined
 // type is the value in the map.
-template<typename ParameterT>
-void
-Node::set_parameters_if_not_set(
-  const std::string & name,
-  const std::map<std::string, ParameterT> & values)
+template <typename ParameterT>
+void Node::set_parameters_if_not_set(
+  const std::string & name, const std::map<std::string, ParameterT> & values)
 {
   std::vector<rclcpp::Parameter> params;
 
@@ -332,8 +250,7 @@ Node::set_parameters_if_not_set(
     std::string parameter_name = name + "." + val.first;
     if (
       !this->has_parameter(parameter_name) ||
-      this->describe_parameter(parameter_name).type == PARAMETER_NOT_SET)
-    {
+      this->describe_parameter(parameter_name).type == PARAMETER_NOT_SET) {
       params.push_back(rclcpp::Parameter(parameter_name, val.second));
     }
   }
@@ -341,9 +258,8 @@ Node::set_parameters_if_not_set(
   this->set_parameters(params);
 }
 
-template<typename ParameterT>
-bool
-Node::get_parameter(const std::string & name, ParameterT & parameter) const
+template <typename ParameterT>
+bool Node::get_parameter(const std::string & name, ParameterT & parameter) const
 {
   std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
 
@@ -357,12 +273,9 @@ Node::get_parameter(const std::string & name, ParameterT & parameter) const
   return result;
 }
 
-template<typename ParameterT>
-bool
-Node::get_parameter_or(
-  const std::string & name,
-  ParameterT & parameter,
-  const ParameterT & alternative_value) const
+template <typename ParameterT>
+bool Node::get_parameter_or(
+  const std::string & name, ParameterT & parameter, const ParameterT & alternative_value) const
 {
   std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
 
@@ -376,11 +289,9 @@ Node::get_parameter_or(
 // this is a partially-specialized version of get_parameter above,
 // where our concrete type for ParameterT is std::map, but the to-be-determined
 // type is the value in the map.
-template<typename ParameterT>
-bool
-Node::get_parameters(
-  const std::string & prefix,
-  std::map<std::string, ParameterT> & values) const
+template <typename ParameterT>
+bool Node::get_parameters(
+  const std::string & prefix, std::map<std::string, ParameterT> & values) const
 {
   std::map<std::string, rclcpp::Parameter> params;
   bool result = node_parameters_->get_parameters_by_prefix(prefix, params);
@@ -393,25 +304,23 @@ Node::get_parameters(
   return result;
 }
 
-template<typename ParameterT>
-void
-Node::get_parameter_or_set(
-  const std::string & name,
-  ParameterT & value,
-  const ParameterT & alternative_value)
+template <typename ParameterT>
+void Node::get_parameter_or_set(
+  const std::string & name, ParameterT & value, const ParameterT & alternative_value)
 {
   std::string sub_name = extend_name_with_sub_namespace(name, this->get_sub_namespace());
 
   bool got_parameter = get_parameter(sub_name, value);
   if (!got_parameter) {
-    this->set_parameters({rclcpp::Parameter(sub_name, alternative_value), });
+    this->set_parameters({
+      rclcpp::Parameter(sub_name, alternative_value),
+    });
     value = alternative_value;
   }
 }
 
-template<typename CallbackT>
-void
-Node::register_param_change_callback(CallbackT && callback)
+template <typename CallbackT>
+void Node::register_param_change_callback(CallbackT && callback)
 {
   this->node_parameters_->register_param_change_callback(std::forward<CallbackT>(callback));
 }

rclcpp/include/rclcpp/node_interfaces/get_node_base_interface.hpp

@@ -16,8 +16,8 @@
 #define RCLCPP__NODE_INTERFACES__GET_NODE_BASE_INTERFACE_HPP_
 
 #include <memory>
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
 
@@ -43,22 +43,16 @@ namespace detail
 // This is a meta-programming checker for if a given Node-like object has a
 // getter called get_node_base_interface() which returns various types,
 // e.g. const pointer or a shared pointer.
-template<typename NodeType, typename ReturnType>
+template <typename NodeType, typename ReturnType>
 struct has_get_node_base_interface
 {
 private:
-  template<typename T>
-  static constexpr
-  auto
-  check(T *)->typename std::is_same<
-    decltype(std::declval<T>().get_node_base_interface()),
-    ReturnType
-  >::type;
+  template <typename T>
+  static constexpr auto check(T *) ->
+    typename std::is_same<decltype(std::declval<T>().get_node_base_interface()), ReturnType>::type;
 
-  template<typename>
-  static constexpr
-  std::false_type
-  check(...);
+  template <typename>
+  static constexpr std::false_type check(...);
 
 public:
   using type = decltype(check<NodeType>(nullptr));
@@ -66,51 +60,47 @@ public:
 };
 
 // If NodeType is a pointer to NodeBaseInterface already (just normal function overload).
-inline
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface_from_pointer(rclcpp::node_interfaces::NodeBaseInterface * pointer)
+inline rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface_from_pointer(
+  rclcpp::node_interfaces::NodeBaseInterface * pointer)
 {
   return pointer;
 }
 
 // If NodeType has a method called get_node_base_interface() which returns a shared pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_base_interface<
-    typename std::remove_pointer<NodeType>::type,
-    std::shared_ptr<rclcpp::node_interfaces::NodeBaseInterface>
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_base_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         std::shared_ptr<rclcpp::node_interfaces::NodeBaseInterface> >::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_base_interface().get();
 }
 
 // If NodeType has a method called get_node_base_interface() which returns a pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_base_interface<
-    typename std::remove_pointer<NodeType>::type,
-    rclcpp::node_interfaces::NodeBaseInterface *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_base_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         rclcpp::node_interfaces::NodeBaseInterface *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_base_interface();
 }
 
 // Forward shared_ptr's to const node pointer signatures.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_same<
-    NodeType,
-    typename std::shared_ptr<typename std::remove_pointer<NodeType>::type::element_type> *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface_from_pointer(NodeType node_shared_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       std::is_same<
+                         NodeType, typename std::shared_ptr<typename std::remove_pointer<
+                                     NodeType>::type::element_type> *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface_from_pointer(
+  NodeType node_shared_pointer)
 {
   return get_node_base_interface_from_pointer(node_shared_pointer->get());
 }
@@ -118,26 +108,20 @@ get_node_base_interface_from_pointer(NodeType node_shared_pointer)
 }  // namespace detail
 
 /// Get the NodeBaseInterface as a pointer from a pointer to a "Node like" object.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface(NodeType node_pointer)
 {
   // Forward pointers to detail implmentation directly.
   return detail::get_node_base_interface_from_pointer(node_pointer);
 }
 
 /// Get the NodeBaseInterface as a pointer from a "Node like" object.
-template<
+template <
   typename NodeType,
   typename std::enable_if<
-    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int
-  >::type = 0
->
-rclcpp::node_interfaces::NodeBaseInterface *
-get_node_base_interface(NodeType && node_reference)
+    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface(NodeType && node_reference)
 {
   // Forward references to detail implmentation as a pointer.
   return detail::get_node_base_interface_from_pointer(&node_reference);

rclcpp/include/rclcpp/node_interfaces/get_node_timers_interface.hpp

@@ -16,8 +16,8 @@
 #define RCLCPP__NODE_INTERFACES__GET_NODE_TIMERS_INTERFACE_HPP_
 
 #include <memory>
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 #include "rclcpp/node_interfaces/node_timers_interface.hpp"
 
@@ -43,22 +43,16 @@ namespace detail
 // This is a meta-programming checker for if a given Node-like object has a
 // getter called get_node_timers_interface() which returns various types,
 // e.g. const pointer or a shared pointer.
-template<typename NodeType, typename ReturnType>
+template <typename NodeType, typename ReturnType>
 struct has_get_node_timers_interface
 {
 private:
-  template<typename T>
-  static constexpr
-  auto
-  check(T *)->typename std::is_same<
-    decltype(std::declval<T>().get_node_timers_interface()),
-    ReturnType
-  >::type;
+  template <typename T>
+  static constexpr auto check(T *) -> typename std::is_same<
+    decltype(std::declval<T>().get_node_timers_interface()), ReturnType>::type;
 
-  template<typename>
-  static constexpr
-  std::false_type
-  check(...);
+  template <typename>
+  static constexpr std::false_type check(...);
 
 public:
   using type = decltype(check<NodeType>(nullptr));
@@ -66,51 +60,47 @@ public:
 };
 
 // If NodeType is a pointer to NodeTimersInterface already (just normal function overload).
-inline
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface_from_pointer(rclcpp::node_interfaces::NodeTimersInterface * pointer)
+inline rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface_from_pointer(
+  rclcpp::node_interfaces::NodeTimersInterface * pointer)
 {
   return pointer;
 }
 
 // If NodeType has a method called get_node_timers_interface() which returns a shared pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_timers_interface<
-    typename std::remove_pointer<NodeType>::type,
-    std::shared_ptr<rclcpp::node_interfaces::NodeTimersInterface>
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_timers_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         std::shared_ptr<rclcpp::node_interfaces::NodeTimersInterface> >::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_timers_interface().get();
 }
 
 // If NodeType has a method called get_node_timers_interface() which returns a pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_timers_interface<
-    typename std::remove_pointer<NodeType>::type,
-    rclcpp::node_interfaces::NodeTimersInterface *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_timers_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         rclcpp::node_interfaces::NodeTimersInterface *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_timers_interface();
 }
 
 // Forward shared_ptr's to const node pointer signatures.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_same<
-    NodeType,
-    typename std::shared_ptr<typename std::remove_pointer<NodeType>::type::element_type> *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface_from_pointer(NodeType node_shared_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       std::is_same<
+                         NodeType, typename std::shared_ptr<typename std::remove_pointer<
+                                     NodeType>::type::element_type> *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface_from_pointer(
+  NodeType node_shared_pointer)
 {
   return get_node_timers_interface_from_pointer(node_shared_pointer->get());
 }
@@ -118,26 +108,20 @@ get_node_timers_interface_from_pointer(NodeType node_shared_pointer)
 }  // namespace detail
 
 /// Get the NodeTimersInterface as a pointer from a pointer to a "Node like" object.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface(NodeType node_pointer)
 {
   // Forward pointers to detail implmentation directly.
   return detail::get_node_timers_interface_from_pointer(node_pointer);
 }
 
 /// Get the NodeTimersInterface as a pointer from a "Node like" object.
-template<
+template <
   typename NodeType,
   typename std::enable_if<
-    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int
-  >::type = 0
->
-rclcpp::node_interfaces::NodeTimersInterface *
-get_node_timers_interface(NodeType && node_reference)
+    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeTimersInterface * get_node_timers_interface(NodeType && node_reference)
 {
   // Forward references to detail implmentation as a pointer.
   return detail::get_node_timers_interface_from_pointer(&node_reference);

rclcpp/include/rclcpp/node_interfaces/get_node_topics_interface.hpp

@@ -16,8 +16,8 @@
 #define RCLCPP__NODE_INTERFACES__GET_NODE_TOPICS_INTERFACE_HPP_
 
 #include <memory>
-#include <utility>
 #include <type_traits>
+#include <utility>
 
 #include "rclcpp/node_interfaces/node_topics_interface.hpp"
 
@@ -43,22 +43,16 @@ namespace detail
 // This is a meta-programming checker for if a given Node-like object has a
 // getter called get_node_topics_interface() which returns various types,
 // e.g. const pointer or a shared pointer.
-template<typename NodeType, typename ReturnType>
+template <typename NodeType, typename ReturnType>
 struct has_get_node_topics_interface
 {
 private:
-  template<typename T>
-  static constexpr
-  auto
-  check(T *)->typename std::is_same<
-    decltype(std::declval<T>().get_node_topics_interface()),
-    ReturnType
-  >::type;
+  template <typename T>
+  static constexpr auto check(T *) -> typename std::is_same<
+    decltype(std::declval<T>().get_node_topics_interface()), ReturnType>::type;
 
-  template<typename>
-  static constexpr
-  std::false_type
-  check(...);
+  template <typename>
+  static constexpr std::false_type check(...);
 
 public:
   using type = decltype(check<NodeType>(nullptr));
@@ -66,51 +60,47 @@ public:
 };
 
 // If NodeType is a pointer to NodeTopicsInterface already (just normal function overload).
-inline
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface_from_pointer(rclcpp::node_interfaces::NodeTopicsInterface * pointer)
+inline rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface_from_pointer(
+  rclcpp::node_interfaces::NodeTopicsInterface * pointer)
 {
   return pointer;
 }
 
 // If NodeType has a method called get_node_topics_interface() which returns a shared pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_topics_interface<
-    typename std::remove_pointer<NodeType>::type,
-    std::shared_ptr<rclcpp::node_interfaces::NodeTopicsInterface>
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_topics_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         std::shared_ptr<rclcpp::node_interfaces::NodeTopicsInterface> >::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_topics_interface().get();
 }
 
 // If NodeType has a method called get_node_topics_interface() which returns a pointer.
-template<
-  typename NodeType,
-  typename std::enable_if<has_get_node_topics_interface<
-    typename std::remove_pointer<NodeType>::type,
-    rclcpp::node_interfaces::NodeTopicsInterface *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface_from_pointer(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       has_get_node_topics_interface<
+                         typename std::remove_pointer<NodeType>::type,
+                         rclcpp::node_interfaces::NodeTopicsInterface *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface_from_pointer(
+  NodeType node_pointer)
 {
   return node_pointer->get_node_topics_interface();
 }
 
 // Forward shared_ptr's to const node pointer signatures.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_same<
-    NodeType,
-    typename std::shared_ptr<typename std::remove_pointer<NodeType>::type::element_type> *
-  >::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface_from_pointer(NodeType node_shared_pointer)
+template <
+  typename NodeType, typename std::enable_if<
+                       std::is_same<
+                         NodeType, typename std::shared_ptr<typename std::remove_pointer<
+                                     NodeType>::type::element_type> *>::value,
+                       int>::type = 0>
+rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface_from_pointer(
+  NodeType node_shared_pointer)
 {
   return get_node_topics_interface_from_pointer(node_shared_pointer->get());
 }
@@ -118,26 +108,20 @@ get_node_topics_interface_from_pointer(NodeType node_shared_pointer)
 }  // namespace detail
 
 /// Get the NodeTopicsInterface as a pointer from a pointer to a "Node like" object.
-template<
-  typename NodeType,
-  typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0
->
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface(NodeType node_pointer)
+template <
+  typename NodeType, typename std::enable_if<std::is_pointer<NodeType>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface(NodeType node_pointer)
 {
   // Forward pointers to detail implmentation directly.
   return detail::get_node_topics_interface_from_pointer(node_pointer);
 }
 
 /// Get the NodeTopicsInterface as a pointer from a "Node like" object.
-template<
+template <
   typename NodeType,
   typename std::enable_if<
-    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int
-  >::type = 0
->
-rclcpp::node_interfaces::NodeTopicsInterface *
-get_node_topics_interface(NodeType && node_reference)
+    !std::is_pointer<typename std::remove_reference<NodeType>::type>::value, int>::type = 0>
+rclcpp::node_interfaces::NodeTopicsInterface * get_node_topics_interface(NodeType && node_reference)
 {
   // Forward references to detail implmentation as a pointer.
   return detail::get_node_topics_interface_from_pointer(&node_reference);

rclcpp/include/rclcpp/node_interfaces/node_base.hpp

@@ -39,100 +39,65 @@ public:
 
   RCLCPP_PUBLIC
   NodeBase(
-    const std::string & node_name,
-    const std::string & namespace_,
-    rclcpp::Context::SharedPtr context,
-    const rcl_node_options_t & rcl_node_options,
+    const std::string & node_name, const std::string & namespace_,
+    rclcpp::Context::SharedPtr context, const rcl_node_options_t & rcl_node_options,
     bool use_intra_process_default);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeBase();
+  virtual ~NodeBase();
 
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_name() const;
+  virtual const char * get_name() const;
 
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_namespace() const;
+  virtual const char * get_namespace() const;
 
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_fully_qualified_name() const;
+  virtual const char * get_fully_qualified_name() const;
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Context::SharedPtr
-  get_context();
+  virtual rclcpp::Context::SharedPtr get_context();
 
   RCLCPP_PUBLIC
-  virtual
-  rcl_node_t *
-  get_rcl_node_handle();
+  virtual rcl_node_t * get_rcl_node_handle();
 
   RCLCPP_PUBLIC
-  virtual
-  const rcl_node_t *
-  get_rcl_node_handle() const;
+  virtual const rcl_node_t * get_rcl_node_handle() const;
 
   RCLCPP_PUBLIC
-  virtual
-  std::shared_ptr<rcl_node_t>
-  get_shared_rcl_node_handle();
+  virtual std::shared_ptr<rcl_node_t> get_shared_rcl_node_handle();
 
   RCLCPP_PUBLIC
-  virtual
-  std::shared_ptr<const rcl_node_t>
-  get_shared_rcl_node_handle() const;
+  virtual std::shared_ptr<const rcl_node_t> get_shared_rcl_node_handle() const;
 
   RCLCPP_PUBLIC
-  virtual
-  bool
-  assert_liveliness() const;
+  virtual bool assert_liveliness() const;
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  create_callback_group(rclcpp::callback_group::CallbackGroupType group_type);
+  virtual rclcpp::callback_group::CallbackGroup::SharedPtr create_callback_group(
+    rclcpp::callback_group::CallbackGroupType group_type);
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_default_callback_group();
+  virtual rclcpp::callback_group::CallbackGroup::SharedPtr get_default_callback_group();
 
   RCLCPP_PUBLIC
-  virtual
-  bool
-  callback_group_in_node(rclcpp::callback_group::CallbackGroup::SharedPtr group);
+  virtual bool callback_group_in_node(rclcpp::callback_group::CallbackGroup::SharedPtr group);
 
   RCLCPP_PUBLIC
-  virtual
-  const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> &
-  get_callback_groups() const;
+  virtual const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> & get_callback_groups()
+    const;
 
   RCLCPP_PUBLIC
-  virtual
-  std::atomic_bool &
-  get_associated_with_executor_atomic();
+  virtual std::atomic_bool & get_associated_with_executor_atomic();
 
   RCLCPP_PUBLIC
-  virtual
-  rcl_guard_condition_t *
-  get_notify_guard_condition();
+  virtual rcl_guard_condition_t * get_notify_guard_condition();
 
   RCLCPP_PUBLIC
-  virtual
-  std::unique_lock<std::recursive_mutex>
-  acquire_notify_guard_condition_lock() const;
+  virtual std::unique_lock<std::recursive_mutex> acquire_notify_guard_condition_lock() const;
 
   RCLCPP_PUBLIC
-  virtual
-  bool
-  get_use_intra_process_default() const;
+  virtual bool get_use_intra_process_default() const;
 
 private:
   RCLCPP_DISABLE_COPY(NodeBase)

rclcpp/include/rclcpp/node_interfaces/node_base_interface.hpp

@@ -39,48 +39,35 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeBaseInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeBaseInterface() = default;
+  virtual ~NodeBaseInterface() = default;
 
   /// Return the name of the node.
   /** \return The name of the node. */
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_name() const = 0;
+  virtual const char * get_name() const = 0;
 
   /// Return the namespace of the node.
   /** \return The namespace of the node. */
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_namespace() const = 0;
+  virtual const char * get_namespace() const = 0;
 
   /// Return the fully qualified name of the node.
   /** \return The fully qualified name of the node. */
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_fully_qualified_name() const = 0;
+  virtual const char * get_fully_qualified_name() const = 0;
 
   /// Return the context of the node.
   /** \return SharedPtr to the node's context. */
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Context::SharedPtr
-  get_context() = 0;
+  virtual rclcpp::Context::SharedPtr get_context() = 0;
 
   /// Return the rcl_node_t node handle (non-const version).
   RCLCPP_PUBLIC
-  virtual
-  rcl_node_t *
-  get_rcl_node_handle() = 0;
+  virtual rcl_node_t * get_rcl_node_handle() = 0;
 
   /// Return the rcl_node_t node handle (const version).
   RCLCPP_PUBLIC
-  virtual
-  const rcl_node_t *
-  get_rcl_node_handle() const = 0;
+  virtual const rcl_node_t * get_rcl_node_handle() const = 0;
 
   /// Return the rcl_node_t node handle in a std::shared_ptr.
   /**
@@ -88,9 +75,7 @@ public:
    * The actual rcl node is not finalized until it is out of scope everywhere.
    */
   RCLCPP_PUBLIC
-  virtual
-  std::shared_ptr<rcl_node_t>
-  get_shared_rcl_node_handle() = 0;
+  virtual std::shared_ptr<rcl_node_t> get_shared_rcl_node_handle() = 0;
 
   /// Return the rcl_node_t node handle in a std::shared_ptr.
   /**
@@ -98,45 +83,33 @@ public:
    * The actual rcl node is not finalized until it is out of scope everywhere.
    */
   RCLCPP_PUBLIC
-  virtual
-  std::shared_ptr<const rcl_node_t>
-  get_shared_rcl_node_handle() const = 0;
+  virtual std::shared_ptr<const rcl_node_t> get_shared_rcl_node_handle() const = 0;
 
   /// Manually assert that this Node is alive (for RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE).
   RCLCPP_PUBLIC
-  virtual
-  bool
-  assert_liveliness() const = 0;
+  virtual bool assert_liveliness() const = 0;
 
   /// Create and return a callback group.
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  create_callback_group(rclcpp::callback_group::CallbackGroupType group_type) = 0;
+  virtual rclcpp::callback_group::CallbackGroup::SharedPtr create_callback_group(
+    rclcpp::callback_group::CallbackGroupType group_type) = 0;
 
   /// Return the default callback group.
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::callback_group::CallbackGroup::SharedPtr
-  get_default_callback_group() = 0;
+  virtual rclcpp::callback_group::CallbackGroup::SharedPtr get_default_callback_group() = 0;
 
   /// Return true if the given callback group is associated with this node.
   RCLCPP_PUBLIC
-  virtual
-  bool
-  callback_group_in_node(rclcpp::callback_group::CallbackGroup::SharedPtr group) = 0;
+  virtual bool callback_group_in_node(rclcpp::callback_group::CallbackGroup::SharedPtr group) = 0;
 
   /// Return list of callback groups associated with this node.
   RCLCPP_PUBLIC
-  virtual
-  const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> &
-  get_callback_groups() const = 0;
+  virtual const std::vector<rclcpp::callback_group::CallbackGroup::WeakPtr> & get_callback_groups()
+    const = 0;
 
   /// Return the atomic bool which is used to ensure only one executor is used.
   RCLCPP_PUBLIC
-  virtual
-  std::atomic_bool &
-  get_associated_with_executor_atomic() = 0;
+  virtual std::atomic_bool & get_associated_with_executor_atomic() = 0;
 
   /// Return guard condition that should be notified when the internal node state changes.
   /**
@@ -145,22 +118,16 @@ public:
    * \return the rcl_guard_condition_t if it is valid, else nullptr
    */
   RCLCPP_PUBLIC
-  virtual
-  rcl_guard_condition_t *
-  get_notify_guard_condition() = 0;
+  virtual rcl_guard_condition_t * get_notify_guard_condition() = 0;
 
   /// Acquire and return a scoped lock that protects the notify guard condition.
   /** This should be used when triggering the notify guard condition. */
   RCLCPP_PUBLIC
-  virtual
-  std::unique_lock<std::recursive_mutex>
-  acquire_notify_guard_condition_lock() const = 0;
+  virtual std::unique_lock<std::recursive_mutex> acquire_notify_guard_condition_lock() const = 0;
 
   /// Return the default preference for using intra process communication.
   RCLCPP_PUBLIC
-  virtual
-  bool
-  get_use_intra_process_default() const = 0;
+  virtual bool get_use_intra_process_default() const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_clock.hpp

@@ -45,14 +45,11 @@ public:
     rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr node_logging);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeClock();
+  virtual ~NodeClock();
 
   /// Get a clock which will be kept up to date by the node.
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Clock::SharedPtr
-  get_clock();
+  virtual rclcpp::Clock::SharedPtr get_clock();
 
 private:
   RCLCPP_DISABLE_COPY(NodeClock)

rclcpp/include/rclcpp/node_interfaces/node_clock_interface.hpp

@@ -32,14 +32,11 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeClockInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeClockInterface() = default;
+  virtual ~NodeClockInterface() = default;
 
   /// Get a ROS clock which will be kept up to date by the node.
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Clock::SharedPtr
-  get_clock() = 0;
+  virtual rclcpp::Clock::SharedPtr get_clock() = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_graph.hpp

@@ -52,70 +52,45 @@ public:
   explicit NodeGraph(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeGraph();
+  virtual ~NodeGraph();
 
   RCLCPP_PUBLIC
-  virtual
-  std::map<std::string, std::vector<std::string>>
-  get_topic_names_and_types(bool no_demangle = false) const;
+  virtual std::map<std::string, std::vector<std::string>> get_topic_names_and_types(
+    bool no_demangle = false) const;
 
   RCLCPP_PUBLIC
-  virtual
-  std::map<std::string, std::vector<std::string>>
-  get_service_names_and_types() const;
+  virtual std::map<std::string, std::vector<std::string>> get_service_names_and_types() const;
 
   RCLCPP_PUBLIC
-  virtual
-  std::vector<std::string>
-  get_node_names() const;
+  virtual std::vector<std::string> get_node_names() const;
 
   RCLCPP_PUBLIC
-  virtual
-  std::vector<std::pair<std::string, std::string>>
-  get_node_names_and_namespaces() const;
+  virtual std::vector<std::pair<std::string, std::string>> get_node_names_and_namespaces() const;
 
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_publishers(const std::string & topic_name) const;
+  virtual size_t count_publishers(const std::string & topic_name) const;
 
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_subscribers(const std::string & topic_name) const;
+  virtual size_t count_subscribers(const std::string & topic_name) const;
 
   RCLCPP_PUBLIC
-  virtual
-  const rcl_guard_condition_t *
-  get_graph_guard_condition() const;
+  virtual const rcl_guard_condition_t * get_graph_guard_condition() const;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  notify_graph_change();
+  virtual void notify_graph_change();
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  notify_shutdown();
+  virtual void notify_shutdown();
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Event::SharedPtr
-  get_graph_event();
+  virtual rclcpp::Event::SharedPtr get_graph_event();
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  wait_for_graph_change(
-    rclcpp::Event::SharedPtr event,
-    std::chrono::nanoseconds timeout);
+  virtual void wait_for_graph_change(
+    rclcpp::Event::SharedPtr event, std::chrono::nanoseconds timeout);
 
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_graph_users();
+  virtual size_t count_graph_users();
 
 private:
   RCLCPP_DISABLE_COPY(NodeGraph)

rclcpp/include/rclcpp/node_interfaces/node_graph_interface.hpp

@@ -39,8 +39,7 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeGraphInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeGraphInterface() = default;
+  virtual ~NodeGraphInterface() = default;
 
   /// Return a map of existing topic names to list of topic types.
   /**
@@ -50,9 +49,8 @@ public:
    * \param[in] no_demangle if true, topic names and types are not demangled
    */
   RCLCPP_PUBLIC
-  virtual
-  std::map<std::string, std::vector<std::string>>
-  get_topic_names_and_types(bool no_demangle = false) const = 0;
+  virtual std::map<std::string, std::vector<std::string>> get_topic_names_and_types(
+    bool no_demangle = false) const = 0;
 
   /// Return a map of existing service names to list of service types.
   /**
@@ -61,39 +59,28 @@ public:
    * process.
    */
   RCLCPP_PUBLIC
-  virtual
-  std::map<std::string, std::vector<std::string>>
-  get_service_names_and_types() const = 0;
+  virtual std::map<std::string, std::vector<std::string>> get_service_names_and_types() const = 0;
 
   /// Return a vector of existing node names (string).
   RCLCPP_PUBLIC
-  virtual
-  std::vector<std::string>
-  get_node_names() const = 0;
+  virtual std::vector<std::string> get_node_names() const = 0;
 
   /// Return a vector of existing node names and namespaces (pair of string).
   RCLCPP_PUBLIC
-  virtual
-  std::vector<std::pair<std::string, std::string>>
-  get_node_names_and_namespaces() const = 0;
+  virtual std::vector<std::pair<std::string, std::string>> get_node_names_and_namespaces()
+    const = 0;
 
   /// Return the number of publishers that are advertised on a given topic.
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_publishers(const std::string & topic_name) const = 0;
+  virtual size_t count_publishers(const std::string & topic_name) const = 0;
 
   /// Return the number of subscribers who have created a subscription for a given topic.
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_subscribers(const std::string & topic_name) const = 0;
+  virtual size_t count_subscribers(const std::string & topic_name) const = 0;
 
   /// Return the rcl guard condition which is triggered when the ROS graph changes.
   RCLCPP_PUBLIC
-  virtual
-  const rcl_guard_condition_t *
-  get_graph_guard_condition() const = 0;
+  virtual const rcl_guard_condition_t * get_graph_guard_condition() const = 0;
 
   /// Notify threads waiting on graph changes.
   /**
@@ -106,15 +93,11 @@ public:
    * \throws RCLBaseError (a child of that exception) when an rcl error occurs
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  notify_graph_change() = 0;
+  virtual void notify_graph_change() = 0;
 
   /// Notify any and all blocking node actions that shutdown has occurred.
   RCLCPP_PUBLIC
-  virtual
-  void
-  notify_shutdown() = 0;
+  virtual void notify_shutdown() = 0;
 
   /// Return a graph event, which will be set anytime a graph change occurs.
   /**
@@ -123,9 +106,7 @@ public:
    * out of scope.
    */
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Event::SharedPtr
-  get_graph_event() = 0;
+  virtual rclcpp::Event::SharedPtr get_graph_event() = 0;
 
   /// Wait for a graph event to occur by waiting on an Event to become set.
   /**
@@ -136,20 +117,15 @@ public:
    *   get_graph_event().
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  wait_for_graph_change(
-    rclcpp::Event::SharedPtr event,
-    std::chrono::nanoseconds timeout) = 0;
+  virtual void wait_for_graph_change(
+    rclcpp::Event::SharedPtr event, std::chrono::nanoseconds timeout) = 0;
 
   /// Return the number of on loan graph events, see get_graph_event().
   /**
    * This is typically only used by the rclcpp::graph_listener::GraphListener.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  count_graph_users() = 0;
+  virtual size_t count_graph_users() = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_logging.hpp

@@ -38,18 +38,13 @@ public:
   explicit NodeLogging(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeLogging();
+  virtual ~NodeLogging();
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Logger
-  get_logger() const;
+  virtual rclcpp::Logger get_logger() const;
 
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_logger_name() const;
+  virtual const char * get_logger_name() const;
 
 private:
   RCLCPP_DISABLE_COPY(NodeLogging)

rclcpp/include/rclcpp/node_interfaces/node_logging_interface.hpp

@@ -34,22 +34,17 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeLoggingInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeLoggingInterface() = default;
+  virtual ~NodeLoggingInterface() = default;
 
   /// Return the logger of the node.
   /** \return The logger of the node. */
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Logger
-  get_logger() const = 0;
+  virtual rclcpp::Logger get_logger() const = 0;
 
   /// Return the logger name associated with the node.
   /** \return The logger name associated with the node. */
   RCLCPP_PUBLIC
-  virtual
-  const char *
-  get_logger_name() const = 0;
+  virtual const char * get_logger_name() const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -15,9 +15,9 @@
 #ifndef RCLCPP__NODE_INTERFACES__NODE_PARAMETERS_HPP_
 #define RCLCPP__NODE_INTERFACES__NODE_PARAMETERS_HPP_
 
+#include <list>
 #include <map>
 #include <memory>
-#include <list>
 #include <string>
 #include <vector>
 
@@ -55,21 +55,17 @@ struct ParameterInfo
 class ParameterMutationRecursionGuard
 {
 public:
-  explicit ParameterMutationRecursionGuard(bool & allow_mod)
-  : allow_modification_(allow_mod)
+  explicit ParameterMutationRecursionGuard(bool & allow_mod) : allow_modification_(allow_mod)
   {
     if (!allow_modification_) {
       throw rclcpp::exceptions::ParameterModifiedInCallbackException(
-              "cannot set or declare a parameter, or change the callback from within set callback");
+        "cannot set or declare a parameter, or change the callback from within set callback");
     }
 
     allow_modification_ = false;
   }
 
-  ~ParameterMutationRecursionGuard()
-  {
-    allow_modification_ = true;
-  }
+  ~ParameterMutationRecursionGuard() { allow_modification_ = true; }
 
 private:
   bool & allow_modification_;
@@ -88,96 +84,77 @@ public:
     const node_interfaces::NodeTopicsInterface::SharedPtr node_topics,
     const node_interfaces::NodeServicesInterface::SharedPtr node_services,
     const node_interfaces::NodeClockInterface::SharedPtr node_clock,
-    const std::vector<Parameter> & parameter_overrides,
-    bool start_parameter_services,
-    bool start_parameter_event_publisher,
-    const rclcpp::QoS & parameter_event_qos,
+    const std::vector<Parameter> & parameter_overrides, bool start_parameter_services,
+    bool start_parameter_event_publisher, const rclcpp::QoS & parameter_event_qos,
     const rclcpp::PublisherOptionsBase & parameter_event_publisher_options,
-    bool allow_undeclared_parameters,
-    bool automatically_declare_parameters_from_overrides);
+    bool allow_undeclared_parameters, bool automatically_declare_parameters_from_overrides);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeParameters();
+  virtual ~NodeParameters();
 
   RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  declare_parameter(
-    const std::string & name,
-    const rclcpp::ParameterValue & default_value,
+  const rclcpp::ParameterValue & declare_parameter(
+    const std::string & name, const rclcpp::ParameterValue & default_value,
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
     bool ignore_override) override;
 
   RCLCPP_PUBLIC
-  void
-  undeclare_parameter(const std::string & name) override;
+  void undeclare_parameter(const std::string & name) override;
 
   RCLCPP_PUBLIC
-  bool
-  has_parameter(const std::string & name) const override;
+  bool has_parameter(const std::string & name) const override;
 
   RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(
+  std::vector<rcl_interfaces::msg::SetParametersResult> set_parameters(
     const std::vector<rclcpp::Parameter> & parameters) override;
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(
+  rcl_interfaces::msg::SetParametersResult set_parameters_atomically(
     const std::vector<rclcpp::Parameter> & parameters) override;
 
   RCLCPP_PUBLIC
-  std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & names) const override;
+  std::vector<rclcpp::Parameter> get_parameters(
+    const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  rclcpp::Parameter
-  get_parameter(const std::string & name) const override;
+  rclcpp::Parameter get_parameter(const std::string & name) const override;
 
   RCLCPP_PUBLIC
-  bool
-  get_parameter(
-    const std::string & name,
-    rclcpp::Parameter & parameter) const override;
+  bool get_parameter(const std::string & name, rclcpp::Parameter & parameter) const override;
 
   RCLCPP_PUBLIC
-  bool
-  get_parameters_by_prefix(
+  bool get_parameters_by_prefix(
     const std::string & prefix,
     std::map<std::string, rclcpp::Parameter> & parameters) const override;
 
   RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(const std::vector<std::string> & names) const override;
+  std::vector<rcl_interfaces::msg::ParameterDescriptor> describe_parameters(
+    const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  std::vector<uint8_t>
-  get_parameter_types(const std::vector<std::string> & names) const override;
+  std::vector<uint8_t> get_parameter_types(const std::vector<std::string> & names) const override;
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ListParametersResult
-  list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const override;
+  rcl_interfaces::msg::ListParametersResult list_parameters(
+    const std::vector<std::string> & prefixes, uint64_t depth) const override;
 
   RCLCPP_PUBLIC
-  OnSetParametersCallbackHandle::SharedPtr
-  add_on_set_parameters_callback(OnParametersSetCallbackType callback) override;
+  OnSetParametersCallbackHandle::SharedPtr add_on_set_parameters_callback(
+    OnParametersSetCallbackType callback) override;
 
   RCLCPP_PUBLIC
-  void
-  remove_on_set_parameters_callback(const OnSetParametersCallbackHandle * const handler) override;
+  void remove_on_set_parameters_callback(
+    const OnSetParametersCallbackHandle * const handler) override;
 
   RCLCPP_PUBLIC
-  OnParametersSetCallbackType
-  set_on_parameters_set_callback(OnParametersSetCallbackType callback) override;
+  OnParametersSetCallbackType set_on_parameters_set_callback(
+    OnParametersSetCallbackType callback) override;
 
-  [[deprecated("use set_on_parameters_set_callback() instead")]]
-  RCLCPP_PUBLIC
-  void
+  [[deprecated("use set_on_parameters_set_callback() instead")]] RCLCPP_PUBLIC void
   register_param_change_callback(OnParametersSetCallbackType callback) override;
 
   RCLCPP_PUBLIC
-  const std::map<std::string, rclcpp::ParameterValue> &
-  get_parameter_overrides() const override;
+  const std::map<std::string, rclcpp::ParameterValue> & get_parameter_overrides() const override;
 
   using CallbacksContainerType = std::list<OnSetParametersCallbackHandle::WeakPtr>;
 

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -38,9 +38,7 @@ struct OnSetParametersCallbackHandle
   RCLCPP_SMART_PTR_DEFINITIONS(OnSetParametersCallbackHandle)
 
   using OnParametersSetCallbackType =
-    std::function<
-    rcl_interfaces::msg::SetParametersResult(
-      const std::vector<rclcpp::Parameter> &)>;
+    std::function<rcl_interfaces::msg::SetParametersResult(const std::vector<rclcpp::Parameter> &)>;
 
   OnParametersSetCallbackType callback;
 };
@@ -52,21 +50,18 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeParametersInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeParametersInterface() = default;
+  virtual ~NodeParametersInterface() = default;
 
   /// Declare and initialize a parameter.
   /**
    * \sa rclcpp::Node::declare_parameter
    */
   RCLCPP_PUBLIC
-  virtual
-  const rclcpp::ParameterValue &
-  declare_parameter(
+  virtual const rclcpp::ParameterValue & declare_parameter(
     const std::string & name,
     const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
-    rcl_interfaces::msg::ParameterDescriptor(),
+      rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false) = 0;
 
   /// Undeclare a parameter.
@@ -74,36 +69,29 @@ public:
    * \sa rclcpp::Node::undeclare_parameter
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  undeclare_parameter(const std::string & name) = 0;
+  virtual void undeclare_parameter(const std::string & name) = 0;
 
   /// Return true if the parameter has been declared, otherwise false.
   /**
    * \sa rclcpp::Node::has_parameter
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  has_parameter(const std::string & name) const = 0;
+  virtual bool has_parameter(const std::string & name) const = 0;
 
   /// Set one or more parameters, one at a time.
   /**
    * \sa rclcpp::Node::set_parameters
    */
   RCLCPP_PUBLIC
-  virtual
-  std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(const std::vector<rclcpp::Parameter> & parameters) = 0;
+  virtual std::vector<rcl_interfaces::msg::SetParametersResult> set_parameters(
+    const std::vector<rclcpp::Parameter> & parameters) = 0;
 
   /// Set and initialize a parameter, all at once.
   /**
    * \sa rclcpp::Node::set_parameters_atomically
    */
   RCLCPP_PUBLIC
-  virtual
-  rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(
+  virtual rcl_interfaces::msg::SetParametersResult set_parameters_atomically(
     const std::vector<rclcpp::Parameter> & parameters) = 0;
 
   /// Get descriptions of parameters given their names.
@@ -113,9 +101,8 @@ public:
    * Any parameter not found is omitted from the returned list.
    */
   RCLCPP_PUBLIC
-  virtual
-  std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & names) const = 0;
+  virtual std::vector<rclcpp::Parameter> get_parameters(
+    const std::vector<std::string> & names) const = 0;
 
   /// Get the description of one parameter given a name.
   /*
@@ -124,9 +111,7 @@ public:
    * \throws std::out_of_range if the parameter does not exist on the node.
    */
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::Parameter
-  get_parameter(const std::string & name) const = 0;
+  virtual rclcpp::Parameter get_parameter(const std::string & name) const = 0;
 
   /// Get the description of one parameter given a name.
   /*
@@ -136,11 +121,7 @@ public:
    * \return false if the parameter does not exist.
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  get_parameter(
-    const std::string & name,
-    rclcpp::Parameter & parameter) const = 0;
+  virtual bool get_parameter(const std::string & name, rclcpp::Parameter & parameter) const = 0;
 
   /// Get all parameters that have the specified prefix into the parameters map.
   /*
@@ -150,30 +131,24 @@ public:
    * \return false otherwise.
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  get_parameters_by_prefix(
-    const std::string & prefix,
-    std::map<std::string, rclcpp::Parameter> & parameters) const = 0;
+  virtual bool get_parameters_by_prefix(
+    const std::string & prefix, std::map<std::string, rclcpp::Parameter> & parameters) const = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  std::vector<rcl_interfaces::msg::ParameterDescriptor>
-  describe_parameters(const std::vector<std::string> & names) const = 0;
+  virtual std::vector<rcl_interfaces::msg::ParameterDescriptor> describe_parameters(
+    const std::vector<std::string> & names) const = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  std::vector<uint8_t>
-  get_parameter_types(const std::vector<std::string> & names) const = 0;
+  virtual std::vector<uint8_t> get_parameter_types(
+    const std::vector<std::string> & names) const = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  rcl_interfaces::msg::ListParametersResult
-  list_parameters(const std::vector<std::string> & prefixes, uint64_t depth) const = 0;
+  virtual rcl_interfaces::msg::ListParametersResult list_parameters(
+    const std::vector<std::string> & prefixes, uint64_t depth) const = 0;
 
   using OnParametersSetCallbackType = OnSetParametersCallbackHandle::OnParametersSetCallbackType;
 
-  using ParametersCallbackFunction [[deprecated("use OnParametersSetCallbackType instead")]] =
+  using ParametersCallbackFunction[[deprecated("use OnParametersSetCallbackType instead")]] =
     OnParametersSetCallbackType;
 
   /// Add a callback for when parameters are being set.
@@ -181,39 +156,31 @@ public:
    * \sa rclcpp::Node::add_on_set_parameters_callback
    */
   RCLCPP_PUBLIC
-  virtual
-  OnSetParametersCallbackHandle::SharedPtr
-  add_on_set_parameters_callback(OnParametersSetCallbackType callback) = 0;
+  virtual OnSetParametersCallbackHandle::SharedPtr add_on_set_parameters_callback(
+    OnParametersSetCallbackType callback) = 0;
 
   /// Remove a callback registered with `add_on_set_parameters_callback`.
   /**
    * \sa rclcpp::Node::remove_on_set_parameters_callback
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  remove_on_set_parameters_callback(const OnSetParametersCallbackHandle * const handler) = 0;
+  virtual void remove_on_set_parameters_callback(
+    const OnSetParametersCallbackHandle * const handler) = 0;
 
   /// Register a callback for when parameters are being set, return an existing one.
   /**
    * \sa rclcpp::Node::set_on_parameters_set_callback
    */
   RCLCPP_PUBLIC
-  virtual
-  OnParametersSetCallbackType
-  set_on_parameters_set_callback(OnParametersSetCallbackType callback) = 0;
+  virtual OnParametersSetCallbackType set_on_parameters_set_callback(
+    OnParametersSetCallbackType callback) = 0;
 
-  [[deprecated("use set_on_parameters_set_callback() instead")]]
-  RCLCPP_PUBLIC
-  virtual
-  void
+  [[deprecated("use set_on_parameters_set_callback() instead")]] RCLCPP_PUBLIC virtual void
   register_param_change_callback(OnParametersSetCallbackType callback) = 0;
 
   /// Return the initial parameter values used by the NodeParameters to override default values.
   RCLCPP_PUBLIC
-  virtual
-  const std::map<std::string, rclcpp::ParameterValue> &
-  get_parameter_overrides() const = 0;
+  virtual const std::map<std::string, rclcpp::ParameterValue> & get_parameter_overrides() const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_services.hpp

@@ -38,20 +38,15 @@ public:
   explicit NodeServices(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeServices();
+  virtual ~NodeServices();
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_client(
+  virtual void add_client(
     rclcpp::ClientBase::SharedPtr client_base_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group);
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_service(
+  virtual void add_service(
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group);
 

rclcpp/include/rclcpp/node_interfaces/node_services_interface.hpp

@@ -33,20 +33,15 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeServicesInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeServicesInterface() = default;
+  virtual ~NodeServicesInterface() = default;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_client(
+  virtual void add_client(
     rclcpp::ClientBase::SharedPtr client_base_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group) = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_service(
+  virtual void add_service(
     rclcpp::ServiceBase::SharedPtr service_base_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group) = 0;
 };

rclcpp/include/rclcpp/node_interfaces/node_time_source.hpp

@@ -45,12 +45,10 @@ public:
     rclcpp::node_interfaces::NodeServicesInterface::SharedPtr node_services,
     rclcpp::node_interfaces::NodeLoggingInterface::SharedPtr node_logging,
     rclcpp::node_interfaces::NodeClockInterface::SharedPtr node_clock,
-    rclcpp::node_interfaces::NodeParametersInterface::SharedPtr node_parameters
-  );
+    rclcpp::node_interfaces::NodeParametersInterface::SharedPtr node_parameters);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeTimeSource();
+  virtual ~NodeTimeSource();
 
 private:
   RCLCPP_DISABLE_COPY(NodeTimeSource)

rclcpp/include/rclcpp/node_interfaces/node_time_source_interface.hpp

@@ -32,8 +32,7 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeTimeSourceInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeTimeSourceInterface() = default;
+  virtual ~NodeTimeSourceInterface() = default;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_timers.hpp

@@ -37,14 +37,11 @@ public:
   explicit NodeTimers(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeTimers();
+  virtual ~NodeTimers();
 
   /// Add a timer to the node.
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_timer(
+  virtual void add_timer(
     rclcpp::TimerBase::SharedPtr timer,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group);
 

rclcpp/include/rclcpp/node_interfaces/node_timers_interface.hpp

@@ -32,14 +32,11 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeTimersInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeTimersInterface() = default;
+  virtual ~NodeTimersInterface() = default;
 
   /// Add a timer to the node.
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_timer(
+  virtual void add_timer(
     rclcpp::TimerBase::SharedPtr timer,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group) = 0;
 };

rclcpp/include/rclcpp/node_interfaces/node_topics.hpp

@@ -45,36 +45,27 @@ public:
   ~NodeTopics() override;
 
   RCLCPP_PUBLIC
-  rclcpp::PublisherBase::SharedPtr
-  create_publisher(
-    const std::string & topic_name,
-    const rclcpp::PublisherFactory & publisher_factory,
-    const rcl_publisher_options_t & publisher_options,
-    bool use_intra_process) override;
+  rclcpp::PublisherBase::SharedPtr create_publisher(
+    const std::string & topic_name, const rclcpp::PublisherFactory & publisher_factory,
+    const rcl_publisher_options_t & publisher_options, bool use_intra_process) override;
 
   RCLCPP_PUBLIC
-  void
-  add_publisher(
+  void add_publisher(
     rclcpp::PublisherBase::SharedPtr publisher,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group) override;
 
   RCLCPP_PUBLIC
-  rclcpp::SubscriptionBase::SharedPtr
-  create_subscription(
-    const std::string & topic_name,
-    const rclcpp::SubscriptionFactory & subscription_factory,
-    const rcl_subscription_options_t & subscription_options,
-    bool use_intra_process) override;
+  rclcpp::SubscriptionBase::SharedPtr create_subscription(
+    const std::string & topic_name, const rclcpp::SubscriptionFactory & subscription_factory,
+    const rcl_subscription_options_t & subscription_options, bool use_intra_process) override;
 
   RCLCPP_PUBLIC
-  void
-  add_subscription(
+  void add_subscription(
     rclcpp::SubscriptionBase::SharedPtr subscription,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group) override;
 
   RCLCPP_PUBLIC
-  rclcpp::node_interfaces::NodeBaseInterface *
-  get_node_base_interface() const override;
+  rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface() const override;
 
 private:
   RCLCPP_DISABLE_COPY(NodeTopics)

rclcpp/include/rclcpp/node_interfaces/node_topics_interface.hpp

@@ -41,45 +41,30 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeTopicsInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeTopicsInterface() = default;
+  virtual ~NodeTopicsInterface() = default;
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::PublisherBase::SharedPtr
-  create_publisher(
-    const std::string & topic_name,
-    const rclcpp::PublisherFactory & publisher_factory,
-    const rcl_publisher_options_t & publisher_options,
-    bool use_intra_process) = 0;
+  virtual rclcpp::PublisherBase::SharedPtr create_publisher(
+    const std::string & topic_name, const rclcpp::PublisherFactory & publisher_factory,
+    const rcl_publisher_options_t & publisher_options, bool use_intra_process) = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_publisher(
+  virtual void add_publisher(
     rclcpp::PublisherBase::SharedPtr publisher,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group) = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::SubscriptionBase::SharedPtr
-  create_subscription(
-    const std::string & topic_name,
-    const rclcpp::SubscriptionFactory & subscription_factory,
-    const rcl_subscription_options_t & subscription_options,
-    bool use_intra_process) = 0;
+  virtual rclcpp::SubscriptionBase::SharedPtr create_subscription(
+    const std::string & topic_name, const rclcpp::SubscriptionFactory & subscription_factory,
+    const rcl_subscription_options_t & subscription_options, bool use_intra_process) = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_subscription(
+  virtual void add_subscription(
     rclcpp::SubscriptionBase::SharedPtr subscription,
     rclcpp::callback_group::CallbackGroup::SharedPtr callback_group) = 0;
 
   RCLCPP_PUBLIC
-  virtual
-  rclcpp::node_interfaces::NodeBaseInterface *
-  get_node_base_interface() const = 0;
+  virtual rclcpp::node_interfaces::NodeBaseInterface * get_node_base_interface() const = 0;
 };
 
 }  // namespace node_interfaces

rclcpp/include/rclcpp/node_interfaces/node_waitables.hpp

@@ -20,8 +20,8 @@
 #include "rclcpp/macros.hpp"
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
 #include "rclcpp/node_interfaces/node_waitables_interface.hpp"
-#include "rclcpp/waitable.hpp"
 #include "rclcpp/visibility_control.hpp"
+#include "rclcpp/waitable.hpp"
 
 namespace rclcpp
 {
@@ -38,20 +38,15 @@ public:
   explicit NodeWaitables(rclcpp::node_interfaces::NodeBaseInterface * node_base);
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeWaitables();
+  virtual ~NodeWaitables();
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_waitable(
+  virtual void add_waitable(
     rclcpp::Waitable::SharedPtr waitable_base_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group);
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  remove_waitable(
+  virtual void remove_waitable(
     rclcpp::Waitable::SharedPtr waitable_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group) noexcept;
 

rclcpp/include/rclcpp/node_interfaces/node_waitables_interface.hpp

@@ -32,21 +32,16 @@ public:
   RCLCPP_SMART_PTR_ALIASES_ONLY(NodeWaitablesInterface)
 
   RCLCPP_PUBLIC
-  virtual
-  ~NodeWaitablesInterface() = default;
+  virtual ~NodeWaitablesInterface() = default;
 
   RCLCPP_PUBLIC
-  virtual
-  void
-  add_waitable(
+  virtual void add_waitable(
     rclcpp::Waitable::SharedPtr waitable_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group) = 0;
 
   /// \note this function should not throw because it may be called in destructors
   RCLCPP_PUBLIC
-  virtual
-  void
-  remove_waitable(
+  virtual void remove_waitable(
     rclcpp::Waitable::SharedPtr waitable_ptr,
     rclcpp::callback_group::CallbackGroup::SharedPtr group) noexcept = 0;
 };

rclcpp/include/rclcpp/node_options.hpp

@@ -59,8 +59,7 @@ public:
 
   /// Destructor.
   RCLCPP_PUBLIC
-  virtual
-  ~NodeOptions() = default;
+  virtual ~NodeOptions() = default;
 
   /// Copy constructor.
   RCLCPP_PUBLIC
@@ -68,8 +67,7 @@ public:
 
   /// Assignment operator.
   RCLCPP_PUBLIC
-  NodeOptions &
-  operator=(const NodeOptions & other);
+  NodeOptions & operator=(const NodeOptions & other);
 
   /// Return the rcl_node_options used by the node.
   /**
@@ -78,23 +76,19 @@ public:
    * changed, like arguments, use_global_arguments, or the rcl allocator.
    */
   RCLCPP_PUBLIC
-  const rcl_node_options_t *
-  get_rcl_node_options() const;
+  const rcl_node_options_t * get_rcl_node_options() const;
 
   /// Return the context to be used by the node.
   RCLCPP_PUBLIC
-  rclcpp::Context::SharedPtr
-  context() const;
+  rclcpp::Context::SharedPtr context() const;
 
   /// Set the context, return this for parameter idiom.
   RCLCPP_PUBLIC
-  NodeOptions &
-  context(rclcpp::Context::SharedPtr context);
+  NodeOptions & context(rclcpp::Context::SharedPtr context);
 
   /// Return a reference to the list of arguments for the node.
   RCLCPP_PUBLIC
-  const std::vector<std::string> &
-  arguments() const;
+  const std::vector<std::string> & arguments() const;
 
   /// Set the arguments, return this for parameter idiom.
   /**
@@ -104,17 +98,14 @@ public:
    * This will cause the internal rcl_node_options_t struct to be invalidated.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  arguments(const std::vector<std::string> & arguments);
+  NodeOptions & arguments(const std::vector<std::string> & arguments);
 
   /// Return a reference to the list of parameter overrides.
   RCLCPP_PUBLIC
-  std::vector<rclcpp::Parameter> &
-  parameter_overrides();
+  std::vector<rclcpp::Parameter> & parameter_overrides();
 
   RCLCPP_PUBLIC
-  const std::vector<rclcpp::Parameter> &
-  parameter_overrides() const;
+  const std::vector<rclcpp::Parameter> & parameter_overrides() const;
 
   /// Set the parameters overrides, return this for parameter idiom.
   /**
@@ -123,13 +114,11 @@ public:
    * values if necessary.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  parameter_overrides(const std::vector<rclcpp::Parameter> & parameter_overrides);
+  NodeOptions & parameter_overrides(const std::vector<rclcpp::Parameter> & parameter_overrides);
 
   /// Append a single parameter override, parameter idiom style.
-  template<typename ParameterT>
-  NodeOptions &
-  append_parameter_override(const std::string & name, const ParameterT & value)
+  template <typename ParameterT>
+  NodeOptions & append_parameter_override(const std::string & name, const ParameterT & value)
   {
     this->parameter_overrides().emplace_back(name, rclcpp::ParameterValue(value));
     return *this;
@@ -137,8 +126,7 @@ public:
 
   /// Return the use_global_arguments flag.
   RCLCPP_PUBLIC
-  bool
-  use_global_arguments() const;
+  bool use_global_arguments() const;
 
   /// Set the use_global_arguments flag, return this for parameter idiom.
   /**
@@ -149,13 +137,11 @@ public:
    * This will cause the internal rcl_node_options_t struct to be invalidated.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  use_global_arguments(bool use_global_arguments);
+  NodeOptions & use_global_arguments(bool use_global_arguments);
 
   /// Return the use_intra_process_comms flag.
   RCLCPP_PUBLIC
-  bool
-  use_intra_process_comms() const;
+  bool use_intra_process_comms() const;
 
   /// Set the use_intra_process_comms flag, return this for parameter idiom.
   /**
@@ -168,13 +154,11 @@ public:
    * desirable.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  use_intra_process_comms(bool use_intra_process_comms);
+  NodeOptions & use_intra_process_comms(bool use_intra_process_comms);
 
   /// Return the start_parameter_services flag.
   RCLCPP_PUBLIC
-  bool
-  start_parameter_services() const;
+  bool start_parameter_services() const;
 
   /// Set the start_parameter_services flag, return this for parameter idiom.
   /**
@@ -187,13 +171,11 @@ public:
    * \sa start_parameter_event_publisher()
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  start_parameter_services(bool start_parameter_services);
+  NodeOptions & start_parameter_services(bool start_parameter_services);
 
   /// Return the start_parameter_event_publisher flag.
   RCLCPP_PUBLIC
-  bool
-  start_parameter_event_publisher() const;
+  bool start_parameter_event_publisher() const;
 
   /// Set the start_parameter_event_publisher flag, return this for parameter idiom.
   /**
@@ -203,26 +185,22 @@ public:
    * separately from the other parameter services.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  start_parameter_event_publisher(bool start_parameter_event_publisher);
+  NodeOptions & start_parameter_event_publisher(bool start_parameter_event_publisher);
 
   /// Return a reference to the parameter_event_qos QoS.
   RCLCPP_PUBLIC
-  const rclcpp::QoS &
-  parameter_event_qos() const;
+  const rclcpp::QoS & parameter_event_qos() const;
 
   /// Set the parameter_event_qos QoS, return this for parameter idiom.
   /**
    * The QoS settings to be used for the parameter event publisher, if enabled.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  parameter_event_qos(const rclcpp::QoS & parameter_event_qos);
+  NodeOptions & parameter_event_qos(const rclcpp::QoS & parameter_event_qos);
 
   /// Return a reference to the parameter_event_publisher_options.
   RCLCPP_PUBLIC
-  const rclcpp::PublisherOptionsBase &
-  parameter_event_publisher_options() const;
+  const rclcpp::PublisherOptionsBase & parameter_event_publisher_options() const;
 
   /// Set the parameter_event_publisher_options, return this for parameter idiom.
   /**
@@ -233,14 +211,12 @@ public:
    *   NodeOptions to also be templated based on the Allocator type.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  parameter_event_publisher_options(
+  NodeOptions & parameter_event_publisher_options(
     const rclcpp::PublisherOptionsBase & parameter_event_publisher_options);
 
   /// Return the allow_undeclared_parameters flag.
   RCLCPP_PUBLIC
-  bool
-  allow_undeclared_parameters() const;
+  bool allow_undeclared_parameters() const;
 
   /// Set the allow_undeclared_parameters, return this for parameter idiom.
   /**
@@ -253,13 +229,11 @@ public:
    * any parameter overrides.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  allow_undeclared_parameters(bool allow_undeclared_parameters);
+  NodeOptions & allow_undeclared_parameters(bool allow_undeclared_parameters);
 
   /// Return the automatically_declare_parameters_from_overrides flag.
   RCLCPP_PUBLIC
-  bool
-  automatically_declare_parameters_from_overrides() const;
+  bool automatically_declare_parameters_from_overrides() const;
 
   /// Set the automatically_declare_parameters_from_overrides, return this.
   /**
@@ -273,27 +247,23 @@ public:
    * declared in this way will use the default constructed ParameterDescriptor.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  automatically_declare_parameters_from_overrides(
+  NodeOptions & automatically_declare_parameters_from_overrides(
     bool automatically_declare_parameters_from_overrides);
 
   /// Return the rcl_allocator_t to be used.
   RCLCPP_PUBLIC
-  const rcl_allocator_t &
-  allocator() const;
+  const rcl_allocator_t & allocator() const;
 
   /// Set the rcl_allocator_t to be used, may cause deallocation of existing rcl_node_options_t.
   /**
    * This will cause the internal rcl_node_options_t struct to be invalidated.
    */
   RCLCPP_PUBLIC
-  NodeOptions &
-  allocator(rcl_allocator_t allocator);
+  NodeOptions & allocator(rcl_allocator_t allocator);
 
 protected:
   /// Retrieve the ROS_DOMAIN_ID environment variable and populate options.
-  size_t
-  get_domain_id_from_env() const;
+  size_t get_domain_id_from_env() const;
 
 private:
   // This is mutable to allow for a const accessor which lazily creates the node options instance.
@@ -303,32 +273,31 @@ private:
   // IMPORTANT: if any of these default values are changed, please update the
   // documentation in this class.
 
-  rclcpp::Context::SharedPtr context_ {
+  rclcpp::Context::SharedPtr context_{
     rclcpp::contexts::default_context::get_global_default_context()};
 
-  std::vector<std::string> arguments_ {};
+  std::vector<std::string> arguments_{};
 
-  std::vector<rclcpp::Parameter> parameter_overrides_ {};
+  std::vector<rclcpp::Parameter> parameter_overrides_{};
 
-  bool use_global_arguments_ {true};
+  bool use_global_arguments_{true};
 
-  bool use_intra_process_comms_ {false};
+  bool use_intra_process_comms_{false};
 
-  bool start_parameter_services_ {true};
+  bool start_parameter_services_{true};
 
-  bool start_parameter_event_publisher_ {true};
+  bool start_parameter_event_publisher_{true};
 
   rclcpp::QoS parameter_event_qos_ = rclcpp::ParameterEventsQoS(
-    rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)
-  );
+    rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events));
 
   rclcpp::PublisherOptionsBase parameter_event_publisher_options_ = rclcpp::PublisherOptionsBase();
 
-  bool allow_undeclared_parameters_ {false};
+  bool allow_undeclared_parameters_{false};
 
-  bool automatically_declare_parameters_from_overrides_ {false};
+  bool automatically_declare_parameters_from_overrides_{false};
 
-  rcl_allocator_t allocator_ {rcl_get_default_allocator()};
+  rcl_allocator_t allocator_{rcl_get_default_allocator()};
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/parameter.hpp

@@ -41,9 +41,8 @@ namespace detail
 // This helper function is required because you cannot do specialization on a
 // class method, so instead we specialize this template function and call it
 // from the unspecialized, but dependent, class method.
-template<typename T>
-auto
-get_value_helper(const rclcpp::Parameter * parameter);
+template <typename T>
+auto get_value_helper(const rclcpp::Parameter * parameter);
 
 }  // namespace detail
 
@@ -64,105 +63,84 @@ public:
   Parameter(const std::string & name, const ParameterValue & value);
 
   /// Construct with given name and given parameter value.
-  template<typename ValueTypeT>
-  Parameter(const std::string & name, ValueTypeT value)
-  : Parameter(name, ParameterValue(value))
-  {}
+  template <typename ValueTypeT>
+  Parameter(const std::string & name, ValueTypeT value) : Parameter(name, ParameterValue(value))
+  {
+  }
 
   RCLCPP_PUBLIC
   explicit Parameter(const rclcpp::node_interfaces::ParameterInfo & parameter_info);
 
   /// Equal operator.
   RCLCPP_PUBLIC
-  bool
-  operator==(const Parameter & rhs) const;
+  bool operator==(const Parameter & rhs) const;
 
   /// Not equal operator.
   RCLCPP_PUBLIC
-  bool
-  operator!=(const Parameter & rhs) const;
+  bool operator!=(const Parameter & rhs) const;
 
   RCLCPP_PUBLIC
-  ParameterType
-  get_type() const;
+  ParameterType get_type() const;
 
   RCLCPP_PUBLIC
-  std::string
-  get_type_name() const;
+  std::string get_type_name() const;
 
   RCLCPP_PUBLIC
-  const std::string &
-  get_name() const;
+  const std::string & get_name() const;
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ParameterValue
-  get_value_message() const;
+  rcl_interfaces::msg::ParameterValue get_value_message() const;
 
   /// Get the internal storage for the parameter value.
   RCLCPP_PUBLIC
-  const rclcpp::ParameterValue &
-  get_parameter_value() const;
+  const rclcpp::ParameterValue & get_parameter_value() const;
 
   /// Get value of parameter using rclcpp::ParameterType as template argument.
-  template<ParameterType ParamT>
-  decltype(auto)
-  get_value() const
+  template <ParameterType ParamT>
+  decltype(auto) get_value() const
   {
     return value_.get<ParamT>();
   }
 
   /// Get value of parameter using c++ types as template argument.
-  template<typename T>
-  decltype(auto)
-  get_value() const;
+  template <typename T>
+  decltype(auto) get_value() const;
 
   RCLCPP_PUBLIC
-  bool
-  as_bool() const;
+  bool as_bool() const;
 
   RCLCPP_PUBLIC
-  int64_t
-  as_int() const;
+  int64_t as_int() const;
 
   RCLCPP_PUBLIC
-  double
-  as_double() const;
+  double as_double() const;
 
   RCLCPP_PUBLIC
-  const std::string &
-  as_string() const;
+  const std::string & as_string() const;
 
   RCLCPP_PUBLIC
-  const std::vector<uint8_t> &
-  as_byte_array() const;
+  const std::vector<uint8_t> & as_byte_array() const;
 
   RCLCPP_PUBLIC
-  const std::vector<bool> &
-  as_bool_array() const;
+  const std::vector<bool> & as_bool_array() const;
 
   RCLCPP_PUBLIC
-  const std::vector<int64_t> &
-  as_integer_array() const;
+  const std::vector<int64_t> & as_integer_array() const;
 
   RCLCPP_PUBLIC
-  const std::vector<double> &
-  as_double_array() const;
+  const std::vector<double> & as_double_array() const;
 
   RCLCPP_PUBLIC
-  const std::vector<std::string> &
-  as_string_array() const;
+  const std::vector<std::string> & as_string_array() const;
 
   RCLCPP_PUBLIC
-  static Parameter
-  from_parameter_msg(const rcl_interfaces::msg::Parameter & parameter);
+  static Parameter from_parameter_msg(const rcl_interfaces::msg::Parameter & parameter);
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::Parameter
-  to_parameter_msg() const;
+  rcl_interfaces::msg::Parameter to_parameter_msg() const;
 
   RCLCPP_PUBLIC
-  std::string
-  value_to_string() const;
+  std::string value_to_string() const;
 
 private:
   std::string name_;
@@ -171,55 +149,43 @@ private:
 
 /// Return a json encoded version of the parameter intended for a dict.
 RCLCPP_PUBLIC
-std::string
-_to_json_dict_entry(const Parameter & param);
+std::string _to_json_dict_entry(const Parameter & param);
 
 RCLCPP_PUBLIC
-std::ostream &
-operator<<(std::ostream & os, const rclcpp::Parameter & pv);
+std::ostream & operator<<(std::ostream & os, const rclcpp::Parameter & pv);
 
 RCLCPP_PUBLIC
-std::ostream &
-operator<<(std::ostream & os, const std::vector<Parameter> & parameters);
+std::ostream & operator<<(std::ostream & os, const std::vector<Parameter> & parameters);
 
 namespace detail
 {
 
-template<typename T>
-auto
-get_value_helper(const rclcpp::Parameter * parameter)
+template <typename T>
+auto get_value_helper(const rclcpp::Parameter * parameter)
 {
   return parameter->get_parameter_value().get<T>();
 }
 
 // Specialization allowing Parameter::get() to return a const ref to the parameter value object.
-template<>
-inline
-auto
-get_value_helper<rclcpp::ParameterValue>(const rclcpp::Parameter * parameter)
+template <>
+inline auto get_value_helper<rclcpp::ParameterValue>(const rclcpp::Parameter * parameter)
 {
   return parameter->get_parameter_value();
 }
 
 // Specialization allowing Parameter::get() to return a const ref to the parameter itself.
-template<>
-inline
-auto
-get_value_helper<rclcpp::Parameter>(const rclcpp::Parameter * parameter)
+template <>
+inline auto get_value_helper<rclcpp::Parameter>(const rclcpp::Parameter * parameter)
 {
   // Use this lambda to ensure it's a const reference being returned (and not a copy).
-  auto type_enforcing_lambda =
-    [&parameter]() -> const rclcpp::Parameter & {
-      return *parameter;
-    };
+  auto type_enforcing_lambda = [&parameter]() -> const rclcpp::Parameter & { return *parameter; };
   return type_enforcing_lambda();
 }
 
 }  // namespace detail
 
-template<typename T>
-decltype(auto)
-Parameter::get_value() const
+template <typename T>
+decltype(auto) Parameter::get_value() const
 {
   // use the helper to specialize for the ParameterValue and Parameter cases.
   return detail::get_value_helper<T>(this);
@@ -232,13 +198,11 @@ namespace std
 
 /// Return a json encoded version of the parameter intended for a list.
 RCLCPP_PUBLIC
-std::string
-to_string(const rclcpp::Parameter & param);
+std::string to_string(const rclcpp::Parameter & param);
 
 /// Return a json encoded version of a vector of parameters, as a string.
 RCLCPP_PUBLIC
-std::string
-to_string(const std::vector<rclcpp::Parameter> & parameters);
+std::string to_string(const std::vector<rclcpp::Parameter> & parameters);
 
 }  // namespace std
 

rclcpp/include/rclcpp/parameter_client.hpp

@@ -29,8 +29,8 @@
 #include "rcl_interfaces/srv/list_parameters.hpp"
 #include "rcl_interfaces/srv/set_parameters.hpp"
 #include "rcl_interfaces/srv/set_parameters_atomically.hpp"
-#include "rclcpp/executors.hpp"
 #include "rclcpp/create_subscription.hpp"
+#include "rclcpp/executors.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/node.hpp"
 #include "rclcpp/parameter.hpp"
@@ -58,77 +58,53 @@ public:
 
   RCLCPP_PUBLIC
   AsyncParametersClient(
-    const rclcpp::Node::SharedPtr node,
-    const std::string & remote_node_name = "",
+    const rclcpp::Node::SharedPtr node, const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
   RCLCPP_PUBLIC
   AsyncParametersClient(
-    rclcpp::Node * node,
-    const std::string & remote_node_name = "",
+    rclcpp::Node * node, const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters,
     rclcpp::callback_group::CallbackGroup::SharedPtr group = nullptr);
 
   RCLCPP_PUBLIC
-  std::shared_future<std::vector<rclcpp::Parameter>>
-  get_parameters(
+  std::shared_future<std::vector<rclcpp::Parameter>> get_parameters(
     const std::vector<std::string> & names,
-    std::function<
-      void(std::shared_future<std::vector<rclcpp::Parameter>>)
-    > callback = nullptr);
+    std::function<void(std::shared_future<std::vector<rclcpp::Parameter>>)> callback = nullptr);
 
   RCLCPP_PUBLIC
-  std::shared_future<std::vector<rclcpp::ParameterType>>
-  get_parameter_types(
+  std::shared_future<std::vector<rclcpp::ParameterType>> get_parameter_types(
     const std::vector<std::string> & names,
-    std::function<
-      void(std::shared_future<std::vector<rclcpp::ParameterType>>)
-    > callback = nullptr);
+    std::function<void(std::shared_future<std::vector<rclcpp::ParameterType>>)> callback = nullptr);
 
   RCLCPP_PUBLIC
-  std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>>
-  set_parameters(
+  std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>> set_parameters(
     const std::vector<rclcpp::Parameter> & parameters,
-    std::function<
-      void(std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>>)
-    > callback = nullptr);
+    std::function<void(std::shared_future<std::vector<rcl_interfaces::msg::SetParametersResult>>)>
+      callback = nullptr);
 
   RCLCPP_PUBLIC
-  std::shared_future<rcl_interfaces::msg::SetParametersResult>
-  set_parameters_atomically(
+  std::shared_future<rcl_interfaces::msg::SetParametersResult> set_parameters_atomically(
     const std::vector<rclcpp::Parameter> & parameters,
-    std::function<
-      void(std::shared_future<rcl_interfaces::msg::SetParametersResult>)
-    > callback = nullptr);
+    std::function<void(std::shared_future<rcl_interfaces::msg::SetParametersResult>)> callback =
+      nullptr);
 
   RCLCPP_PUBLIC
-  std::shared_future<rcl_interfaces::msg::ListParametersResult>
-  list_parameters(
-    const std::vector<std::string> & prefixes,
-    uint64_t depth,
-    std::function<
-      void(std::shared_future<rcl_interfaces::msg::ListParametersResult>)
-    > callback = nullptr);
+  std::shared_future<rcl_interfaces::msg::ListParametersResult> list_parameters(
+    const std::vector<std::string> & prefixes, uint64_t depth,
+    std::function<void(std::shared_future<rcl_interfaces::msg::ListParametersResult>)> callback =
+      nullptr);
 
-  template<
-    typename CallbackT,
-    typename AllocatorT = std::allocator<void>>
-  typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
-  on_parameter_event(
+  template <typename CallbackT, typename AllocatorT = std::allocator<void>>
+  typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr on_parameter_event(
     CallbackT && callback,
-    const rclcpp::QoS & qos = (
-      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events))
-    ),
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-      rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ))
+    const rclcpp::QoS & qos =
+      (rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events))),
+    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options =
+      (rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()))
   {
-    return this->on_parameter_event(
-      this->node_topics_interface_,
-      callback,
-      qos,
-      options);
+    return this->on_parameter_event(this->node_topics_interface_, callback, qos, options);
   }
 
   /**
@@ -136,59 +112,43 @@ public:
    * which returns a shared_ptr to a NodeTopicsInterface, or be a
    * NodeTopicsInterface pointer itself.
    */
-  template<
-    typename CallbackT,
-    typename NodeT,
-    typename AllocatorT = std::allocator<void>>
+  template <typename CallbackT, typename NodeT, typename AllocatorT = std::allocator<void>>
   static typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
   on_parameter_event(
-    NodeT && node,
-    CallbackT && callback,
-    const rclcpp::QoS & qos = (
-      rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events))
-    ),
-    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options = (
-      rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()
-  ))
+    NodeT && node, CallbackT && callback,
+    const rclcpp::QoS & qos =
+      (rclcpp::QoS(rclcpp::QoSInitialization::from_rmw(rmw_qos_profile_parameter_events))),
+    const rclcpp::SubscriptionOptionsWithAllocator<AllocatorT> & options =
+      (rclcpp::SubscriptionOptionsWithAllocator<AllocatorT>()))
   {
     return rclcpp::create_subscription<rcl_interfaces::msg::ParameterEvent>(
-      node,
-      "parameter_events",
-      qos,
-      std::forward<CallbackT>(callback),
-      options);
+      node, "parameter_events", qos, std::forward<CallbackT>(callback), options);
   }
 
   RCLCPP_PUBLIC
-  bool
-  service_is_ready() const;
+  bool service_is_ready() const;
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
-  bool
-  wait_for_service(
+  template <typename RepT = int64_t, typename RatioT = std::milli>
+  bool wait_for_service(
     std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
   {
     return wait_for_service_nanoseconds(
-      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout)
-    );
+      std::chrono::duration_cast<std::chrono::nanoseconds>(timeout));
   }
 
 protected:
   RCLCPP_PUBLIC
-  bool
-  wait_for_service_nanoseconds(std::chrono::nanoseconds timeout);
+  bool wait_for_service_nanoseconds(std::chrono::nanoseconds timeout);
 
 private:
   rclcpp::node_interfaces::NodeTopicsInterface::SharedPtr node_topics_interface_;
   rclcpp::Client<rcl_interfaces::srv::GetParameters>::SharedPtr get_parameters_client_;
-  rclcpp::Client<rcl_interfaces::srv::GetParameterTypes>::SharedPtr
-    get_parameter_types_client_;
+  rclcpp::Client<rcl_interfaces::srv::GetParameterTypes>::SharedPtr get_parameter_types_client_;
   rclcpp::Client<rcl_interfaces::srv::SetParameters>::SharedPtr set_parameters_client_;
   rclcpp::Client<rcl_interfaces::srv::SetParametersAtomically>::SharedPtr
     set_parameters_atomically_client_;
   rclcpp::Client<rcl_interfaces::srv::ListParameters>::SharedPtr list_parameters_client_;
-  rclcpp::Client<rcl_interfaces::srv::DescribeParameters>::SharedPtr
-    describe_parameters_client_;
+  rclcpp::Client<rcl_interfaces::srv::DescribeParameters>::SharedPtr describe_parameters_client_;
   std::string remote_node_name_;
 };
 
@@ -199,27 +159,23 @@ public:
 
   RCLCPP_PUBLIC
   explicit SyncParametersClient(
-    rclcpp::Node::SharedPtr node,
-    const std::string & remote_node_name = "",
+    rclcpp::Node::SharedPtr node, const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters);
 
   RCLCPP_PUBLIC
   SyncParametersClient(
-    rclcpp::executor::Executor::SharedPtr executor,
-    rclcpp::Node::SharedPtr node,
+    rclcpp::executor::Executor::SharedPtr executor, rclcpp::Node::SharedPtr node,
     const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters);
 
   RCLCPP_PUBLIC
   explicit SyncParametersClient(
-    rclcpp::Node * node,
-    const std::string & remote_node_name = "",
+    rclcpp::Node * node, const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters);
 
   RCLCPP_PUBLIC
   SyncParametersClient(
-    rclcpp::executor::Executor::SharedPtr executor,
-    rclcpp::Node * node,
+    rclcpp::executor::Executor::SharedPtr executor, rclcpp::Node * node,
     const std::string & remote_node_name = "",
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters);
 
@@ -234,16 +190,13 @@ public:
     const rmw_qos_profile_t & qos_profile = rmw_qos_profile_parameters);
 
   RCLCPP_PUBLIC
-  std::vector<rclcpp::Parameter>
-  get_parameters(const std::vector<std::string> & parameter_names);
+  std::vector<rclcpp::Parameter> get_parameters(const std::vector<std::string> & parameter_names);
 
   RCLCPP_PUBLIC
-  bool
-  has_parameter(const std::string & parameter_name);
+  bool has_parameter(const std::string & parameter_name);
 
-  template<typename T>
-  T
-  get_parameter_impl(
+  template <typename T>
+  T get_parameter_impl(
     const std::string & parameter_name, std::function<T()> parameter_not_found_handler)
   {
     std::vector<std::string> names;
@@ -256,48 +209,42 @@ public:
     }
   }
 
-  template<typename T>
-  T
-  get_parameter(const std::string & parameter_name, const T & default_value)
+  template <typename T>
+  T get_parameter(const std::string & parameter_name, const T & default_value)
   {
     return get_parameter_impl(
-      parameter_name,
-      std::function<T()>([&default_value]() -> T {return default_value;}));
+      parameter_name, std::function<T()>([&default_value]() -> T { return default_value; }));
   }
 
-  template<typename T>
-  T
-  get_parameter(const std::string & parameter_name)
+  template <typename T>
+  T get_parameter(const std::string & parameter_name)
   {
-    return get_parameter_impl(
-      parameter_name,
-      std::function<T()>([]() -> T {throw std::runtime_error("Parameter not set");}));
+    return get_parameter_impl(parameter_name, std::function<T()>([]() -> T {
+                                throw std::runtime_error("Parameter not set");
+                              }));
   }
 
   RCLCPP_PUBLIC
-  std::vector<rclcpp::ParameterType>
-  get_parameter_types(const std::vector<std::string> & parameter_names);
+  std::vector<rclcpp::ParameterType> get_parameter_types(
+    const std::vector<std::string> & parameter_names);
 
   RCLCPP_PUBLIC
-  std::vector<rcl_interfaces::msg::SetParametersResult>
-  set_parameters(const std::vector<rclcpp::Parameter> & parameters);
+  std::vector<rcl_interfaces::msg::SetParametersResult> set_parameters(
+    const std::vector<rclcpp::Parameter> & parameters);
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::SetParametersResult
-  set_parameters_atomically(const std::vector<rclcpp::Parameter> & parameters);
+  rcl_interfaces::msg::SetParametersResult set_parameters_atomically(
+    const std::vector<rclcpp::Parameter> & parameters);
 
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ListParametersResult
-  list_parameters(
-    const std::vector<std::string> & parameter_prefixes,
-    uint64_t depth);
+  rcl_interfaces::msg::ListParametersResult list_parameters(
+    const std::vector<std::string> & parameter_prefixes, uint64_t depth);
 
-  template<typename CallbackT>
-  typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
-  on_parameter_event(CallbackT && callback)
+  template <typename CallbackT>
+  typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr on_parameter_event(
+    CallbackT && callback)
   {
-    return async_parameters_client_->on_parameter_event(
-      std::forward<CallbackT>(callback));
+    return async_parameters_client_->on_parameter_event(std::forward<CallbackT>(callback));
   }
 
   /**
@@ -305,29 +252,18 @@ public:
    * which returns a shared_ptr to a NodeTopicsInterface, or be a
    * NodeTopicsInterface pointer itself.
    */
-  template<
-    typename CallbackT,
-    typename NodeT>
+  template <typename CallbackT, typename NodeT>
   static typename rclcpp::Subscription<rcl_interfaces::msg::ParameterEvent>::SharedPtr
-  on_parameter_event(
-    NodeT && node,
-    CallbackT && callback)
+  on_parameter_event(NodeT && node, CallbackT && callback)
   {
-    return AsyncParametersClient::on_parameter_event(
-      node,
-      std::forward<CallbackT>(callback));
+    return AsyncParametersClient::on_parameter_event(node, std::forward<CallbackT>(callback));
   }
 
   RCLCPP_PUBLIC
-  bool
-  service_is_ready() const
-  {
-    return async_parameters_client_->service_is_ready();
-  }
+  bool service_is_ready() const { return async_parameters_client_->service_is_ready(); }
 
-  template<typename RepT = int64_t, typename RatioT = std::milli>
-  bool
-  wait_for_service(
+  template <typename RepT = int64_t, typename RatioT = std::milli>
+  bool wait_for_service(
     std::chrono::duration<RepT, RatioT> timeout = std::chrono::duration<RepT, RatioT>(-1))
   {
     return async_parameters_client_->wait_for_service(timeout);

rclcpp/include/rclcpp/parameter_events_filter.hpp

@@ -35,7 +35,7 @@ class ParameterEventsFilter
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(ParameterEventsFilter)
-  enum class EventType {NEW, DELETED, CHANGED};  ///< An enum for the type of event.
+  enum class EventType { NEW, DELETED, CHANGED };  ///< An enum for the type of event.
   /// Used for the listed results
   using EventPair = std::pair<EventType, rcl_interfaces::msg::Parameter *>;
 
@@ -60,8 +60,7 @@ public:
    */
   RCLCPP_PUBLIC
   ParameterEventsFilter(
-    rcl_interfaces::msg::ParameterEvent::SharedPtr event,
-    const std::vector<std::string> & names,
+    rcl_interfaces::msg::ParameterEvent::SharedPtr event, const std::vector<std::string> & names,
     const std::vector<EventType> & types);
 
   /// Get the result of the filter
@@ -73,7 +72,7 @@ public:
 
 private:
   // access only allowed via const accessor.
-  std::vector<EventPair> result_;  ///< Storage of the resultant vector
+  std::vector<EventPair> result_;                         ///< Storage of the resultant vector
   rcl_interfaces::msg::ParameterEvent::SharedPtr event_;  ///< Keep event in scope
 };
 

rclcpp/include/rclcpp/parameter_map.hpp

@@ -37,16 +37,14 @@ using ParameterMap = std::unordered_map<std::string, std::vector<Parameter>>;
 /// \returns a map where the keys are fully qualified node names and values a list of parameters.
 /// \throws InvalidParametersException if the `rcl_params_t` is inconsistent or invalid.
 RCLCPP_PUBLIC
-ParameterMap
-parameter_map_from(const rcl_params_t * const c_params);
+ParameterMap parameter_map_from(const rcl_params_t * const c_params);
 
 /// Convert parameter value from rcl_yaml_param_parser into a C++ class instance.
 /// \param[in] c_value C structure containing a value of a parameter.
 /// \returns an instance of a parameter value
 /// \throws InvalidParameterValueException if the `rcl_variant_t` is inconsistent or invalid.
 RCLCPP_PUBLIC
-ParameterValue
-parameter_value_from(const rcl_variant_t * const c_value);
+ParameterValue parameter_value_from(const rcl_variant_t * const c_value);
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/parameter_service.hpp

@@ -48,13 +48,11 @@ public:
 
 private:
   rclcpp::Service<rcl_interfaces::srv::GetParameters>::SharedPtr get_parameters_service_;
-  rclcpp::Service<rcl_interfaces::srv::GetParameterTypes>::SharedPtr
-    get_parameter_types_service_;
+  rclcpp::Service<rcl_interfaces::srv::GetParameterTypes>::SharedPtr get_parameter_types_service_;
   rclcpp::Service<rcl_interfaces::srv::SetParameters>::SharedPtr set_parameters_service_;
   rclcpp::Service<rcl_interfaces::srv::SetParametersAtomically>::SharedPtr
     set_parameters_atomically_service_;
-  rclcpp::Service<rcl_interfaces::srv::DescribeParameters>::SharedPtr
-    describe_parameters_service_;
+  rclcpp::Service<rcl_interfaces::srv::DescribeParameters>::SharedPtr describe_parameters_service_;
   rclcpp::Service<rcl_interfaces::srv::ListParameters>::SharedPtr list_parameters_service_;
 };
 

rclcpp/include/rclcpp/parameter_value.hpp

@@ -29,8 +29,7 @@
 namespace rclcpp
 {
 
-enum ParameterType : uint8_t
-{
+enum ParameterType : uint8_t {
   PARAMETER_NOT_SET = rcl_interfaces::msg::ParameterType::PARAMETER_NOT_SET,
   PARAMETER_BOOL = rcl_interfaces::msg::ParameterType::PARAMETER_BOOL,
   PARAMETER_INTEGER = rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER,
@@ -45,12 +44,10 @@ enum ParameterType : uint8_t
 
 /// Return the name of a parameter type
 RCLCPP_PUBLIC
-std::string
-to_string(ParameterType type);
+std::string to_string(ParameterType type);
 
 RCLCPP_PUBLIC
-std::ostream &
-operator<<(std::ostream & os, ParameterType type);
+std::ostream & operator<<(std::ostream & os, ParameterType type);
 
 /// Indicate the parameter type does not match the expected type.
 class ParameterTypeException : public std::runtime_error
@@ -64,7 +61,8 @@ public:
   RCLCPP_PUBLIC
   ParameterTypeException(ParameterType expected, ParameterType actual)
   : std::runtime_error("expected [" + to_string(expected) + "] got [" + to_string(actual) + "]")
-  {}
+  {
+  }
 };
 
 /// Store the type and value of a parameter.
@@ -122,30 +120,25 @@ public:
 
   /// Return an enum indicating the type of the set value.
   RCLCPP_PUBLIC
-  ParameterType
-  get_type() const;
+  ParameterType get_type() const;
 
   /// Return a message populated with the parameter value
   RCLCPP_PUBLIC
-  rcl_interfaces::msg::ParameterValue
-  to_value_msg() const;
+  rcl_interfaces::msg::ParameterValue to_value_msg() const;
 
   /// Equal operator.
   RCLCPP_PUBLIC
-  bool
-  operator==(const ParameterValue & rhs) const;
+  bool operator==(const ParameterValue & rhs) const;
 
   /// Not equal operator.
   RCLCPP_PUBLIC
-  bool
-  operator!=(const ParameterValue & rhs) const;
+  bool operator!=(const ParameterValue & rhs) const;
 
   // The following get() variants require the use of ParameterType
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<type == ParameterType::PARAMETER_BOOL, const bool &>::type
-  get() const
+  template <ParameterType type>
+  constexpr typename std::enable_if<type == ParameterType::PARAMETER_BOOL, const bool &>::type get()
+    const
   {
     if (value_.type != rcl_interfaces::msg::ParameterType::PARAMETER_BOOL) {
       throw ParameterTypeException(ParameterType::PARAMETER_BOOL, get_type());
@@ -153,9 +146,8 @@ public:
     return value_.bool_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<type == ParameterType::PARAMETER_INTEGER, const int64_t &>::type
+  template <ParameterType type>
+  constexpr typename std::enable_if<type == ParameterType::PARAMETER_INTEGER, const int64_t &>::type
   get() const
   {
     if (value_.type != rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER) {
@@ -164,9 +156,8 @@ public:
     return value_.integer_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<type == ParameterType::PARAMETER_DOUBLE, const double &>::type
+  template <ParameterType type>
+  constexpr typename std::enable_if<type == ParameterType::PARAMETER_DOUBLE, const double &>::type
   get() const
   {
     if (value_.type != rcl_interfaces::msg::ParameterType::PARAMETER_DOUBLE) {
@@ -175,10 +166,10 @@ public:
     return value_.double_value;
   }
 
-  template<ParameterType type>
+  template <ParameterType type>
   constexpr
-  typename std::enable_if<type == ParameterType::PARAMETER_STRING, const std::string &>::type
-  get() const
+    typename std::enable_if<type == ParameterType::PARAMETER_STRING, const std::string &>::type
+    get() const
   {
     if (value_.type != rcl_interfaces::msg::ParameterType::PARAMETER_STRING) {
       throw ParameterTypeException(ParameterType::PARAMETER_STRING, get_type());
@@ -186,9 +177,8 @@ public:
     return value_.string_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<
+  template <ParameterType type>
+  constexpr typename std::enable_if<
     type == ParameterType::PARAMETER_BYTE_ARRAY, const std::vector<uint8_t> &>::type
   get() const
   {
@@ -198,9 +188,8 @@ public:
     return value_.byte_array_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<
+  template <ParameterType type>
+  constexpr typename std::enable_if<
     type == ParameterType::PARAMETER_BOOL_ARRAY, const std::vector<bool> &>::type
   get() const
   {
@@ -210,9 +199,8 @@ public:
     return value_.bool_array_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<
+  template <ParameterType type>
+  constexpr typename std::enable_if<
     type == ParameterType::PARAMETER_INTEGER_ARRAY, const std::vector<int64_t> &>::type
   get() const
   {
@@ -222,9 +210,8 @@ public:
     return value_.integer_array_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<
+  template <ParameterType type>
+  constexpr typename std::enable_if<
     type == ParameterType::PARAMETER_DOUBLE_ARRAY, const std::vector<double> &>::type
   get() const
   {
@@ -234,9 +221,8 @@ public:
     return value_.double_array_value;
   }
 
-  template<ParameterType type>
-  constexpr
-  typename std::enable_if<
+  template <ParameterType type>
+  constexpr typename std::enable_if<
     type == ParameterType::PARAMETER_STRING_ARRAY, const std::vector<std::string> &>::type
   get() const
   {
@@ -248,84 +234,74 @@ public:
 
   // The following get() variants allow the use of primitive types
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<std::is_same<type, bool>::value, const bool &>::type
-  get() const
+  template <typename type>
+  constexpr typename std::enable_if<std::is_same<type, bool>::value, const bool &>::type get() const
   {
     return get<ParameterType::PARAMETER_BOOL>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
+  template <typename type>
+  constexpr typename std::enable_if<
     std::is_integral<type>::value && !std::is_same<type, bool>::value, const int64_t &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_INTEGER>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<std::is_floating_point<type>::value, const double &>::type
-  get() const
+  template <typename type>
+  constexpr typename std::enable_if<std::is_floating_point<type>::value, const double &>::type get()
+    const
   {
     return get<ParameterType::PARAMETER_DOUBLE>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<std::is_convertible<type, std::string>::value, const std::string &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, std::string>::value, const std::string &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_STRING>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
-    std::is_convertible<
-      type, const std::vector<uint8_t> &>::value, const std::vector<uint8_t> &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, const std::vector<uint8_t> &>::value,
+    const std::vector<uint8_t> &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_BYTE_ARRAY>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
-    std::is_convertible<
-      type, const std::vector<bool> &>::value, const std::vector<bool> &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, const std::vector<bool> &>::value, const std::vector<bool> &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_BOOL_ARRAY>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
-    std::is_convertible<
-      type, const std::vector<int64_t> &>::value, const std::vector<int64_t> &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, const std::vector<int64_t> &>::value,
+    const std::vector<int64_t> &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_INTEGER_ARRAY>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
-    std::is_convertible<
-      type, const std::vector<double> &>::value, const std::vector<double> &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, const std::vector<double> &>::value,
+    const std::vector<double> &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_DOUBLE_ARRAY>();
   }
 
-  template<typename type>
-  constexpr
-  typename std::enable_if<
-    std::is_convertible<
-      type, const std::vector<std::string> &>::value, const std::vector<std::string> &>::type
+  template <typename type>
+  constexpr typename std::enable_if<
+    std::is_convertible<type, const std::vector<std::string> &>::value,
+    const std::vector<std::string> &>::type
   get() const
   {
     return get<ParameterType::PARAMETER_STRING_ARRAY>();
@@ -337,8 +313,7 @@ private:
 
 /// Return the value of a parameter as a string
 RCLCPP_PUBLIC
-std::string
-to_string(const ParameterValue & type);
+std::string to_string(const ParameterValue & type);
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/publisher.hpp

@@ -42,7 +42,7 @@ namespace rclcpp
 {
 
 /// A publisher publishes messages of any type to a topic.
-template<typename MessageT, typename Alloc = std::allocator<void>>
+template <typename MessageT, typename Alloc = std::allocator<void>>
 class Publisher : public PublisherBase
 {
 public:
@@ -55,15 +55,12 @@ public:
   RCLCPP_SMART_PTR_DEFINITIONS(Publisher<MessageT, Alloc>)
 
   Publisher(
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const std::string & topic,
+    rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic,
     const rcl_publisher_options_t & publisher_options,
     const PublisherEventCallbacks & event_callbacks,
     const std::shared_ptr<MessageAlloc> & allocator)
   : PublisherBase(
-      node_base,
-      topic,
-      *rosidl_typesupport_cpp::get_message_type_support_handle<MessageT>(),
+      node_base, topic, *rosidl_typesupport_cpp::get_message_type_support_handle<MessageT>(),
       publisher_options),
     message_allocator_(allocator)
   {
@@ -71,24 +68,21 @@ public:
 
     if (event_callbacks.deadline_callback) {
       this->add_event_handler(
-        event_callbacks.deadline_callback,
-        RCL_PUBLISHER_OFFERED_DEADLINE_MISSED);
+        event_callbacks.deadline_callback, RCL_PUBLISHER_OFFERED_DEADLINE_MISSED);
     }
     if (event_callbacks.liveliness_callback) {
       this->add_event_handler(event_callbacks.liveliness_callback, RCL_PUBLISHER_LIVELINESS_LOST);
     }
   }
 
-  virtual ~Publisher()
-  {}
+  virtual ~Publisher() {}
 
-  mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  make_mapped_ring_buffer(size_t size) const override
+  mapped_ring_buffer::MappedRingBufferBase::SharedPtr make_mapped_ring_buffer(
+    size_t size) const override
   {
-    return mapped_ring_buffer::MappedRingBuffer<
-      MessageT,
-      typename Publisher<MessageT, Alloc>::MessageAlloc
-    >::make_shared(size, this->get_allocator());
+    return mapped_ring_buffer::
+      MappedRingBuffer<MessageT, typename Publisher<MessageT, Alloc>::MessageAlloc>::make_shared(
+        size, this->get_allocator());
   }
 
   /// Send a message to the topic for this publisher.
@@ -96,8 +90,7 @@ public:
    * This function is templated on the input message type, MessageT.
    * \param[in] msg A shared pointer to the message to send.
    */
-  virtual void
-  publish(std::unique_ptr<MessageT, MessageDeleter> msg)
+  virtual void publish(std::unique_ptr<MessageT, MessageDeleter> msg)
   {
     if (!intra_process_is_enabled_) {
       this->do_inter_process_publish(msg.get());
@@ -115,11 +108,9 @@ public:
     MessageSharedPtr shared_msg;
     if (inter_process_publish_needed) {
       shared_msg = std::move(msg);
-      message_seq =
-        store_intra_process_message(intra_process_publisher_id_, shared_msg);
+      message_seq = store_intra_process_message(intra_process_publisher_id_, shared_msg);
     } else {
-      message_seq =
-        store_intra_process_message(intra_process_publisher_id_, std::move(msg));
+      message_seq = store_intra_process_message(intra_process_publisher_id_, std::move(msg));
     }
     this->do_intra_process_publish(message_seq);
     if (inter_process_publish_needed) {
@@ -129,18 +120,17 @@ public:
 
 // Skip deprecated attribute in windows, as it raise a warning in template specialization.
 #if !defined(_WIN32)
-  [[deprecated(
-    "publishing an unique_ptr is prefered when using intra process communication."
-    " If using a shared_ptr, use publish(*msg).")]]
+  [
+    [deprecated("publishing an unique_ptr is prefered when using intra process communication."
+                " If using a shared_ptr, use publish(*msg).")]]
 #endif
-  virtual void
-  publish(const std::shared_ptr<const MessageT> & msg)
+    virtual void
+    publish(const std::shared_ptr<const MessageT> & msg)
   {
     publish(*msg);
   }
 
-  virtual void
-  publish(const MessageT & msg)
+  virtual void publish(const MessageT & msg)
   {
     // Avoid allocating when not using intra process.
     if (!intra_process_is_enabled_) {
@@ -158,11 +148,10 @@ public:
 
 // Skip deprecated attribute in windows, as it raise a warning in template specialization.
 #if !defined(_WIN32)
-  [[deprecated(
-    "Use publish(*msg). Check against nullptr before calling if necessary.")]]
+  [[deprecated("Use publish(*msg). Check against nullptr before calling if necessary.")]]
 #endif
-  virtual void
-  publish(const MessageT * msg)
+    virtual void
+    publish(const MessageT * msg)
   {
     if (!msg) {
       throw std::runtime_error("msg argument is nullptr");
@@ -170,42 +159,34 @@ public:
     return this->publish(*msg);
   }
 
-  void
-  publish(const rcl_serialized_message_t & serialized_msg)
+  void publish(const rcl_serialized_message_t & serialized_msg)
   {
     return this->do_serialized_publish(&serialized_msg);
   }
 
 // Skip deprecated attribute in windows, as it raise a warning in template specialization.
 #if !defined(_WIN32)
-  [[deprecated(
-    "Use publish(*serialized_msg). Check against nullptr before calling if necessary.")]]
+  [[deprecated("Use publish(*serialized_msg). Check against nullptr before calling if necessary.")]]
 #endif
-  void
-  publish(const rcl_serialized_message_t * serialized_msg)
-  {
-    return this->do_serialized_publish(serialized_msg);
-  }
+    void
+    publish(const rcl_serialized_message_t * serialized_msg) {
+      return this->do_serialized_publish(serialized_msg);
+    }
 
 // Skip deprecated attribute in windows, as it raise a warning in template specialization.
 #if !defined(_WIN32)
-  [[deprecated(
-    "Use publish(*serialized_msg). Check against nullptr before calling if necessary.")]]
+      [[deprecated(
+        "Use publish(*serialized_msg). Check against nullptr before calling if necessary.")]]
 #endif
-  void
-  publish(std::shared_ptr<const rcl_serialized_message_t> serialized_msg)
+    void publish(std::shared_ptr<const rcl_serialized_message_t> serialized_msg)
   {
     return this->do_serialized_publish(serialized_msg.get());
   }
 
-  std::shared_ptr<MessageAlloc> get_allocator() const
-  {
-    return message_allocator_;
-  }
+  std::shared_ptr<MessageAlloc> get_allocator() const { return message_allocator_; }
 
 protected:
-  void
-  do_inter_process_publish(const MessageT * msg)
+  void do_inter_process_publish(const MessageT * msg)
   {
     auto status = rcl_publish(&publisher_handle_, msg, nullptr);
     if (RCL_RET_PUBLISHER_INVALID == status) {
@@ -223,8 +204,7 @@ protected:
     }
   }
 
-  void
-  do_serialized_publish(const rcl_serialized_message_t * serialized_msg)
+  void do_serialized_publish(const rcl_serialized_message_t * serialized_msg)
   {
     if (intra_process_is_enabled_) {
       // TODO(Karsten1987): support serialized message passed by intraprocess
@@ -236,8 +216,7 @@ protected:
     }
   }
 
-  void
-  do_intra_process_publish(uint64_t message_seq)
+  void do_intra_process_publish(uint64_t message_seq)
   {
     rcl_interfaces::msg::IntraProcessMessage ipm;
     ipm.publisher_id = intra_process_publisher_id_;
@@ -258,15 +237,12 @@ protected:
     }
   }
 
-  uint64_t
-  store_intra_process_message(
-    uint64_t publisher_id,
-    std::shared_ptr<const MessageT> msg)
+  uint64_t store_intra_process_message(uint64_t publisher_id, std::shared_ptr<const MessageT> msg)
   {
     auto ipm = weak_ipm_.lock();
     if (!ipm) {
       throw std::runtime_error(
-              "intra process publish called after destruction of intra process manager");
+        "intra process publish called after destruction of intra process manager");
     }
     if (!msg) {
       throw std::runtime_error("cannot publisher msg which is a null pointer");
@@ -276,15 +252,13 @@ protected:
     return message_seq;
   }
 
-  uint64_t
-  store_intra_process_message(
-    uint64_t publisher_id,
-    std::unique_ptr<MessageT, MessageDeleter> msg)
+  uint64_t store_intra_process_message(
+    uint64_t publisher_id, std::unique_ptr<MessageT, MessageDeleter> msg)
   {
     auto ipm = weak_ipm_.lock();
     if (!ipm) {
       throw std::runtime_error(
-              "intra process publish called after destruction of intra process manager");
+        "intra process publish called after destruction of intra process manager");
     }
     if (!msg) {
       throw std::runtime_error("cannot publisher msg which is a null pointer");

rclcpp/include/rclcpp/publisher_base.hpp

@@ -41,7 +41,7 @@ namespace node_interfaces
 {
 class NodeBaseInterface;
 class NodeTopicsInterface;
-}
+}  // namespace node_interfaces
 
 namespace intra_process_manager
 {
@@ -50,7 +50,7 @@ namespace intra_process_manager
  * `intra_process_manager.hpp` and `publisher_base.hpp`.
  */
 class IntraProcessManager;
-}
+}  // namespace intra_process_manager
 
 class PublisherBase
 {
@@ -70,8 +70,7 @@ public:
    */
   RCLCPP_PUBLIC
   PublisherBase(
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const std::string & topic,
+    rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic,
     const rosidl_message_type_support_t & type_support,
     const rcl_publisher_options_t & publisher_options);
 
@@ -81,56 +80,47 @@ public:
   /// Get the topic that this publisher publishes on.
   /** \return The topic name. */
   RCLCPP_PUBLIC
-  const char *
-  get_topic_name() const;
+  const char * get_topic_name() const;
 
   /// Get the queue size for this publisher.
   /** \return The queue size. */
   RCLCPP_PUBLIC
-  size_t
-  get_queue_size() const;
+  size_t get_queue_size() const;
 
   /// Get the global identifier for this publisher (used in rmw and by DDS).
   /** \return The gid. */
   RCLCPP_PUBLIC
-  const rmw_gid_t &
-  get_gid() const;
+  const rmw_gid_t & get_gid() const;
 
   /// Get the global identifier for this publisher used by intra-process communication.
   /** \return The intra-process gid. */
   RCLCPP_PUBLIC
-  const rmw_gid_t &
-  get_intra_process_gid() const;
+  const rmw_gid_t & get_intra_process_gid() const;
 
   /// Get the rcl publisher handle.
   /** \return The rcl publisher handle. */
   RCLCPP_PUBLIC
-  rcl_publisher_t *
-  get_publisher_handle();
+  rcl_publisher_t * get_publisher_handle();
 
   /// Get the rcl publisher handle.
   /** \return The rcl publisher handle. */
   RCLCPP_PUBLIC
-  const rcl_publisher_t *
-  get_publisher_handle() const;
+  const rcl_publisher_t * get_publisher_handle() const;
 
   /// Get all the QoS event handlers associated with this publisher.
   /** \return The vector of QoS event handlers. */
   RCLCPP_PUBLIC
-  const std::vector<std::shared_ptr<rclcpp::QOSEventHandlerBase>> &
-  get_event_handlers() const;
+  const std::vector<std::shared_ptr<rclcpp::QOSEventHandlerBase>> & get_event_handlers() const;
 
   /// Get subscription count
   /** \return The number of subscriptions. */
   RCLCPP_PUBLIC
-  size_t
-  get_subscription_count() const;
+  size_t get_subscription_count() const;
 
   /// Get intraprocess subscription count
   /** \return The number of intraprocess subscriptions. */
   RCLCPP_PUBLIC
-  size_t
-  get_intra_process_subscription_count() const;
+  size_t get_intra_process_subscription_count() const;
 
   /// Manually assert that this Publisher is alive (for RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC).
   /**
@@ -142,8 +132,7 @@ public:
    */
   RCLCPP_PUBLIC
   RCUTILS_WARN_UNUSED
-  bool
-  assert_liveliness() const;
+  bool assert_liveliness() const;
 
   /// Get the actual QoS settings, after the defaults have been determined.
   /**
@@ -156,8 +145,7 @@ public:
    * \return The actual qos settings.
    */
   RCLCPP_PUBLIC
-  rmw_qos_profile_t
-  get_actual_qos() const;
+  rmw_qos_profile_t get_actual_qos() const;
 
   /// Compare this publisher to a gid.
   /**
@@ -166,8 +154,7 @@ public:
    * \return True if the publisher's gid matches the input.
    */
   RCLCPP_PUBLIC
-  bool
-  operator==(const rmw_gid_t & gid) const;
+  bool operator==(const rmw_gid_t & gid) const;
 
   /// Compare this publisher to a pointer gid.
   /**
@@ -176,37 +163,29 @@ public:
    * \return True if this publisher's gid matches the input.
    */
   RCLCPP_PUBLIC
-  bool
-  operator==(const rmw_gid_t * gid) const;
+  bool operator==(const rmw_gid_t * gid) const;
 
   using IntraProcessManagerSharedPtr =
     std::shared_ptr<rclcpp::intra_process_manager::IntraProcessManager>;
 
   /// Implementation utility function that creates a typed mapped ring buffer.
   RCLCPP_PUBLIC
-  mapped_ring_buffer::MappedRingBufferBase::SharedPtr
-  virtual make_mapped_ring_buffer(size_t size) const;
+  mapped_ring_buffer::MappedRingBufferBase::SharedPtr virtual make_mapped_ring_buffer(
+    size_t size) const;
 
   /// Implementation utility function used to setup intra process publishing after creation.
   RCLCPP_PUBLIC
-  void
-  setup_intra_process(
-    uint64_t intra_process_publisher_id,
-    IntraProcessManagerSharedPtr ipm,
+  void setup_intra_process(
+    uint64_t intra_process_publisher_id, IntraProcessManagerSharedPtr ipm,
     const rcl_publisher_options_t & intra_process_options);
 
 protected:
-  template<typename EventCallbackT>
-  void
-  add_event_handler(
-    const EventCallbackT & callback,
-    const rcl_publisher_event_type_t event_type)
+  template <typename EventCallbackT>
+  void add_event_handler(
+    const EventCallbackT & callback, const rcl_publisher_event_type_t event_type)
   {
     auto handler = std::make_shared<QOSEventHandler<EventCallbackT>>(
-      callback,
-      rcl_publisher_event_init,
-      &publisher_handle_,
-      event_type);
+      callback, rcl_publisher_event_init, &publisher_handle_, event_type);
     event_handlers_.emplace_back(handler);
   }
 

rclcpp/include/rclcpp/publisher_factory.hpp

@@ -23,9 +23,9 @@
 
 #include "rosidl_typesupport_cpp/message_type_support.hpp"
 
-#include "rclcpp/publisher.hpp"
 #include "rclcpp/intra_process_manager.hpp"
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
+#include "rclcpp/publisher.hpp"
 #include "rclcpp/visibility_control.hpp"
 
 namespace rclcpp
@@ -45,43 +45,32 @@ namespace rclcpp
 struct PublisherFactory
 {
   // Creates a PublisherT<MessageT, ...> publisher object and returns it as a PublisherBase.
-  using PublisherFactoryFunction = std::function<
-    rclcpp::PublisherBase::SharedPtr(
-      rclcpp::node_interfaces::NodeBaseInterface * node_base,
-      const std::string & topic_name,
-      const rcl_publisher_options_t & publisher_options)>;
+  using PublisherFactoryFunction = std::function<rclcpp::PublisherBase::SharedPtr(
+    rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic_name,
+    const rcl_publisher_options_t & publisher_options)>;
 
   PublisherFactoryFunction create_typed_publisher;
 };
 
 /// Return a PublisherFactory with functions setup for creating a PublisherT<MessageT, Alloc>.
-template<typename MessageT, typename Alloc, typename PublisherT>
-PublisherFactory
-create_publisher_factory(
-  const PublisherEventCallbacks & event_callbacks,
-  std::shared_ptr<Alloc> allocator)
+template <typename MessageT, typename Alloc, typename PublisherT>
+PublisherFactory create_publisher_factory(
+  const PublisherEventCallbacks & event_callbacks, std::shared_ptr<Alloc> allocator)
 {
   PublisherFactory factory;
 
   // factory function that creates a MessageT specific PublisherT
   factory.create_typed_publisher =
     [event_callbacks, allocator](
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const std::string & topic_name,
-    const rcl_publisher_options_t & publisher_options
-    ) -> std::shared_ptr<PublisherT>
-    {
-      auto options_copy = publisher_options;
-      auto message_alloc = std::make_shared<typename PublisherT::MessageAlloc>(*allocator.get());
-      options_copy.allocator = allocator::get_rcl_allocator<MessageT>(*message_alloc.get());
+      rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic_name,
+      const rcl_publisher_options_t & publisher_options) -> std::shared_ptr<PublisherT> {
+    auto options_copy = publisher_options;
+    auto message_alloc = std::make_shared<typename PublisherT::MessageAlloc>(*allocator.get());
+    options_copy.allocator = allocator::get_rcl_allocator<MessageT>(*message_alloc.get());
 
-      return std::make_shared<PublisherT>(
-        node_base,
-        topic_name,
-        options_copy,
-        event_callbacks,
-        message_alloc);
-    };
+    return std::make_shared<PublisherT>(
+      node_base, topic_name, options_copy, event_callbacks, message_alloc);
+  };
 
   // return the factory now that it is populated
   return factory;

rclcpp/include/rclcpp/publisher_options.hpp

@@ -19,12 +19,12 @@
 #include <string>
 #include <vector>
 
+#include "rcl/publisher.h"
 #include "rclcpp/callback_group.hpp"
 #include "rclcpp/intra_process_setting.hpp"
 #include "rclcpp/qos.hpp"
 #include "rclcpp/qos_event.hpp"
 #include "rclcpp/visibility_control.hpp"
-#include "rcl/publisher.h"
 
 namespace rclcpp
 {
@@ -43,7 +43,7 @@ struct PublisherOptionsBase
 };
 
 /// Structure containing optional configuration for Publishers.
-template<typename Allocator>
+template <typename Allocator>
 struct PublisherOptionsWithAllocator : public PublisherOptionsBase
 {
   /// Optional custom allocator.
@@ -54,12 +54,12 @@ struct PublisherOptionsWithAllocator : public PublisherOptionsBase
   /// Constructor using base class as input.
   explicit PublisherOptionsWithAllocator(const PublisherOptionsBase & publisher_options_base)
   : PublisherOptionsBase(publisher_options_base)
-  {}
+  {
+  }
 
   /// Convert this class, and a rclcpp::QoS, into an rcl_publisher_options_t.
-  template<typename MessageT>
-  rcl_publisher_options_t
-  to_rcl_publisher_options(const rclcpp::QoS & qos) const
+  template <typename MessageT>
+  rcl_publisher_options_t to_rcl_publisher_options(const rclcpp::QoS & qos) const
   {
     rcl_publisher_options_t result;
     using AllocatorTraits = std::allocator_traits<Allocator>;

rclcpp/include/rclcpp/qos.hpp

@@ -34,9 +34,7 @@ struct RCLCPP_PUBLIC QoSInitialization
   QoSInitialization(rmw_qos_history_policy_t history_policy_arg, size_t depth_arg);
 
   /// Create a QoSInitialization from an existing rmw_qos_profile_t, using its history and depth.
-  static
-  QoSInitialization
-  from_rmw(const rmw_qos_profile_t & rmw_qos);
+  static QoSInitialization from_rmw(const rmw_qos_profile_t & rmw_qos);
 };
 
 /// Use to initialize the QoS with the keep_all history setting.
@@ -56,8 +54,7 @@ class RCLCPP_PUBLIC QoS
 {
 public:
   /// Constructor which allows you to construct a QoS by giving the only required settings.
-  explicit
-  QoS(
+  explicit QoS(
     const QoSInitialization & qos_initialization,
     const rmw_qos_profile_t & initial_profile = rmw_qos_profile_default);
 
@@ -69,83 +66,64 @@ public:
   QoS(size_t history_depth);  // NOLINT(runtime/explicit): conversion constructor
 
   /// Return the rmw qos profile.
-  rmw_qos_profile_t &
-  get_rmw_qos_profile();
+  rmw_qos_profile_t & get_rmw_qos_profile();
 
   /// Return the rmw qos profile.
-  const rmw_qos_profile_t &
-  get_rmw_qos_profile() const;
+  const rmw_qos_profile_t & get_rmw_qos_profile() const;
 
   /// Set the history policy.
-  QoS &
-  history(rmw_qos_history_policy_t history);
+  QoS & history(rmw_qos_history_policy_t history);
 
   /// Set the history to keep last.
-  QoS &
-  keep_last(size_t depth);
+  QoS & keep_last(size_t depth);
 
   /// Set the history to keep all.
-  QoS &
-  keep_all();
+  QoS & keep_all();
 
   /// Set the reliability setting.
-  QoS &
-  reliability(rmw_qos_reliability_policy_t reliability);
+  QoS & reliability(rmw_qos_reliability_policy_t reliability);
 
   /// Set the reliability setting to reliable.
-  QoS &
-  reliable();
+  QoS & reliable();
 
   /// Set the reliability setting to best effort.
-  QoS &
-  best_effort();
+  QoS & best_effort();
 
   /// Set the durability setting.
-  QoS &
-  durability(rmw_qos_durability_policy_t durability);
+  QoS & durability(rmw_qos_durability_policy_t durability);
 
   /// Set the durability setting to volatile.
   /**
     * Note that this cannot be named `volatile` because it is a C++ keyword.
     */
-  QoS &
-  durability_volatile();
+  QoS & durability_volatile();
 
   /// Set the durability setting to transient local.
-  QoS &
-  transient_local();
+  QoS & transient_local();
 
   /// Set the deadline setting.
-  QoS &
-  deadline(rmw_time_t deadline);
+  QoS & deadline(rmw_time_t deadline);
 
   /// Set the deadline setting, rclcpp::Duration.
-  QoS &
-  deadline(const rclcpp::Duration & deadline);
+  QoS & deadline(const rclcpp::Duration & deadline);
 
   /// Set the lifespan setting.
-  QoS &
-  lifespan(rmw_time_t lifespan);
+  QoS & lifespan(rmw_time_t lifespan);
 
   /// Set the lifespan setting, rclcpp::Duration.
-  QoS &
-  lifespan(const rclcpp::Duration & lifespan);
+  QoS & lifespan(const rclcpp::Duration & lifespan);
 
   /// Set the liveliness setting.
-  QoS &
-  liveliness(rmw_qos_liveliness_policy_t liveliness);
+  QoS & liveliness(rmw_qos_liveliness_policy_t liveliness);
 
   /// Set the liveliness_lease_duration setting.
-  QoS &
-  liveliness_lease_duration(rmw_time_t liveliness_lease_duration);
+  QoS & liveliness_lease_duration(rmw_time_t liveliness_lease_duration);
 
   /// Set the liveliness_lease_duration setting, rclcpp::Duration.
-  QoS &
-  liveliness_lease_duration(const rclcpp::Duration & liveliness_lease_duration);
+  QoS & liveliness_lease_duration(const rclcpp::Duration & liveliness_lease_duration);
 
   /// Set the avoid_ros_namespace_conventions setting.
-  QoS &
-  avoid_ros_namespace_conventions(bool avoid_ros_namespace_conventions);
+  QoS & avoid_ros_namespace_conventions(bool avoid_ros_namespace_conventions);
 
 private:
   rmw_qos_profile_t rmw_qos_profile_;
@@ -154,51 +132,41 @@ private:
 class RCLCPP_PUBLIC SensorDataQoS : public QoS
 {
 public:
-  explicit
-  SensorDataQoS(
-    const QoSInitialization & qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_sensor_data)
-  ));
+  explicit SensorDataQoS(
+    const QoSInitialization & qos_initialization =
+      (QoSInitialization::from_rmw(rmw_qos_profile_sensor_data)));
 };
 
 class RCLCPP_PUBLIC ParametersQoS : public QoS
 {
 public:
-  explicit
-  ParametersQoS(
-    const QoSInitialization & qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_parameters)
-  ));
+  explicit ParametersQoS(
+    const QoSInitialization & qos_initialization =
+      (QoSInitialization::from_rmw(rmw_qos_profile_parameters)));
 };
 
 class RCLCPP_PUBLIC ServicesQoS : public QoS
 {
 public:
-  explicit
-  ServicesQoS(
-    const QoSInitialization & qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_services_default)
-  ));
+  explicit ServicesQoS(
+    const QoSInitialization & qos_initialization =
+      (QoSInitialization::from_rmw(rmw_qos_profile_services_default)));
 };
 
 class RCLCPP_PUBLIC ParameterEventsQoS : public QoS
 {
 public:
-  explicit
-  ParameterEventsQoS(
-    const QoSInitialization & qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)
-  ));
+  explicit ParameterEventsQoS(
+    const QoSInitialization & qos_initialization =
+      (QoSInitialization::from_rmw(rmw_qos_profile_parameter_events)));
 };
 
 class RCLCPP_PUBLIC SystemDefaultsQoS : public QoS
 {
 public:
-  explicit
-  SystemDefaultsQoS(
-    const QoSInitialization & qos_initialization = (
-      QoSInitialization::from_rmw(rmw_qos_profile_system_default)
-  ));
+  explicit SystemDefaultsQoS(
+    const QoSInitialization & qos_initialization =
+      (QoSInitialization::from_rmw(rmw_qos_profile_system_default)));
 };
 
 }  // namespace rclcpp

rclcpp/include/rclcpp/qos_event.hpp

@@ -33,10 +33,10 @@ using QOSDeadlineOfferedInfo = rmw_offered_deadline_missed_status_t;
 using QOSLivelinessChangedInfo = rmw_liveliness_changed_status_t;
 using QOSLivelinessLostInfo = rmw_liveliness_lost_status_t;
 
-using QOSDeadlineRequestedCallbackType = std::function<void (QOSDeadlineRequestedInfo &)>;
-using QOSDeadlineOfferedCallbackType = std::function<void (QOSDeadlineOfferedInfo &)>;
-using QOSLivelinessChangedCallbackType = std::function<void (QOSLivelinessChangedInfo &)>;
-using QOSLivelinessLostCallbackType = std::function<void (QOSLivelinessLostInfo &)>;
+using QOSDeadlineRequestedCallbackType = std::function<void(QOSDeadlineRequestedInfo &)>;
+using QOSDeadlineOfferedCallbackType = std::function<void(QOSDeadlineOfferedInfo &)>;
+using QOSLivelinessChangedCallbackType = std::function<void(QOSLivelinessChangedInfo &)>;
+using QOSLivelinessLostCallbackType = std::function<void(QOSLivelinessLostInfo &)>;
 
 /// Contains callbacks for various types of events a Publisher can receive from the middleware.
 struct PublisherEventCallbacks
@@ -60,33 +60,28 @@ public:
 
   /// Get the number of ready events
   RCLCPP_PUBLIC
-  size_t
-  get_number_of_ready_events() override;
+  size_t get_number_of_ready_events() override;
 
   /// Add the Waitable to a wait set.
   RCLCPP_PUBLIC
-  bool
-  add_to_wait_set(rcl_wait_set_t * wait_set) override;
+  bool add_to_wait_set(rcl_wait_set_t * wait_set) override;
 
   /// Check if the Waitable is ready.
   RCLCPP_PUBLIC
-  bool
-  is_ready(rcl_wait_set_t * wait_set) override;
+  bool is_ready(rcl_wait_set_t * wait_set) override;
 
 protected:
   rcl_event_t event_handle_;
   size_t wait_set_event_index_;
 };
 
-template<typename EventCallbackT>
+template <typename EventCallbackT>
 class QOSEventHandler : public QOSEventHandlerBase
 {
 public:
-  template<typename InitFuncT, typename ParentHandleT, typename EventTypeEnum>
+  template <typename InitFuncT, typename ParentHandleT, typename EventTypeEnum>
   QOSEventHandler(
-    const EventCallbackT & callback,
-    InitFuncT init_func,
-    ParentHandleT parent_handle,
+    const EventCallbackT & callback, InitFuncT init_func, ParentHandleT parent_handle,
     EventTypeEnum event_type)
   : event_callback_(callback)
   {
@@ -98,16 +93,13 @@ public:
   }
 
   /// Execute any entities of the Waitable that are ready.
-  void
-  execute() override
+  void execute() override
   {
     EventCallbackInfoT callback_info;
 
     rcl_ret_t ret = rcl_take_event(&event_handle_, &callback_info);
     if (ret != RCL_RET_OK) {
-      RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "Couldn't take event info: %s", rcl_get_error_string().str);
+      RCUTILS_LOG_ERROR_NAMED("rclcpp", "Couldn't take event info: %s", rcl_get_error_string().str);
       return;
     }
 
@@ -115,8 +107,9 @@ public:
   }
 
 private:
-  using EventCallbackInfoT = typename std::remove_reference<typename
-      rclcpp::function_traits::function_traits<EventCallbackT>::template argument_type<0>>::type;
+  using EventCallbackInfoT =
+    typename std::remove_reference<typename rclcpp::function_traits::function_traits<
+      EventCallbackT>::template argument_type<0>>::type;
 
   EventCallbackT event_callback_;
 };

rclcpp/include/rclcpp/rate.hpp

@@ -40,22 +40,22 @@ using std::chrono::duration;
 using std::chrono::duration_cast;
 using std::chrono::nanoseconds;
 
-template<class Clock = std::chrono::high_resolution_clock>
+template <class Clock = std::chrono::high_resolution_clock>
 class GenericRate : public RateBase
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(GenericRate)
 
   explicit GenericRate(double rate)
-  : GenericRate<Clock>(
-      duration_cast<nanoseconds>(duration<double>(1.0 / rate)))
-  {}
+  : GenericRate<Clock>(duration_cast<nanoseconds>(duration<double>(1.0 / rate)))
+  {
+  }
   explicit GenericRate(std::chrono::nanoseconds period)
   : period_(period), last_interval_(Clock::now())
-  {}
+  {
+  }
 
-  virtual bool
-  sleep()
+  virtual bool sleep()
   {
     // Time coming into sleep
     auto now = Clock::now();
@@ -86,22 +86,11 @@ public:
     return true;
   }
 
-  virtual bool
-  is_steady() const
-  {
-    return Clock::is_steady;
-  }
+  virtual bool is_steady() const { return Clock::is_steady; }
 
-  virtual void
-  reset()
-  {
-    last_interval_ = Clock::now();
-  }
+  virtual void reset() { last_interval_ = Clock::now(); }
 
-  std::chrono::nanoseconds period() const
-  {
-    return period_;
-  }
+  std::chrono::nanoseconds period() const { return period_; }
 
 private:
   RCLCPP_DISABLE_COPY(GenericRate)

rclcpp/include/rclcpp/scope_exit.hpp

@@ -26,20 +26,18 @@
 namespace rclcpp
 {
 
-template<typename Callable>
+template <typename Callable>
 struct ScopeExit
 {
-  explicit ScopeExit(Callable callable)
-  : callable_(callable) {}
-  ~ScopeExit() {callable_();}
+  explicit ScopeExit(Callable callable) : callable_(callable) {}
+  ~ScopeExit() { callable_(); }
 
 private:
   Callable callable_;
 };
 
-template<typename Callable>
-ScopeExit<Callable>
-make_scope_exit(Callable callable)
+template <typename Callable>
+ScopeExit<Callable> make_scope_exit(Callable callable)
 {
   return ScopeExit<Callable>(callable);
 }
@@ -47,6 +45,6 @@ make_scope_exit(Callable callable)
 }  // namespace rclcpp
 
 #define RCLCPP_SCOPE_EXIT(code) \
-  auto RCLCPP_STRING_JOIN(scope_exit_, __LINE__) = rclcpp::make_scope_exit([&]() {code;})
+  auto RCLCPP_STRING_JOIN(scope_exit_, __LINE__) = rclcpp::make_scope_exit([&]() { code; })
 
 #endif  // RCLCPP__SCOPE_EXIT_HPP_

rclcpp/include/rclcpp/service.hpp

@@ -26,11 +26,11 @@
 
 #include "rclcpp/any_service_callback.hpp"
 #include "rclcpp/exceptions.hpp"
+#include "rclcpp/expand_topic_or_service_name.hpp"
+#include "rclcpp/logging.hpp"
 #include "rclcpp/macros.hpp"
 #include "rclcpp/type_support_decl.hpp"
-#include "rclcpp/expand_topic_or_service_name.hpp"
 #include "rclcpp/visibility_control.hpp"
-#include "rclcpp/logging.hpp"
 #include "rmw/error_handling.h"
 #include "rmw/rmw.h"
 
@@ -43,40 +43,33 @@ public:
   RCLCPP_SMART_PTR_DEFINITIONS_NOT_COPYABLE(ServiceBase)
 
   RCLCPP_PUBLIC
-  explicit ServiceBase(
-    std::shared_ptr<rcl_node_t> node_handle);
+  explicit ServiceBase(std::shared_ptr<rcl_node_t> node_handle);
 
   RCLCPP_PUBLIC
   virtual ~ServiceBase();
 
   RCLCPP_PUBLIC
-  const char *
-  get_service_name();
+  const char * get_service_name();
 
   RCLCPP_PUBLIC
-  std::shared_ptr<rcl_service_t>
-  get_service_handle();
+  std::shared_ptr<rcl_service_t> get_service_handle();
 
   RCLCPP_PUBLIC
-  std::shared_ptr<const rcl_service_t>
-  get_service_handle() const;
+  std::shared_ptr<const rcl_service_t> get_service_handle() const;
 
   virtual std::shared_ptr<void> create_request() = 0;
   virtual std::shared_ptr<rmw_request_id_t> create_request_header() = 0;
   virtual void handle_request(
-    std::shared_ptr<rmw_request_id_t> request_header,
-    std::shared_ptr<void> request) = 0;
+    std::shared_ptr<rmw_request_id_t> request_header, std::shared_ptr<void> request) = 0;
 
 protected:
   RCLCPP_DISABLE_COPY(ServiceBase)
 
   RCLCPP_PUBLIC
-  rcl_node_t *
-  get_rcl_node_handle();
+  rcl_node_t * get_rcl_node_handle();
 
   RCLCPP_PUBLIC
-  const rcl_node_t *
-  get_rcl_node_handle() const;
+  const rcl_node_t * get_rcl_node_handle() const;
 
   std::shared_ptr<rcl_node_t> node_handle_;
 
@@ -84,27 +77,22 @@ protected:
   bool owns_rcl_handle_ = true;
 };
 
-template<typename ServiceT>
+template <typename ServiceT>
 class Service : public ServiceBase
 {
 public:
-  using CallbackType = std::function<
-    void (
-      const std::shared_ptr<typename ServiceT::Request>,
-      std::shared_ptr<typename ServiceT::Response>)>;
+  using CallbackType = std::function<void(
+    const std::shared_ptr<typename ServiceT::Request>,
+    std::shared_ptr<typename ServiceT::Response>)>;
 
-  using CallbackWithHeaderType = std::function<
-    void (
-      const std::shared_ptr<rmw_request_id_t>,
-      const std::shared_ptr<typename ServiceT::Request>,
-      std::shared_ptr<typename ServiceT::Response>)>;
+  using CallbackWithHeaderType = std::function<void(
+    const std::shared_ptr<rmw_request_id_t>, const std::shared_ptr<typename ServiceT::Request>,
+    std::shared_ptr<typename ServiceT::Response>)>;
   RCLCPP_SMART_PTR_DEFINITIONS(Service)
 
   Service(
-    std::shared_ptr<rcl_node_t> node_handle,
-    const std::string & service_name,
-    AnyServiceCallback<ServiceT> any_callback,
-    rcl_service_options_t & service_options)
+    std::shared_ptr<rcl_node_t> node_handle, const std::string & service_name,
+    AnyServiceCallback<ServiceT> any_callback, rcl_service_options_t & service_options)
   : ServiceBase(node_handle), any_callback_(any_callback)
   {
     using rosidl_typesupport_cpp::get_service_type_support_handle;
@@ -113,15 +101,13 @@ public:
     std::weak_ptr<rcl_node_t> weak_node_handle(node_handle_);
     // rcl does the static memory allocation here
     service_handle_ = std::shared_ptr<rcl_service_t>(
-      new rcl_service_t, [weak_node_handle](rcl_service_t * service)
-      {
+      new rcl_service_t, [weak_node_handle](rcl_service_t * service) {
         auto handle = weak_node_handle.lock();
         if (handle) {
           if (rcl_service_fini(service, handle.get()) != RCL_RET_OK) {
             RCLCPP_ERROR(
               rclcpp::get_node_logger(handle.get()).get_child("rclcpp"),
-              "Error in destruction of rcl service handle: %s",
-              rcl_get_error_string().str);
+              "Error in destruction of rcl service handle: %s", rcl_get_error_string().str);
             rcl_reset_error();
           }
         } else {
@@ -135,10 +121,7 @@ public:
     *service_handle_.get() = rcl_get_zero_initialized_service();
 
     rcl_ret_t ret = rcl_service_init(
-      service_handle_.get(),
-      node_handle.get(),
-      service_type_support_handle,
-      service_name.c_str(),
+      service_handle_.get(), node_handle.get(), service_type_support_handle, service_name.c_str(),
       &service_options);
     if (ret != RCL_RET_OK) {
       if (ret == RCL_RET_SERVICE_NAME_INVALID) {
@@ -146,9 +129,7 @@ public:
         // this will throw on any validation problem
         rcl_reset_error();
         expand_topic_or_service_name(
-          service_name,
-          rcl_node_get_name(rcl_node_handle),
-          rcl_node_get_namespace(rcl_node_handle),
+          service_name, rcl_node_get_name(rcl_node_handle), rcl_node_get_namespace(rcl_node_handle),
           true);
       }
 
@@ -157,11 +138,9 @@ public:
   }
 
   Service(
-    std::shared_ptr<rcl_node_t> node_handle,
-    std::shared_ptr<rcl_service_t> service_handle,
+    std::shared_ptr<rcl_node_t> node_handle, std::shared_ptr<rcl_service_t> service_handle,
     AnyServiceCallback<ServiceT> any_callback)
-  : ServiceBase(node_handle),
-    any_callback_(any_callback)
+  : ServiceBase(node_handle), any_callback_(any_callback)
   {
     // check if service handle was initialized
     if (!rcl_service_is_valid(service_handle.get())) {
@@ -175,11 +154,9 @@ public:
   }
 
   Service(
-    std::shared_ptr<rcl_node_t> node_handle,
-    rcl_service_t * service_handle,
+    std::shared_ptr<rcl_node_t> node_handle, rcl_service_t * service_handle,
     AnyServiceCallback<ServiceT> any_callback)
-  : ServiceBase(node_handle),
-    any_callback_(any_callback)
+  : ServiceBase(node_handle), any_callback_(any_callback)
   {
     // check if service handle was initialized
     if (!rcl_service_is_valid(service_handle)) {
@@ -196,9 +173,7 @@ public:
 
   Service() = delete;
 
-  virtual ~Service()
-  {
-  }
+  virtual ~Service() {}
 
   std::shared_ptr<void> create_request()
   {
@@ -213,8 +188,7 @@ public:
   }
 
   void handle_request(
-    std::shared_ptr<rmw_request_id_t> request_header,
-    std::shared_ptr<void> request)
+    std::shared_ptr<rmw_request_id_t> request_header, std::shared_ptr<void> request)
   {
     auto typed_request = std::static_pointer_cast<typename ServiceT::Request>(request);
     auto response = std::shared_ptr<typename ServiceT::Response>(new typename ServiceT::Response);
@@ -223,8 +197,7 @@ public:
   }
 
   void send_response(
-    std::shared_ptr<rmw_request_id_t> req_id,
-    std::shared_ptr<typename ServiceT::Response> response)
+    std::shared_ptr<rmw_request_id_t> req_id, std::shared_ptr<typename ServiceT::Response> response)
   {
     rcl_ret_t status = rcl_send_response(get_service_handle().get(), req_id.get(), response.get());
 

rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp

@@ -42,7 +42,7 @@ namespace allocator_memory_strategy
  * the rmw implementation after the executor waits for work, based on the number of entities that
  * come through.
  */
-template<typename Alloc = std::allocator<void>>
+template <typename Alloc = std::allocator<void>>
 class AllocatorMemoryStrategy : public memory_strategy::MemoryStrategy
 {
 public:
@@ -56,10 +56,7 @@ public:
     allocator_ = std::make_shared<VoidAlloc>(*allocator.get());
   }
 
-  AllocatorMemoryStrategy()
-  {
-    allocator_ = std::make_shared<VoidAlloc>();
-  }
+  AllocatorMemoryStrategy() { allocator_ = std::make_shared<VoidAlloc>(); }
 
   void add_guard_condition(const rcl_guard_condition_t * guard_condition)
   {
@@ -126,28 +123,21 @@ public:
 
     subscription_handles_.erase(
       std::remove(subscription_handles_.begin(), subscription_handles_.end(), nullptr),
-      subscription_handles_.end()
-    );
+      subscription_handles_.end());
 
     service_handles_.erase(
       std::remove(service_handles_.begin(), service_handles_.end(), nullptr),
-      service_handles_.end()
-    );
+      service_handles_.end());
 
     client_handles_.erase(
-      std::remove(client_handles_.begin(), client_handles_.end(), nullptr),
-      client_handles_.end()
-    );
+      std::remove(client_handles_.begin(), client_handles_.end(), nullptr), client_handles_.end());
 
     timer_handles_.erase(
-      std::remove(timer_handles_.begin(), timer_handles_.end(), nullptr),
-      timer_handles_.end()
-    );
+      std::remove(timer_handles_.begin(), timer_handles_.end(), nullptr), timer_handles_.end());
 
     waitable_handles_.erase(
       std::remove(waitable_handles_.begin(), waitable_handles_.end(), nullptr),
-      waitable_handles_.end()
-    );
+      waitable_handles_.end());
   }
 
   bool collect_entities(const WeakNodeList & weak_nodes)
@@ -174,21 +164,21 @@ public:
             return false;
           });
         group->find_service_ptrs_if([this](const rclcpp::ServiceBase::SharedPtr & service) {
-            service_handles_.push_back(service->get_service_handle());
-            return false;
-          });
+          service_handles_.push_back(service->get_service_handle());
+          return false;
+        });
         group->find_client_ptrs_if([this](const rclcpp::ClientBase::SharedPtr & client) {
-            client_handles_.push_back(client->get_client_handle());
-            return false;
-          });
+          client_handles_.push_back(client->get_client_handle());
+          return false;
+        });
         group->find_timer_ptrs_if([this](const rclcpp::TimerBase::SharedPtr & timer) {
-            timer_handles_.push_back(timer->get_timer_handle());
-            return false;
-          });
+          timer_handles_.push_back(timer->get_timer_handle());
+          return false;
+        });
         group->find_waitable_ptrs_if([this](const rclcpp::Waitable::SharedPtr & waitable) {
-            waitable_handles_.push_back(waitable);
-            return false;
-          });
+          waitable_handles_.push_back(waitable);
+          return false;
+        });
       }
     }
     return has_invalid_weak_nodes;
@@ -199,8 +189,7 @@ public:
     for (auto subscription : subscription_handles_) {
       if (rcl_wait_set_add_subscription(wait_set, subscription.get(), NULL) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add subscription to wait set: %s", rcl_get_error_string().str);
+          "rclcpp", "Couldn't add subscription to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
@@ -208,8 +197,7 @@ public:
     for (auto client : client_handles_) {
       if (rcl_wait_set_add_client(wait_set, client.get(), NULL) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add client to wait set: %s", rcl_get_error_string().str);
+          "rclcpp", "Couldn't add client to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
@@ -217,8 +205,7 @@ public:
     for (auto service : service_handles_) {
       if (rcl_wait_set_add_service(wait_set, service.get(), NULL) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add service to wait set: %s", rcl_get_error_string().str);
+          "rclcpp", "Couldn't add service to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
@@ -226,8 +213,7 @@ public:
     for (auto timer : timer_handles_) {
       if (rcl_wait_set_add_timer(wait_set, timer.get(), NULL) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add timer to wait set: %s", rcl_get_error_string().str);
+          "rclcpp", "Couldn't add timer to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
@@ -235,9 +221,7 @@ public:
     for (auto guard_condition : guard_conditions_) {
       if (rcl_wait_set_add_guard_condition(wait_set, guard_condition, NULL) != RCL_RET_OK) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add guard_condition to wait set: %s",
-          rcl_get_error_string().str);
+          "rclcpp", "Couldn't add guard_condition to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
@@ -245,18 +229,15 @@ public:
     for (auto waitable : waitable_handles_) {
       if (!waitable->add_to_wait_set(wait_set)) {
         RCUTILS_LOG_ERROR_NAMED(
-          "rclcpp",
-          "Couldn't add waitable to wait set: %s", rcl_get_error_string().str);
+          "rclcpp", "Couldn't add waitable to wait set: %s", rcl_get_error_string().str);
         return false;
       }
     }
     return true;
   }
 
-  virtual void
-  get_next_subscription(
-    executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes)
+  virtual void get_next_subscription(
+    executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
   {
     auto it = subscription_handles_.begin();
     while (it != subscription_handles_.end()) {
@@ -297,10 +278,7 @@ public:
     }
   }
 
-  virtual void
-  get_next_service(
-    executor::AnyExecutable & any_exec,
-    const WeakNodeList & weak_nodes)
+  virtual void get_next_service(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
   {
     auto it = service_handles_.begin();
     while (it != service_handles_.end()) {
@@ -332,8 +310,7 @@ public:
     }
   }
 
-  virtual void
-  get_next_client(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
+  virtual void get_next_client(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
   {
     auto it = client_handles_.begin();
     while (it != client_handles_.end()) {
@@ -365,8 +342,8 @@ public:
     }
   }
 
-  virtual void
-  get_next_waitable(executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
+  virtual void get_next_waitable(
+    executor::AnyExecutable & any_exec, const WeakNodeList & weak_nodes)
   {
     auto it = waitable_handles_.begin();
     while (it != waitable_handles_.end()) {
@@ -457,13 +434,10 @@ public:
     return number_of_timers;
   }
 
-  size_t number_of_waitables() const
-  {
-    return waitable_handles_.size();
-  }
+  size_t number_of_waitables() const { return waitable_handles_.size(); }
 
 private:
-  template<typename T>
+  template <typename T>
   using VectorRebind =
     std::vector<T, typename std::allocator_traits<Alloc>::template rebind_alloc<T>>;
 

rclcpp/include/rclcpp/strategies/message_pool_memory_strategy.hpp

@@ -35,22 +35,17 @@ namespace message_pool_memory_strategy
  * The size of the message pool should be at least the largest number of concurrent accesses to
  * the subscription (usually the number of threads).
  */
-template<
-  typename MessageT,
-  size_t Size,
-  typename std::enable_if<
-    rosidl_generator_traits::has_fixed_size<MessageT>::value
-  >::type * = nullptr
->
-class MessagePoolMemoryStrategy
-  : public message_memory_strategy::MessageMemoryStrategy<MessageT>
+template <
+  typename MessageT, size_t Size,
+  typename std::enable_if<rosidl_generator_traits::has_fixed_size<MessageT>::value>::type * =
+    nullptr>
+class MessagePoolMemoryStrategy : public message_memory_strategy::MessageMemoryStrategy<MessageT>
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(MessagePoolMemoryStrategy)
 
   /// Default constructor
-  MessagePoolMemoryStrategy()
-  : next_array_index_(0)
+  MessagePoolMemoryStrategy() : next_array_index_(0)
   {
     for (size_t i = 0; i < Size; ++i) {
       pool_[i].msg_ptr_ = std::make_shared<MessageT>();
@@ -72,7 +67,7 @@ public:
       throw std::runtime_error("Tried to access message that was still in use! Abort.");
     }
     pool_[current_index].msg_ptr_->~MessageT();
-    new (pool_[current_index].msg_ptr_.get())MessageT;
+    new (pool_[current_index].msg_ptr_.get()) MessageT;
 
     pool_[current_index].used = true;
     return pool_[current_index].msg_ptr_;

rclcpp/include/rclcpp/subscription.hpp

@@ -25,7 +25,6 @@
 #include <string>
 #include <utility>
 
-
 #include "rcl/error_handling.h"
 #include "rcl/subscription.h"
 
@@ -53,9 +52,7 @@ class NodeTopicsInterface;
 }  // namespace node_interfaces
 
 /// Subscription implementation, templated on the type of message this subscription receives.
-template<
-  typename CallbackMessageT,
-  typename Alloc = std::allocator<void>>
+template <typename CallbackMessageT, typename Alloc = std::allocator<void>>
 class Subscription : public SubscriptionBase
 {
   friend class rclcpp::node_interfaces::NodeTopicsInterface;
@@ -82,32 +79,26 @@ public:
    */
   Subscription(
     std::shared_ptr<rcl_node_t> node_handle,
-    const rosidl_message_type_support_t & type_support_handle,
-    const std::string & topic_name,
+    const rosidl_message_type_support_t & type_support_handle, const std::string & topic_name,
     const rcl_subscription_options_t & subscription_options,
     AnySubscriptionCallback<CallbackMessageT, Alloc> callback,
     const SubscriptionEventCallbacks & event_callbacks,
     typename message_memory_strategy::MessageMemoryStrategy<CallbackMessageT, Alloc>::SharedPtr
-    memory_strategy = message_memory_strategy::MessageMemoryStrategy<CallbackMessageT,
-    Alloc>::create_default())
+      memory_strategy =
+        message_memory_strategy::MessageMemoryStrategy<CallbackMessageT, Alloc>::create_default())
   : SubscriptionBase(
-      node_handle,
-      type_support_handle,
-      topic_name,
-      subscription_options,
+      node_handle, type_support_handle, topic_name, subscription_options,
       rclcpp::subscription_traits::is_serialized_subscription_argument<CallbackMessageT>::value),
     any_callback_(callback),
     message_memory_strategy_(memory_strategy)
   {
     if (event_callbacks.deadline_callback) {
       this->add_event_handler(
-        event_callbacks.deadline_callback,
-        RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED);
+        event_callbacks.deadline_callback, RCL_SUBSCRIPTION_REQUESTED_DEADLINE_MISSED);
     }
     if (event_callbacks.liveliness_callback) {
       this->add_event_handler(
-        event_callbacks.liveliness_callback,
-        RCL_SUBSCRIPTION_LIVELINESS_CHANGED);
+        event_callbacks.liveliness_callback, RCL_SUBSCRIPTION_LIVELINESS_CHANGED);
     }
   }
 
@@ -117,8 +108,8 @@ public:
    * \param[in] message_memory_strategy Shared pointer to the memory strategy to set.
    */
   void set_message_memory_strategy(
-    typename message_memory_strategy::MessageMemoryStrategy<CallbackMessageT,
-    Alloc>::SharedPtr message_memory_strategy)
+    typename message_memory_strategy::MessageMemoryStrategy<CallbackMessageT, Alloc>::SharedPtr
+      message_memory_strategy)
   {
     message_memory_strategy_ = message_memory_strategy;
   }
@@ -162,8 +153,7 @@ public:
   }
 
   void handle_intra_process_message(
-    rcl_interfaces::msg::IntraProcessMessage & ipm,
-    const rmw_message_info_t & message_info)
+    rcl_interfaces::msg::IntraProcessMessage & ipm, const rmw_message_info_t & message_info)
   {
     if (!use_intra_process_) {
       // throw std::runtime_error(
@@ -182,10 +172,7 @@ public:
     if (any_callback_.use_take_shared_method()) {
       ConstMessageSharedPtr msg;
       take_intra_process_message(
-        ipm.publisher_id,
-        ipm.message_sequence,
-        intra_process_subscription_id_,
-        msg);
+        ipm.publisher_id, ipm.message_sequence, intra_process_subscription_id_, msg);
       if (!msg) {
         // This can happen when having two nodes in different process both using intraprocess
         // communication. It could happen too if the publisher no longer exists or the requested
@@ -198,10 +185,7 @@ public:
     } else {
       MessageUniquePtr msg;
       take_intra_process_message(
-        ipm.publisher_id,
-        ipm.message_sequence,
-        intra_process_subscription_id_,
-        msg);
+        ipm.publisher_id, ipm.message_sequence, intra_process_subscription_id_, msg);
       if (!msg) {
         // This can happen when having two nodes in different process both using intraprocess
         // communication. It could happen too if the publisher no longer exists or the requested
@@ -215,8 +199,7 @@ public:
   }
 
   /// Implemenation detail.
-  const std::shared_ptr<rcl_subscription_t>
-  get_intra_process_subscription_handle() const
+  const std::shared_ptr<rcl_subscription_t> get_intra_process_subscription_handle() const
   {
     if (!use_intra_process_) {
       return nullptr;
@@ -225,40 +208,33 @@ public:
   }
 
 private:
-  void
-  take_intra_process_message(
-    uint64_t publisher_id,
-    uint64_t message_sequence,
-    uint64_t subscription_id,
+  void take_intra_process_message(
+    uint64_t publisher_id, uint64_t message_sequence, uint64_t subscription_id,
     MessageUniquePtr & message)
   {
     auto ipm = weak_ipm_.lock();
     if (!ipm) {
       throw std::runtime_error(
-              "intra process take called after destruction of intra process manager");
+        "intra process take called after destruction of intra process manager");
     }
     ipm->template take_intra_process_message<CallbackMessageT, Alloc>(
       publisher_id, message_sequence, subscription_id, message);
   }
 
-  void
-  take_intra_process_message(
-    uint64_t publisher_id,
-    uint64_t message_sequence,
-    uint64_t subscription_id,
+  void take_intra_process_message(
+    uint64_t publisher_id, uint64_t message_sequence, uint64_t subscription_id,
     ConstMessageSharedPtr & message)
   {
     auto ipm = weak_ipm_.lock();
     if (!ipm) {
       throw std::runtime_error(
-              "intra process take called after destruction of intra process manager");
+        "intra process take called after destruction of intra process manager");
     }
     ipm->template take_intra_process_message<CallbackMessageT, Alloc>(
       publisher_id, message_sequence, subscription_id, message);
   }
 
-  bool
-  matches_any_intra_process_publishers(const rmw_gid_t * sender_gid)
+  bool matches_any_intra_process_publishers(const rmw_gid_t * sender_gid)
   {
     if (!use_intra_process_) {
       return false;
@@ -266,8 +242,8 @@ private:
     auto ipm = weak_ipm_.lock();
     if (!ipm) {
       throw std::runtime_error(
-              "intra process publisher check called "
-              "after destruction of intra process manager");
+        "intra process publisher check called "
+        "after destruction of intra process manager");
     }
     return ipm->matches_any_publishers(sender_gid);
   }

rclcpp/include/rclcpp/subscription_base.hpp

@@ -46,7 +46,7 @@ namespace intra_process_manager
  * `intra_process_manager.hpp` and `subscription_base.hpp`.
  */
 class IntraProcessManager;
-}
+}  // namespace intra_process_manager
 
 /// Virtual base class for subscriptions. This pattern allows us to iterate over different template
 /// specializations of Subscription, among other things.
@@ -66,10 +66,8 @@ public:
   RCLCPP_PUBLIC
   SubscriptionBase(
     std::shared_ptr<rcl_node_t> node_handle,
-    const rosidl_message_type_support_t & type_support_handle,
-    const std::string & topic_name,
-    const rcl_subscription_options_t & subscription_options,
-    bool is_serialized = false);
+    const rosidl_message_type_support_t & type_support_handle, const std::string & topic_name,
+    const rcl_subscription_options_t & subscription_options, bool is_serialized = false);
 
   /// Default destructor.
   RCLCPP_PUBLIC
@@ -77,26 +75,21 @@ public:
 
   /// Get the topic that this subscription is subscribed on.
   RCLCPP_PUBLIC
-  const char *
-  get_topic_name() const;
+  const char * get_topic_name() const;
 
   RCLCPP_PUBLIC
-  std::shared_ptr<rcl_subscription_t>
-  get_subscription_handle();
+  std::shared_ptr<rcl_subscription_t> get_subscription_handle();
 
   RCLCPP_PUBLIC
-  const std::shared_ptr<rcl_subscription_t>
-  get_subscription_handle() const;
+  const std::shared_ptr<rcl_subscription_t> get_subscription_handle() const;
 
   RCLCPP_PUBLIC
-  virtual const std::shared_ptr<rcl_subscription_t>
-  get_intra_process_subscription_handle() const;
+  virtual const std::shared_ptr<rcl_subscription_t> get_intra_process_subscription_handle() const;
 
   /// Get all the QoS event handlers associated with this subscription.
   /** \return The vector of QoS event handlers. */
   RCLCPP_PUBLIC
-  const std::vector<std::shared_ptr<rclcpp::QOSEventHandlerBase>> &
-  get_event_handlers() const;
+  const std::vector<std::shared_ptr<rclcpp::QOSEventHandlerBase>> & get_event_handlers() const;
 
   /// Get the actual QoS settings, after the defaults have been determined.
   /**
@@ -109,75 +102,59 @@ public:
    * \return The actual qos settings.
    */
   RCLCPP_PUBLIC
-  rmw_qos_profile_t
-  get_actual_qos() const;
+  rmw_qos_profile_t get_actual_qos() const;
 
   /// Borrow a new message.
   /** \return Shared pointer to the fresh message. */
-  virtual std::shared_ptr<void>
-  create_message() = 0;
+  virtual std::shared_ptr<void> create_message() = 0;
 
   /// Borrow a new serialized message
   /** \return Shared pointer to a rcl_message_serialized_t. */
-  virtual std::shared_ptr<rcl_serialized_message_t>
-  create_serialized_message() = 0;
+  virtual std::shared_ptr<rcl_serialized_message_t> create_serialized_message() = 0;
 
   /// Check if we need to handle the message, and execute the callback if we do.
   /**
    * \param[in] message Shared pointer to the message to handle.
    * \param[in] message_info Metadata associated with this message.
    */
-  virtual void
-  handle_message(std::shared_ptr<void> & message, const rmw_message_info_t & message_info) = 0;
+  virtual void handle_message(
+    std::shared_ptr<void> & message, const rmw_message_info_t & message_info) = 0;
 
   /// Return the message borrowed in create_message.
   /** \param[in] message Shared pointer to the returned message. */
-  virtual void
-  return_message(std::shared_ptr<void> & message) = 0;
+  virtual void return_message(std::shared_ptr<void> & message) = 0;
 
   /// Return the message borrowed in create_serialized_message.
   /** \param[in] message Shared pointer to the returned message. */
-  virtual void
-  return_serialized_message(std::shared_ptr<rcl_serialized_message_t> & message) = 0;
+  virtual void return_serialized_message(std::shared_ptr<rcl_serialized_message_t> & message) = 0;
 
-  virtual void
-  handle_intra_process_message(
-    rcl_interfaces::msg::IntraProcessMessage & ipm,
-    const rmw_message_info_t & message_info) = 0;
+  virtual void handle_intra_process_message(
+    rcl_interfaces::msg::IntraProcessMessage & ipm, const rmw_message_info_t & message_info) = 0;
 
-  const rosidl_message_type_support_t &
-  get_message_type_support_handle() const;
+  const rosidl_message_type_support_t & get_message_type_support_handle() const;
 
-  bool
-  is_serialized() const;
+  bool is_serialized() const;
 
   /// Get matching publisher count.
   /** \return The number of publishers on this topic. */
   RCLCPP_PUBLIC
-  size_t
-  get_publisher_count() const;
+  size_t get_publisher_count() const;
 
   using IntraProcessManagerWeakPtr =
     std::weak_ptr<rclcpp::intra_process_manager::IntraProcessManager>;
 
   /// Implemenation detail.
   void setup_intra_process(
-    uint64_t intra_process_subscription_id,
-    IntraProcessManagerWeakPtr weak_ipm,
+    uint64_t intra_process_subscription_id, IntraProcessManagerWeakPtr weak_ipm,
     const rcl_subscription_options_t & intra_process_options);
 
 protected:
-  template<typename EventCallbackT>
-  void
-  add_event_handler(
-    const EventCallbackT & callback,
-    const rcl_subscription_event_type_t event_type)
+  template <typename EventCallbackT>
+  void add_event_handler(
+    const EventCallbackT & callback, const rcl_subscription_event_type_t event_type)
   {
     auto handler = std::make_shared<QOSEventHandler<EventCallbackT>>(
-      callback,
-      rcl_subscription_event_init,
-      get_subscription_handle().get(),
-      event_type);
+      callback, rcl_subscription_event_init, get_subscription_handle().get(), event_type);
     event_handlers_.emplace_back(handler);
   }
 

rclcpp/include/rclcpp/subscription_factory.hpp

@@ -24,10 +24,10 @@
 
 #include "rosidl_typesupport_cpp/message_type_support.hpp"
 
-#include "rclcpp/subscription.hpp"
-#include "rclcpp/subscription_traits.hpp"
 #include "rclcpp/intra_process_manager.hpp"
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
+#include "rclcpp/subscription.hpp"
+#include "rclcpp/subscription_traits.hpp"
 #include "rclcpp/visibility_control.hpp"
 
 namespace rclcpp
@@ -47,38 +47,29 @@ namespace rclcpp
 struct SubscriptionFactory
 {
   // Creates a Subscription<MessageT> object and returns it as a SubscriptionBase.
-  using SubscriptionFactoryFunction = std::function<
-    rclcpp::SubscriptionBase::SharedPtr(
-      rclcpp::node_interfaces::NodeBaseInterface * node_base,
-      const std::string & topic_name,
-      const rcl_subscription_options_t & subscription_options)>;
+  using SubscriptionFactoryFunction = std::function<rclcpp::SubscriptionBase::SharedPtr(
+    rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic_name,
+    const rcl_subscription_options_t & subscription_options)>;
 
   SubscriptionFactoryFunction create_typed_subscription;
 
   // Function that takes a MessageT from the intra process manager
-  using SetupIntraProcessFunction = std::function<
-    void (
-      rclcpp::intra_process_manager::IntraProcessManager::SharedPtr ipm,
-      rclcpp::SubscriptionBase::SharedPtr subscription,
-      const rcl_subscription_options_t & subscription_options)>;
+  using SetupIntraProcessFunction = std::function<void(
+    rclcpp::intra_process_manager::IntraProcessManager::SharedPtr ipm,
+    rclcpp::SubscriptionBase::SharedPtr subscription,
+    const rcl_subscription_options_t & subscription_options)>;
 
   SetupIntraProcessFunction setup_intra_process;
 };
 
 /// Return a SubscriptionFactory with functions for creating a SubscriptionT<MessageT, Alloc>.
-template<
-  typename MessageT,
-  typename CallbackT,
-  typename Alloc,
-  typename CallbackMessageT,
+template <
+  typename MessageT, typename CallbackT, typename Alloc, typename CallbackMessageT,
   typename SubscriptionT>
-SubscriptionFactory
-create_subscription_factory(
-  CallbackT && callback,
-  const SubscriptionEventCallbacks & event_callbacks,
+SubscriptionFactory create_subscription_factory(
+  CallbackT && callback, const SubscriptionEventCallbacks & event_callbacks,
   typename rclcpp::message_memory_strategy::MessageMemoryStrategy<
-    CallbackMessageT, Alloc>::SharedPtr
-  msg_mem_strat,
+    CallbackMessageT, Alloc>::SharedPtr msg_mem_strat,
   std::shared_ptr<Alloc> allocator)
 {
   SubscriptionFactory factory;
@@ -93,29 +84,23 @@ create_subscription_factory(
   // factory function that creates a MessageT specific SubscriptionT
   factory.create_typed_subscription =
     [allocator, msg_mem_strat, any_subscription_callback, event_callbacks, message_alloc](
-    rclcpp::node_interfaces::NodeBaseInterface * node_base,
-    const std::string & topic_name,
-    const rcl_subscription_options_t & subscription_options
-    ) -> rclcpp::SubscriptionBase::SharedPtr
-    {
-      auto options_copy = subscription_options;
-      options_copy.allocator =
-        rclcpp::allocator::get_rcl_allocator<CallbackMessageT>(*message_alloc.get());
+      rclcpp::node_interfaces::NodeBaseInterface * node_base, const std::string & topic_name,
+      const rcl_subscription_options_t & subscription_options)
+    -> rclcpp::SubscriptionBase::SharedPtr {
+    auto options_copy = subscription_options;
+    options_copy.allocator =
+      rclcpp::allocator::get_rcl_allocator<CallbackMessageT>(*message_alloc.get());
 
-      using rclcpp::Subscription;
-      using rclcpp::SubscriptionBase;
+    using rclcpp::Subscription;
+    using rclcpp::SubscriptionBase;
 
-      auto sub = Subscription<CallbackMessageT, Alloc>::make_shared(
-        node_base->get_shared_rcl_node_handle(),
-        *rosidl_typesupport_cpp::get_message_type_support_handle<MessageT>(),
-        topic_name,
-        options_copy,
-        any_subscription_callback,
-        event_callbacks,
-        msg_mem_strat);
-      auto sub_base_ptr = std::dynamic_pointer_cast<SubscriptionBase>(sub);
-      return sub_base_ptr;
-    };
+    auto sub = Subscription<CallbackMessageT, Alloc>::make_shared(
+      node_base->get_shared_rcl_node_handle(),
+      *rosidl_typesupport_cpp::get_message_type_support_handle<MessageT>(), topic_name,
+      options_copy, any_subscription_callback, event_callbacks, msg_mem_strat);
+    auto sub_base_ptr = std::dynamic_pointer_cast<SubscriptionBase>(sub);
+    return sub_base_ptr;
+  };
 
   // return the factory now that it is populated
   return factory;

rclcpp/include/rclcpp/subscription_options.hpp

@@ -42,7 +42,7 @@ struct SubscriptionOptionsBase
 };
 
 /// Structure containing optional configuration for Subscriptions.
-template<typename Allocator>
+template <typename Allocator>
 struct SubscriptionOptionsWithAllocator : public SubscriptionOptionsBase
 {
   /// Optional custom allocator.
@@ -54,12 +54,12 @@ struct SubscriptionOptionsWithAllocator : public SubscriptionOptionsBase
   explicit SubscriptionOptionsWithAllocator(
     const SubscriptionOptionsBase & subscription_options_base)
   : SubscriptionOptionsBase(subscription_options_base)
-  {}
+  {
+  }
 
   /// Convert this class, with a rclcpp::QoS, into an rcl_subscription_options_t.
-  template<typename MessageT>
-  rcl_subscription_options_t
-  to_rcl_subscription_options(const rclcpp::QoS & qos) const
+  template <typename MessageT>
+  rcl_subscription_options_t to_rcl_subscription_options(const rclcpp::QoS & qos) const
   {
     rcl_subscription_options_t result;
     using AllocatorTraits = std::allocator_traits<Allocator>;

rclcpp/include/rclcpp/subscription_traits.hpp

@@ -17,8 +17,8 @@
 
 #include <memory>
 
-#include "rclcpp/function_traits.hpp"
 #include "rcl/types.h"
+#include "rclcpp/function_traits.hpp"
 
 namespace rclcpp
 {
@@ -36,60 +36,66 @@ namespace subscription_traits
  * when no template is used, the colon has to be separated by a space.
  * Cheers!
  */
-template<typename T>
+template <typename T>
 struct is_serialized_subscription_argument : std::false_type
-{};
+{
+};
 
-template<>
-struct is_serialized_subscription_argument<rcl_serialized_message_t>: std::true_type
-{};
+template <>
+struct is_serialized_subscription_argument<rcl_serialized_message_t> : std::true_type
+{
+};
 
-template<>
+template <>
 struct is_serialized_subscription_argument<std::shared_ptr<rcl_serialized_message_t>>
-  : std::true_type
-{};
+: std::true_type
+{
+};
 
-template<typename T>
+template <typename T>
 struct is_serialized_subscription : is_serialized_subscription_argument<T>
-{};
+{
+};
 
-template<typename CallbackT>
+template <typename CallbackT>
 struct is_serialized_callback
-  : is_serialized_subscription_argument<
+: is_serialized_subscription_argument<
     typename rclcpp::function_traits::function_traits<CallbackT>::template argument_type<0>>
-{};
+{
+};
 
-template<typename MessageT>
+template <typename MessageT>
 struct extract_message_type
 {
   using type = typename std::remove_cv<MessageT>::type;
 };
 
-template<typename MessageT>
-struct extract_message_type<std::shared_ptr<MessageT>>: extract_message_type<MessageT>
-{};
+template <typename MessageT>
+struct extract_message_type<std::shared_ptr<MessageT>> : extract_message_type<MessageT>
+{
+};
 
-template<typename MessageT, typename Deleter>
-struct extract_message_type<std::unique_ptr<MessageT, Deleter>>: extract_message_type<MessageT>
-{};
+template <typename MessageT, typename Deleter>
+struct extract_message_type<std::unique_ptr<MessageT, Deleter>> : extract_message_type<MessageT>
+{
+};
 
-template<
+template <
   typename CallbackT,
   // Do not attempt if CallbackT is an integer (mistaken for depth)
-  typename = std::enable_if_t<!std::is_integral<
-    std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>,
+  typename = std::enable_if_t<
+    !std::is_integral<std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>,
   // Do not attempt if CallbackT is a QoS (mistaken for qos)
-  typename = std::enable_if_t<!std::is_base_of<
-    rclcpp::QoS,
-    std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>,
+  typename = std::enable_if_t<
+    !std::is_base_of<rclcpp::QoS, std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>,
   // Do not attempt if CallbackT is a rmw_qos_profile_t (mistaken for qos profile)
-  typename = std::enable_if_t<!std::is_same<
-    rmw_qos_profile_t,
-    std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>
->
-struct has_message_type : extract_message_type<
+  typename = std::enable_if_t<
+    !std::is_same<rmw_qos_profile_t, std::remove_cv_t<std::remove_reference_t<CallbackT>>>::value>>
+struct has_message_type
+: extract_message_type<
     typename rclcpp::function_traits::function_traits<CallbackT>::template argument_type<0>>
-{};
+{
+};
 
 }  // namespace subscription_traits
 }  // namespace rclcpp

rclcpp/include/rclcpp/time.hpp

@@ -41,9 +41,7 @@ public:
   Time(const Time & rhs);
 
   RCLCPP_PUBLIC
-  Time(
-    const builtin_interfaces::msg::Time & time_msg,
-    rcl_clock_type_t ros_time = RCL_ROS_TIME);
+  Time(const builtin_interfaces::msg::Time & time_msg, rcl_clock_type_t ros_time = RCL_ROS_TIME);
 
   RCLCPP_PUBLIC
   explicit Time(const rcl_time_point_t & time_point);
@@ -55,75 +53,59 @@ public:
   operator builtin_interfaces::msg::Time() const;
 
   RCLCPP_PUBLIC
-  Time &
-  operator=(const Time & rhs);
+  Time & operator=(const Time & rhs);
 
   RCLCPP_PUBLIC
-  Time &
-  operator=(const builtin_interfaces::msg::Time & time_msg);
+  Time & operator=(const builtin_interfaces::msg::Time & time_msg);
 
   RCLCPP_PUBLIC
-  bool
-  operator==(const rclcpp::Time & rhs) const;
+  bool operator==(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  bool
-  operator!=(const rclcpp::Time & rhs) const;
+  bool operator!=(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  bool
-  operator<(const rclcpp::Time & rhs) const;
+  bool operator<(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  bool
-  operator<=(const rclcpp::Time & rhs) const;
+  bool operator<=(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  bool
-  operator>=(const rclcpp::Time & rhs) const;
+  bool operator>=(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  bool
-  operator>(const rclcpp::Time & rhs) const;
+  bool operator>(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  Time
-  operator+(const rclcpp::Duration & rhs) const;
+  Time operator+(const rclcpp::Duration & rhs) const;
 
   RCLCPP_PUBLIC
-  Duration
-  operator-(const rclcpp::Time & rhs) const;
+  Duration operator-(const rclcpp::Time & rhs) const;
 
   RCLCPP_PUBLIC
-  Time
-  operator-(const rclcpp::Duration & rhs) const;
+  Time operator-(const rclcpp::Duration & rhs) const;
 
   RCLCPP_PUBLIC
-  rcl_time_point_value_t
-  nanoseconds() const;
+  rcl_time_point_value_t nanoseconds() const;
 
   RCLCPP_PUBLIC
-  static Time
-  max();
+  static Time max();
 
   /// \return the seconds since epoch as a floating point number.
   /// \warning Depending on sizeof(double) there could be significant precision loss.
   /// When an exact time is required use nanoseconds() instead.
   RCLCPP_PUBLIC
-  double
-  seconds() const;
+  double seconds() const;
 
   RCLCPP_PUBLIC
-  rcl_clock_type_t
-  get_clock_type() const;
+  rcl_clock_type_t get_clock_type() const;
 
 private:
   rcl_time_point_t rcl_time_;
   friend Clock;  // Allow clock to manipulate internal data
 };
 
-Time
-operator+(const rclcpp::Duration & lhs, const rclcpp::Time & rhs);
+Time operator+(const rclcpp::Duration & lhs, const rclcpp::Time & rhs);
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/time_source.hpp

@@ -21,12 +21,11 @@
 #include "rcl/time.h"
 
 #include "builtin_interfaces/msg/time.hpp"
-#include "rosgraph_msgs/msg/clock.hpp"
 #include "rcl_interfaces/msg/parameter_event.hpp"
+#include "rosgraph_msgs/msg/clock.hpp"
 
 #include "rclcpp/node.hpp"
 
-
 namespace rclcpp
 {
 class Clock;
@@ -107,7 +106,7 @@ private:
   void on_parameter_event(const rcl_interfaces::msg::ParameterEvent::SharedPtr event);
 
   // An enum to hold the parameter state
-  enum UseSimTimeParameterState {UNSET, SET_TRUE, SET_FALSE};
+  enum UseSimTimeParameterState { UNSET, SET_TRUE, SET_FALSE };
   UseSimTimeParameterState parameter_state_;
 
   // An internal method to use in the clock callback that iterates and enables all clocks
@@ -119,8 +118,7 @@ private:
   static void enable_ros_time(rclcpp::Clock::SharedPtr clock);
   static void disable_ros_time(rclcpp::Clock::SharedPtr clock);
   static void set_clock(
-    const builtin_interfaces::msg::Time::SharedPtr msg,
-    bool set_ros_time_enabled,
+    const builtin_interfaces::msg::Time::SharedPtr msg, bool set_ros_time_enabled,
     rclcpp::Clock::SharedPtr clock);
 
   // Local storage of validity of ROS time

rclcpp/include/rclcpp/timer.hpp

@@ -47,16 +47,13 @@ public:
 
   RCLCPP_PUBLIC
   explicit TimerBase(
-    Clock::SharedPtr clock,
-    std::chrono::nanoseconds period,
-    rclcpp::Context::SharedPtr context);
+    Clock::SharedPtr clock, std::chrono::nanoseconds period, rclcpp::Context::SharedPtr context);
 
   RCLCPP_PUBLIC
   ~TimerBase();
 
   RCLCPP_PUBLIC
-  void
-  cancel();
+  void cancel();
 
   /// Return the timer cancellation state.
   /**
@@ -65,26 +62,21 @@ public:
    * \throws RCLErrorBase some child class exception based on ret
    */
   RCLCPP_PUBLIC
-  bool
-  is_canceled();
+  bool is_canceled();
 
   RCLCPP_PUBLIC
-  void
-  reset();
+  void reset();
 
   RCLCPP_PUBLIC
-  virtual void
-  execute_callback() = 0;
+  virtual void execute_callback() = 0;
 
   RCLCPP_PUBLIC
-  std::shared_ptr<const rcl_timer_t>
-  get_timer_handle();
+  std::shared_ptr<const rcl_timer_t> get_timer_handle();
 
   /// Check how long the timer has until its next scheduled callback.
   /** \return A std::chrono::duration representing the relative time until the next callback. */
   RCLCPP_PUBLIC
-  std::chrono::nanoseconds
-  time_until_trigger();
+  std::chrono::nanoseconds time_until_trigger();
 
   /// Is the clock steady (i.e. is the time between ticks constant?)
   /** \return True if the clock used by this timer is steady. */
@@ -104,18 +96,15 @@ protected:
   std::shared_ptr<rcl_timer_t> timer_handle_;
 };
 
-
-using VoidCallbackType = std::function<void ()>;
-using TimerCallbackType = std::function<void (TimerBase &)>;
+using VoidCallbackType = std::function<void()>;
+using TimerCallbackType = std::function<void(TimerBase &)>;
 
 /// Generic timer. Periodically executes a user-specified callback.
-template<
+template <
   typename FunctorT,
   typename std::enable_if<
     rclcpp::function_traits::same_arguments<FunctorT, VoidCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value
-  >::type * = nullptr
->
+    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value>::type * = nullptr>
 class GenericTimer : public TimerBase
 {
 public:
@@ -129,8 +118,7 @@ public:
    */
   explicit GenericTimer(
     Clock::SharedPtr clock, std::chrono::nanoseconds period, FunctorT && callback,
-    rclcpp::Context::SharedPtr context
-  )
+    rclcpp::Context::SharedPtr context)
   : TimerBase(clock, period, context), callback_(std::forward<FunctorT>(callback))
   {
   }
@@ -142,8 +130,7 @@ public:
     cancel();
   }
 
-  void
-  execute_callback() override
+  void execute_callback() override
   {
     rcl_ret_t ret = rcl_timer_call(timer_handle_.get());
     if (ret == RCL_RET_TIMER_CANCELED) {
@@ -156,35 +143,23 @@ public:
   }
 
   // void specialization
-  template<
-    typename CallbackT = FunctorT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<CallbackT, VoidCallbackType>::value
-    >::type * = nullptr
-  >
-  void
-  execute_callback_delegate()
+  template <
+    typename CallbackT = FunctorT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                                     CallbackT, VoidCallbackType>::value>::type * = nullptr>
+  void execute_callback_delegate()
   {
     callback_();
   }
 
-  template<
-    typename CallbackT = FunctorT,
-    typename std::enable_if<
-      rclcpp::function_traits::same_arguments<CallbackT, TimerCallbackType>::value
-    >::type * = nullptr
-  >
-  void
-  execute_callback_delegate()
+  template <
+    typename CallbackT = FunctorT, typename std::enable_if<rclcpp::function_traits::same_arguments<
+                                     CallbackT, TimerCallbackType>::value>::type * = nullptr>
+  void execute_callback_delegate()
   {
     callback_(*this);
   }
 
-  bool
-  is_steady() override
-  {
-    return clock_->get_clock_type() == RCL_STEADY_TIME;
-  }
+  bool is_steady() override { return clock_->get_clock_type() == RCL_STEADY_TIME; }
 
 protected:
   RCLCPP_DISABLE_COPY(GenericTimer)
@@ -192,25 +167,22 @@ protected:
   FunctorT callback_;
 };
 
-template<
+template <
   typename FunctorT,
   typename std::enable_if<
     rclcpp::function_traits::same_arguments<FunctorT, VoidCallbackType>::value ||
-    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value
-  >::type * = nullptr
->
+    rclcpp::function_traits::same_arguments<FunctorT, TimerCallbackType>::value>::type * = nullptr>
 class WallTimer : public GenericTimer<FunctorT>
 {
 public:
   RCLCPP_SMART_PTR_DEFINITIONS(WallTimer)
 
   WallTimer(
-    std::chrono::nanoseconds period,
-    FunctorT && callback,
-    rclcpp::Context::SharedPtr context)
+    std::chrono::nanoseconds period, FunctorT && callback, rclcpp::Context::SharedPtr context)
   : GenericTimer<FunctorT>(
       std::make_shared<Clock>(RCL_STEADY_TIME), period, std::move(callback), context)
-  {}
+  {
+  }
 
 protected:
   RCLCPP_DISABLE_COPY(WallTimer)

rclcpp/include/rclcpp/type_support_decl.hpp

@@ -29,48 +29,37 @@ namespace type_support
 {
 
 RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_intra_process_message_msg_type_support();
+const rosidl_message_type_support_t * get_intra_process_message_msg_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_parameter_event_msg_type_support();
+const rosidl_message_type_support_t * get_parameter_event_msg_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_set_parameters_result_msg_type_support();
+const rosidl_message_type_support_t * get_set_parameters_result_msg_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_parameter_descriptor_msg_type_support();
+const rosidl_message_type_support_t * get_parameter_descriptor_msg_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_message_type_support_t *
-get_list_parameters_result_msg_type_support();
+const rosidl_message_type_support_t * get_list_parameters_result_msg_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_get_parameters_srv_type_support();
+const rosidl_service_type_support_t * get_get_parameters_srv_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_get_parameter_types_srv_type_support();
+const rosidl_service_type_support_t * get_get_parameter_types_srv_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_set_parameters_srv_type_support();
+const rosidl_service_type_support_t * get_set_parameters_srv_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_list_parameters_srv_type_support();
+const rosidl_service_type_support_t * get_list_parameters_srv_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_describe_parameters_srv_type_support();
+const rosidl_service_type_support_t * get_describe_parameters_srv_type_support();
 
 RCLCPP_PUBLIC
-const rosidl_service_type_support_t *
-get_set_parameters_atomically_srv_type_support();
+const rosidl_service_type_support_t * get_set_parameters_atomically_srv_type_support();
 
 }  // namespace type_support
 }  // namespace rclcpp

rclcpp/include/rclcpp/utilities.hpp

@@ -30,14 +30,14 @@
 
 namespace std
 {
-template<typename T>
+template <typename T>
 std::string to_string(T value)
 {
   std::ostringstream os;
   os << value;
   return os.str();
 }
-}
+}  // namespace std
 #endif
 
 namespace rclcpp
@@ -52,8 +52,7 @@ namespace rclcpp
  * \sa rclcpp::Context::init() for more details on arguments and possible exceptions
  */
 RCLCPP_PUBLIC
-void
-init(int argc, char const * const argv[], const InitOptions & init_options = InitOptions());
+void init(int argc, char const * const argv[], const InitOptions & init_options = InitOptions());
 
 /// Install the global signal handler for rclcpp.
 /**
@@ -70,13 +69,11 @@ init(int argc, char const * const argv[], const InitOptions & init_options = Ini
  * \return true if signal handler was installed by this function, false if already installed.
  */
 RCLCPP_PUBLIC
-bool
-install_signal_handlers();
+bool install_signal_handlers();
 
 /// Return true if the signal handlers are installed, otherwise false.
 RCLCPP_PUBLIC
-bool
-signal_handlers_installed();
+bool signal_handlers_installed();
 
 /// Uninstall the global signal handler for rclcpp.
 /**
@@ -92,8 +89,7 @@ signal_handlers_installed();
  * \return true if signal handler was uninstalled by this function, false if was not installed.
  */
 RCLCPP_PUBLIC
-bool
-uninstall_signal_handlers();
+bool uninstall_signal_handlers();
 
 /// Initialize communications via the rmw implementation and set up a global signal handler.
 /**
@@ -104,11 +100,8 @@ uninstall_signal_handlers();
  * \throws anything remove_ros_arguments can throw
  */
 RCLCPP_PUBLIC
-std::vector<std::string>
-init_and_remove_ros_arguments(
-  int argc,
-  char const * const argv[],
-  const InitOptions & init_options = InitOptions());
+std::vector<std::string> init_and_remove_ros_arguments(
+  int argc, char const * const argv[], const InitOptions & init_options = InitOptions());
 
 /// Remove ROS-specific arguments from argument vector.
 /**
@@ -124,8 +117,7 @@ init_and_remove_ros_arguments(
  * \throws rclcpp::exceptions::RCLErrorBase if the parsing fails
  */
 RCLCPP_PUBLIC
-std::vector<std::string>
-remove_ros_arguments(int argc, char const * const argv[]);
+std::vector<std::string> remove_ros_arguments(int argc, char const * const argv[]);
 
 /// Check rclcpp's status.
 /**
@@ -140,8 +132,7 @@ remove_ros_arguments(int argc, char const * const argv[]);
  * \return true if shutdown has been called, false otherwise
  */
 RCLCPP_PUBLIC
-bool
-ok(rclcpp::Context::SharedPtr context = nullptr);
+bool ok(rclcpp::Context::SharedPtr context = nullptr);
 
 /// Return true if init() has already been called for the given context.
 /**
@@ -154,8 +145,7 @@ ok(rclcpp::Context::SharedPtr context = nullptr);
  * \return true if the context is initialized, and false otherwise
  */
 RCLCPP_PUBLIC
-bool
-is_initialized(rclcpp::Context::SharedPtr context = nullptr);
+bool is_initialized(rclcpp::Context::SharedPtr context = nullptr);
 
 /// Shutdown rclcpp context, invalidating it for derived entities.
 /**
@@ -171,8 +161,7 @@ is_initialized(rclcpp::Context::SharedPtr context = nullptr);
  * \return true if shutdown was successful, false if context was already shutdown
  */
 RCLCPP_PUBLIC
-bool
-shutdown(
+bool shutdown(
   rclcpp::Context::SharedPtr context = nullptr,
   const std::string & reason = "user called rclcpp::shutdown()");
 
@@ -192,8 +181,7 @@ shutdown(
  * \param[in] context with which to associate the context
  */
 RCLCPP_PUBLIC
-void
-on_shutdown(std::function<void()> callback, rclcpp::Context::SharedPtr context = nullptr);
+void on_shutdown(std::function<void()> callback, rclcpp::Context::SharedPtr context = nullptr);
 
 /// Use the global condition variable to block for the specified amount of time.
 /**
@@ -209,10 +197,8 @@ on_shutdown(std::function<void()> callback, rclcpp::Context::SharedPtr context =
  * \return true if the condition variable did not timeout.
  */
 RCLCPP_PUBLIC
-bool
-sleep_for(
-  const std::chrono::nanoseconds & nanoseconds,
-  rclcpp::Context::SharedPtr context = nullptr);
+bool sleep_for(
+  const std::chrono::nanoseconds & nanoseconds, rclcpp::Context::SharedPtr context = nullptr);
 
 /// Safely check if addition will overflow.
 /**
@@ -224,9 +210,8 @@ sleep_for(
  * \tparam T is type of the operands.
  * \return True if the x + y sum is greater than T::max value.
  */
-template<typename T>
-bool
-add_will_overflow(const T x, const T y)
+template <typename T>
+bool add_will_overflow(const T x, const T y)
 {
   return (y > 0) && (x > (std::numeric_limits<T>::max() - y));
 }
@@ -241,9 +226,8 @@ add_will_overflow(const T x, const T y)
  * \tparam T is type of the operands.
  * \return True if the x + y sum is less than T::min value.
  */
-template<typename T>
-bool
-add_will_underflow(const T x, const T y)
+template <typename T>
+bool add_will_underflow(const T x, const T y)
 {
   return (y < 0) && (x < (std::numeric_limits<T>::min() - y));
 }
@@ -258,9 +242,8 @@ add_will_underflow(const T x, const T y)
  * \tparam T is type of the operands.
  * \return True if the difference `x - y` sum is grater than T::max value.
  */
-template<typename T>
-bool
-sub_will_overflow(const T x, const T y)
+template <typename T>
+bool sub_will_overflow(const T x, const T y)
 {
   return (y < 0) && (x > (std::numeric_limits<T>::max() + y));
 }
@@ -275,9 +258,8 @@ sub_will_overflow(const T x, const T y)
  * \tparam T is type of the operands.
  * \return True if the difference `x - y` sum is less than T::min value.
  */
-template<typename T>
-bool
-sub_will_underflow(const T x, const T y)
+template <typename T>
+bool sub_will_underflow(const T x, const T y)
 {
   return (y > 0) && (x < (std::numeric_limits<T>::min() + y));
 }
@@ -290,8 +272,7 @@ sub_will_underflow(const T x, const T y)
  * \return the given string
  */
 RCLCPP_PUBLIC
-const char *
-get_c_string(const char * string_in);
+const char * get_c_string(const char * string_in);
 
 /// Return the C string from the given std::string.
 /**
@@ -299,8 +280,7 @@ get_c_string(const char * string_in);
  * \return the C string from the std::string
  */
 RCLCPP_PUBLIC
-const char *
-get_c_string(const std::string & string_in);
+const char * get_c_string(const std::string & string_in);
 
 }  // namespace rclcpp
 

rclcpp/include/rclcpp/visibility_control.hpp

@@ -26,31 +26,31 @@
 //     https://gcc.gnu.org/wiki/Visibility
 
 #if defined _WIN32 || defined __CYGWIN__
-  #ifdef __GNUC__
-    #define RCLCPP_EXPORT __attribute__ ((dllexport))
-    #define RCLCPP_IMPORT __attribute__ ((dllimport))
-  #else
-    #define RCLCPP_EXPORT __declspec(dllexport)
-    #define RCLCPP_IMPORT __declspec(dllimport)
-  #endif
-  #ifdef RCLCPP_BUILDING_LIBRARY
-    #define RCLCPP_PUBLIC RCLCPP_EXPORT
-  #else
-    #define RCLCPP_PUBLIC RCLCPP_IMPORT
-  #endif
-  #define RCLCPP_PUBLIC_TYPE RCLCPP_PUBLIC
-  #define RCLCPP_LOCAL
+#ifdef __GNUC__
+#define RCLCPP_EXPORT __attribute__((dllexport))
+#define RCLCPP_IMPORT __attribute__((dllimport))
 #else
-  #define RCLCPP_EXPORT __attribute__ ((visibility("default")))
-  #define RCLCPP_IMPORT
-  #if __GNUC__ >= 4
-    #define RCLCPP_PUBLIC __attribute__ ((visibility("default")))
-    #define RCLCPP_LOCAL  __attribute__ ((visibility("hidden")))
-  #else
-    #define RCLCPP_PUBLIC
-    #define RCLCPP_LOCAL
-  #endif
-  #define RCLCPP_PUBLIC_TYPE
+#define RCLCPP_EXPORT __declspec(dllexport)
+#define RCLCPP_IMPORT __declspec(dllimport)
+#endif
+#ifdef RCLCPP_BUILDING_LIBRARY
+#define RCLCPP_PUBLIC RCLCPP_EXPORT
+#else
+#define RCLCPP_PUBLIC RCLCPP_IMPORT
+#endif
+#define RCLCPP_PUBLIC_TYPE RCLCPP_PUBLIC
+#define RCLCPP_LOCAL
+#else
+#define RCLCPP_EXPORT __attribute__((visibility("default")))
+#define RCLCPP_IMPORT
+#if __GNUC__ >= 4
+#define RCLCPP_PUBLIC __attribute__((visibility("default")))
+#define RCLCPP_LOCAL __attribute__((visibility("hidden")))
+#else
+#define RCLCPP_PUBLIC
+#define RCLCPP_LOCAL
+#endif
+#define RCLCPP_PUBLIC_TYPE
 #endif
 
 #endif  // RCLCPP__VISIBILITY_CONTROL_HPP_

rclcpp/include/rclcpp/waitable.hpp

@@ -35,9 +35,7 @@ public:
    * \return The number of subscriptions associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_subscriptions();
+  virtual size_t get_number_of_ready_subscriptions();
 
   /// Get the number of ready timers
   /**
@@ -46,9 +44,7 @@ public:
    * \return The number of timers associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_timers();
+  virtual size_t get_number_of_ready_timers();
 
   /// Get the number of ready clients
   /**
@@ -57,9 +53,7 @@ public:
    * \return The number of clients associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_clients();
+  virtual size_t get_number_of_ready_clients();
 
   /// Get the number of ready events
   /**
@@ -68,9 +62,7 @@ public:
    * \return The number of events associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_events();
+  virtual size_t get_number_of_ready_events();
 
   /// Get the number of ready services
   /**
@@ -79,9 +71,7 @@ public:
    * \return The number of services associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_services();
+  virtual size_t get_number_of_ready_services();
 
   /// Get the number of ready guard_conditions
   /**
@@ -90,9 +80,7 @@ public:
    * \return The number of guard_conditions associated with the Waitable.
    */
   RCLCPP_PUBLIC
-  virtual
-  size_t
-  get_number_of_ready_guard_conditions();
+  virtual size_t get_number_of_ready_guard_conditions();
 
   // TODO(jacobperron): smart pointer?
   /// Add the Waitable to a wait set.
@@ -102,9 +90,7 @@ public:
    * \throws rclcpp::execptions::RCLError from rcl_wait_set_add_*()
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  add_to_wait_set(rcl_wait_set_t * wait_set) = 0;
+  virtual bool add_to_wait_set(rcl_wait_set_t * wait_set) = 0;
 
   /// Check if the Waitable is ready.
   /**
@@ -117,9 +103,7 @@ public:
    * \return `true` if the Waitable is ready, `false` otherwise.
    */
   RCLCPP_PUBLIC
-  virtual
-  bool
-  is_ready(rcl_wait_set_t *) = 0;
+  virtual bool is_ready(rcl_wait_set_t *) = 0;
 
   /// Execute any entities of the Waitable that are ready.
   /**
@@ -143,9 +127,7 @@ public:
    * ```
    */
   RCLCPP_PUBLIC
-  virtual
-  void
-  execute() = 0;
+  virtual void execute() = 0;
 };  // class Waitable
 
 }  // namespace rclcpp

rclcpp/src/rclcpp/any_executable.cpp

@@ -24,7 +24,8 @@ AnyExecutable::AnyExecutable()
   client(nullptr),
   callback_group(nullptr),
   node_base(nullptr)
-{}
+{
+}
 
 AnyExecutable::~AnyExecutable()
 {

rclcpp/src/rclcpp/callback_group.cpp

@@ -21,89 +21,69 @@ using rclcpp::callback_group::CallbackGroupType;
 
 CallbackGroup::CallbackGroup(CallbackGroupType group_type)
 : type_(group_type), can_be_taken_from_(true)
-{}
-
-
-std::atomic_bool &
-CallbackGroup::can_be_taken_from()
 {
-  return can_be_taken_from_;
 }
 
-const CallbackGroupType &
-CallbackGroup::type() const
-{
-  return type_;
-}
+std::atomic_bool & CallbackGroup::can_be_taken_from() { return can_be_taken_from_; }
 
-void
-CallbackGroup::add_subscription(
-  const rclcpp::SubscriptionBase::SharedPtr subscription_ptr)
+const CallbackGroupType & CallbackGroup::type() const { return type_; }
+
+void CallbackGroup::add_subscription(const rclcpp::SubscriptionBase::SharedPtr subscription_ptr)
 {
   std::lock_guard<std::mutex> lock(mutex_);
   subscription_ptrs_.push_back(subscription_ptr);
   subscription_ptrs_.erase(
     std::remove_if(
-      subscription_ptrs_.begin(),
-      subscription_ptrs_.end(),
-      [](rclcpp::SubscriptionBase::WeakPtr x) {return x.expired();}),
+      subscription_ptrs_.begin(), subscription_ptrs_.end(),
+      [](rclcpp::SubscriptionBase::WeakPtr x) { return x.expired(); }),
     subscription_ptrs_.end());
 }
 
-void
-CallbackGroup::add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr)
+void CallbackGroup::add_timer(const rclcpp::TimerBase::SharedPtr timer_ptr)
 {
   std::lock_guard<std::mutex> lock(mutex_);
   timer_ptrs_.push_back(timer_ptr);
   timer_ptrs_.erase(
     std::remove_if(
-      timer_ptrs_.begin(),
-      timer_ptrs_.end(),
-      [](rclcpp::TimerBase::WeakPtr x) {return x.expired();}),
+      timer_ptrs_.begin(), timer_ptrs_.end(),
+      [](rclcpp::TimerBase::WeakPtr x) { return x.expired(); }),
     timer_ptrs_.end());
 }
 
-void
-CallbackGroup::add_service(const rclcpp::ServiceBase::SharedPtr service_ptr)
+void CallbackGroup::add_service(const rclcpp::ServiceBase::SharedPtr service_ptr)
 {
   std::lock_guard<std::mutex> lock(mutex_);
   service_ptrs_.push_back(service_ptr);
   service_ptrs_.erase(
     std::remove_if(
-      service_ptrs_.begin(),
-      service_ptrs_.end(),
-      [](rclcpp::ServiceBase::WeakPtr x) {return x.expired();}),
+      service_ptrs_.begin(), service_ptrs_.end(),
+      [](rclcpp::ServiceBase::WeakPtr x) { return x.expired(); }),
     service_ptrs_.end());
 }
 
-void
-CallbackGroup::add_client(const rclcpp::ClientBase::SharedPtr client_ptr)
+void CallbackGroup::add_client(const rclcpp::ClientBase::SharedPtr client_ptr)
 {
   std::lock_guard<std::mutex> lock(mutex_);
   client_ptrs_.push_back(client_ptr);
   client_ptrs_.erase(
     std::remove_if(
-      client_ptrs_.begin(),
-      client_ptrs_.end(),
-      [](rclcpp::ClientBase::WeakPtr x) {return x.expired();}),
+      client_ptrs_.begin(), client_ptrs_.end(),
+      [](rclcpp::ClientBase::WeakPtr x) { return x.expired(); }),
     client_ptrs_.end());
 }
 
-void
-CallbackGroup::add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr)
+void CallbackGroup::add_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr)
 {
   std::lock_guard<std::mutex> lock(mutex_);
   waitable_ptrs_.push_back(waitable_ptr);
   waitable_ptrs_.erase(
     std::remove_if(
-      waitable_ptrs_.begin(),
-      waitable_ptrs_.end(),
-      [](rclcpp::Waitable::WeakPtr x) {return x.expired();}),
+      waitable_ptrs_.begin(), waitable_ptrs_.end(),
+      [](rclcpp::Waitable::WeakPtr x) { return x.expired(); }),
     waitable_ptrs_.end());
 }
 
-void
-CallbackGroup::remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept
+void CallbackGroup::remove_waitable(const rclcpp::Waitable::SharedPtr waitable_ptr) noexcept
 {
   std::lock_guard<std::mutex> lock(mutex_);
   for (auto iter = waitable_ptrs_.begin(); iter != waitable_ptrs_.end(); ++iter) {

rclcpp/src/rclcpp/client.cpp

@@ -24,10 +24,10 @@
 #include "rcl/node.h"
 #include "rcl/wait.h"
 #include "rclcpp/exceptions.hpp"
+#include "rclcpp/logging.hpp"
 #include "rclcpp/node_interfaces/node_base_interface.hpp"
 #include "rclcpp/node_interfaces/node_graph_interface.hpp"
 #include "rclcpp/utilities.hpp"
-#include "rclcpp/logging.hpp"
 
 using rclcpp::ClientBase;
 using rclcpp::exceptions::InvalidNodeError;
@@ -43,25 +43,23 @@ ClientBase::ClientBase(
   std::weak_ptr<rcl_node_t> weak_node_handle(node_handle_);
   rcl_client_t * new_rcl_client = new rcl_client_t;
   *new_rcl_client = rcl_get_zero_initialized_client();
-  client_handle_.reset(
-    new_rcl_client, [weak_node_handle](rcl_client_t * client)
-    {
-      auto handle = weak_node_handle.lock();
-      if (handle) {
-        if (rcl_client_fini(client, handle.get()) != RCL_RET_OK) {
-          RCLCPP_ERROR(
-            rclcpp::get_node_logger(handle.get()).get_child("rclcpp"),
-            "Error in destruction of rcl client handle: %s", rcl_get_error_string().str);
-          rcl_reset_error();
-        }
-      } else {
+  client_handle_.reset(new_rcl_client, [weak_node_handle](rcl_client_t * client) {
+    auto handle = weak_node_handle.lock();
+    if (handle) {
+      if (rcl_client_fini(client, handle.get()) != RCL_RET_OK) {
         RCLCPP_ERROR(
-          rclcpp::get_logger("rclcpp"),
-          "Error in destruction of rcl client handle: "
-          "the Node Handle was destructed too early. You will leak memory");
+          rclcpp::get_node_logger(handle.get()).get_child("rclcpp"),
+          "Error in destruction of rcl client handle: %s", rcl_get_error_string().str);
+        rcl_reset_error();
       }
-      delete client;
-    });
+    } else {
+      RCLCPP_ERROR(
+        rclcpp::get_logger("rclcpp"),
+        "Error in destruction of rcl client handle: "
+        "the Node Handle was destructed too early. You will leak memory");
+    }
+    delete client;
+  });
 }
 
 ClientBase::~ClientBase()
@@ -70,32 +68,20 @@ ClientBase::~ClientBase()
   client_handle_.reset();
 }
 
-const char *
-ClientBase::get_service_name() const
+const char * ClientBase::get_service_name() const
 {
   return rcl_client_get_service_name(this->get_client_handle().get());
 }
 
-std::shared_ptr<rcl_client_t>
-ClientBase::get_client_handle()
-{
-  return client_handle_;
-}
+std::shared_ptr<rcl_client_t> ClientBase::get_client_handle() { return client_handle_; }
 
-std::shared_ptr<const rcl_client_t>
-ClientBase::get_client_handle() const
-{
-  return client_handle_;
-}
+std::shared_ptr<const rcl_client_t> ClientBase::get_client_handle() const { return client_handle_; }
 
-bool
-ClientBase::service_is_ready() const
+bool ClientBase::service_is_ready() const
 {
   bool is_ready;
   rcl_ret_t ret = rcl_service_server_is_available(
-    this->get_rcl_node_handle(),
-    this->get_client_handle().get(),
-    &is_ready);
+    this->get_rcl_node_handle(), this->get_client_handle().get(), &is_ready);
   if (RCL_RET_NODE_INVALID == ret) {
     const rcl_node_t * node_handle = this->get_rcl_node_handle();
     if (node_handle && !rcl_context_is_valid(node_handle->context)) {
@@ -109,8 +95,7 @@ ClientBase::service_is_ready() const
   return is_ready;
 }
 
-bool
-ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
+bool ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
 {
   auto start = std::chrono::steady_clock::now();
   // make an event to reuse, rather than create a new one each time
@@ -129,10 +114,9 @@ ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
   auto event = node_ptr->get_graph_event();
   // update the time even on the first loop to account for time spent in the first call
   // to this->server_is_ready()
-  std::chrono::nanoseconds time_to_wait =
-    timeout > std::chrono::nanoseconds(0) ?
-    timeout - (std::chrono::steady_clock::now() - start) :
-    std::chrono::nanoseconds::max();
+  std::chrono::nanoseconds time_to_wait = timeout > std::chrono::nanoseconds(0)
+                                            ? timeout - (std::chrono::steady_clock::now() - start)
+                                            : std::chrono::nanoseconds::max();
   if (time_to_wait < std::chrono::nanoseconds(0)) {
     // Do not allow the time_to_wait to become negative when timeout was originally positive.
     // Setting time_to_wait to 0 will allow one non-blocking wait because of the do-while.
@@ -166,14 +150,6 @@ ClientBase::wait_for_service_nanoseconds(std::chrono::nanoseconds timeout)
   return false;  // timeout exceeded while waiting for the server to be ready
 }
 
-rcl_node_t *
-ClientBase::get_rcl_node_handle()
-{
-  return node_handle_.get();
-}
+rcl_node_t * ClientBase::get_rcl_node_handle() { return node_handle_.get(); }
 
-const rcl_node_t *
-ClientBase::get_rcl_node_handle() const
-{
-  return node_handle_.get();
-}
+const rcl_node_t * ClientBase::get_rcl_node_handle() const { return node_handle_.get(); }

rclcpp/src/rclcpp/clock.cpp

@@ -22,13 +22,11 @@ namespace rclcpp
 {
 
 JumpHandler::JumpHandler(
-  pre_callback_t pre_callback,
-  post_callback_t post_callback,
+  pre_callback_t pre_callback, post_callback_t post_callback,
   const rcl_jump_threshold_t & threshold)
-: pre_callback(pre_callback),
-  post_callback(post_callback),
-  notice_threshold(threshold)
-{}
+: pre_callback(pre_callback), post_callback(post_callback), notice_threshold(threshold)
+{
+}
 
 Clock::Clock(rcl_clock_type_t clock_type)
 {
@@ -47,8 +45,7 @@ Clock::~Clock()
   }
 }
 
-Time
-Clock::now()
+Time Clock::now()
 {
   Time now(0, 0, rcl_clock_.type);
 
@@ -60,8 +57,7 @@ Clock::now()
   return now;
 }
 
-bool
-Clock::ros_time_is_active()
+bool Clock::ros_time_is_active()
 {
   if (!rcl_clock_valid(&rcl_clock_)) {
     RCUTILS_LOG_ERROR("ROS time not valid!");
@@ -71,29 +67,17 @@ Clock::ros_time_is_active()
   bool is_enabled = false;
   auto ret = rcl_is_enabled_ros_time_override(&rcl_clock_, &is_enabled);
   if (ret != RCL_RET_OK) {
-    exceptions::throw_from_rcl_error(
-      ret, "Failed to check ros_time_override_status");
+    exceptions::throw_from_rcl_error(ret, "Failed to check ros_time_override_status");
   }
   return is_enabled;
 }
 
-rcl_clock_t *
-Clock::get_clock_handle() noexcept
-{
-  return &rcl_clock_;
-}
+rcl_clock_t * Clock::get_clock_handle() noexcept { return &rcl_clock_; }
 
-rcl_clock_type_t
-Clock::get_clock_type() const noexcept
-{
-  return rcl_clock_.type;
-}
+rcl_clock_type_t Clock::get_clock_type() const noexcept { return rcl_clock_.type; }
 
-void
-Clock::on_time_jump(
-  const struct rcl_time_jump_t * time_jump,
-  bool before_jump,
-  void * user_data)
+void Clock::on_time_jump(
+  const struct rcl_time_jump_t * time_jump, bool before_jump, void * user_data)
 {
   const auto * handler = static_cast<JumpHandler *>(user_data);
   if (nullptr == handler) {
@@ -106,10 +90,8 @@ Clock::on_time_jump(
   }
 }
 
-JumpHandler::SharedPtr
-Clock::create_jump_callback(
-  JumpHandler::pre_callback_t pre_callback,
-  JumpHandler::post_callback_t post_callback,
+JumpHandler::SharedPtr Clock::create_jump_callback(
+  JumpHandler::pre_callback_t pre_callback, JumpHandler::post_callback_t post_callback,
   const rcl_jump_threshold_t & threshold)
 {
   // Allocate a new jump handler
@@ -119,9 +101,8 @@ Clock::create_jump_callback(
   }
 
   // Try to add the jump callback to the clock
-  rcl_ret_t ret = rcl_clock_add_jump_callback(
-    &rcl_clock_, threshold, Clock::on_time_jump,
-    handler.get());
+  rcl_ret_t ret =
+    rcl_clock_add_jump_callback(&rcl_clock_, threshold, Clock::on_time_jump, handler.get());
   if (RCL_RET_OK != ret) {
     exceptions::throw_from_rcl_error(ret, "Failed to add time jump callback");
   }
@@ -130,8 +111,7 @@ Clock::create_jump_callback(
   // create shared_ptr that removes the callback automatically when all copies are destructed
   // TODO(dorezyuk) UB, if the clock leaves scope before the JumpHandler
   return JumpHandler::SharedPtr(handler.release(), [this](JumpHandler * handler) noexcept {
-    rcl_ret_t ret = rcl_clock_remove_jump_callback(&rcl_clock_, Clock::on_time_jump,
-        handler);
+    rcl_ret_t ret = rcl_clock_remove_jump_callback(&rcl_clock_, Clock::on_time_jump, handler);
     delete handler;
     handler = NULL;
     if (RCL_RET_OK != ret) {

rclcpp/src/rclcpp/context.cpp

@@ -31,8 +31,7 @@ static std::vector<std::weak_ptr<rclcpp::Context>> g_contexts;
 
 using rclcpp::Context;
 
-Context::Context()
-: rcl_context_(nullptr), shutdown_reason_("") {}
+Context::Context() : rcl_context_(nullptr), shutdown_reason_("") {}
 
 Context::~Context()
 {
@@ -52,8 +51,7 @@ Context::~Context()
 }
 
 RCLCPP_LOCAL
-void
-__delete_context(rcl_context_t * context)
+void __delete_context(rcl_context_t * context)
 {
   if (context) {
     if (rcl_context_is_valid(context)) {
@@ -64,8 +62,8 @@ __delete_context(rcl_context_t * context)
       rcl_ret_t ret = rcl_context_fini(context);
       if (RCL_RET_OK != ret) {
         RCLCPP_ERROR(
-          rclcpp::get_logger("rclcpp"),
-          "failed to finalize context: %s", rcl_get_error_string().str);
+          rclcpp::get_logger("rclcpp"), "failed to finalize context: %s",
+          rcl_get_error_string().str);
         rcl_reset_error();
       }
     }
@@ -73,11 +71,7 @@ __delete_context(rcl_context_t * context)
   }
 }
 
-void
-Context::init(
-  int argc,
-  char const * const argv[],
-  const rclcpp::InitOptions & init_options)
+void Context::init(int argc, char const * const argv[], const rclcpp::InitOptions & init_options)
 {
   std::lock_guard<std::recursive_mutex> init_lock(init_mutex_);
   if (this->is_valid()) {
@@ -97,8 +91,7 @@ Context::init(
   g_contexts.push_back(this->shared_from_this());
 }
 
-bool
-Context::is_valid() const
+bool Context::is_valid() const
 {
   // Take a local copy of the shared pointer to avoid it getting nulled under our feet.
   auto local_rcl_context = rcl_context_;
@@ -108,27 +101,17 @@ Context::is_valid() const
   return rcl_context_is_valid(local_rcl_context.get());
 }
 
-const rclcpp::InitOptions &
-Context::get_init_options() const
-{
-  return init_options_;
-}
+const rclcpp::InitOptions & Context::get_init_options() const { return init_options_; }
 
-rclcpp::InitOptions
-Context::get_init_options()
-{
-  return init_options_;
-}
+rclcpp::InitOptions Context::get_init_options() { return init_options_; }
 
-std::string
-Context::shutdown_reason()
+std::string Context::shutdown_reason()
 {
   std::lock_guard<std::recursive_mutex> lock(init_mutex_);
   return shutdown_reason_;
 }
 
-bool
-Context::shutdown(const std::string & reason)
+bool Context::shutdown(const std::string & reason)
 {
   // prevent races
   std::lock_guard<std::recursive_mutex> init_lock(init_mutex_);
@@ -153,7 +136,7 @@ Context::shutdown(const std::string & reason)
   this->interrupt_all_wait_sets();
   // remove self from the global contexts
   std::lock_guard<std::mutex> context_lock(g_contexts_mutex);
-  for (auto it = g_contexts.begin(); it != g_contexts.end(); ) {
+  for (auto it = g_contexts.begin(); it != g_contexts.end();) {
     auto shared_context = it->lock();
     if (shared_context.get() == this) {
       it = g_contexts.erase(it);
@@ -165,33 +148,25 @@ Context::shutdown(const std::string & reason)
   return true;
 }
 
-rclcpp::Context::OnShutdownCallback
-Context::on_shutdown(OnShutdownCallback callback)
+rclcpp::Context::OnShutdownCallback Context::on_shutdown(OnShutdownCallback callback)
 {
   on_shutdown_callbacks_.push_back(callback);
   return callback;
 }
 
-const std::vector<rclcpp::Context::OnShutdownCallback> &
-Context::get_on_shutdown_callbacks() const
+const std::vector<rclcpp::Context::OnShutdownCallback> & Context::get_on_shutdown_callbacks() const
 {
   return on_shutdown_callbacks_;
 }
 
-std::vector<rclcpp::Context::OnShutdownCallback> &
-Context::get_on_shutdown_callbacks()
+std::vector<rclcpp::Context::OnShutdownCallback> & Context::get_on_shutdown_callbacks()
 {
   return on_shutdown_callbacks_;
 }
 
-std::shared_ptr<rcl_context_t>
-Context::get_rcl_context()
-{
-  return rcl_context_;
-}
+std::shared_ptr<rcl_context_t> Context::get_rcl_context() { return rcl_context_; }
 
-bool
-Context::sleep_for(const std::chrono::nanoseconds & nanoseconds)
+bool Context::sleep_for(const std::chrono::nanoseconds & nanoseconds)
 {
   std::chrono::nanoseconds time_left = nanoseconds;
   {
@@ -208,14 +183,9 @@ Context::sleep_for(const std::chrono::nanoseconds & nanoseconds)
   return this->is_valid();
 }
 
-void
-Context::interrupt_all_sleep_for()
-{
-  interrupt_condition_variable_.notify_all();
-}
+void Context::interrupt_all_sleep_for() { interrupt_condition_variable_.notify_all(); }
 
-rcl_guard_condition_t *
-Context::get_interrupt_guard_condition(rcl_wait_set_t * wait_set)
+rcl_guard_condition_t * Context::get_interrupt_guard_condition(rcl_wait_set_t * wait_set)
 {
   std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
   auto kv = interrupt_guard_cond_handles_.find(wait_set);
@@ -233,8 +203,7 @@ Context::get_interrupt_guard_condition(rcl_wait_set_t * wait_set)
   }
 }
 
-void
-Context::release_interrupt_guard_condition(rcl_wait_set_t * wait_set)
+void Context::release_interrupt_guard_condition(rcl_wait_set_t * wait_set)
 {
   std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
   auto kv = interrupt_guard_cond_handles_.find(wait_set);
@@ -249,10 +218,8 @@ Context::release_interrupt_guard_condition(rcl_wait_set_t * wait_set)
   }
 }
 
-void
-Context::release_interrupt_guard_condition(
-  rcl_wait_set_t * wait_set,
-  const std::nothrow_t &) noexcept
+void Context::release_interrupt_guard_condition(
+  rcl_wait_set_t * wait_set, const std::nothrow_t &) noexcept
 {
   try {
     this->release_interrupt_guard_condition(wait_set);
@@ -268,30 +235,26 @@ Context::release_interrupt_guard_condition(
   }
 }
 
-void
-Context::interrupt_all_wait_sets()
+void Context::interrupt_all_wait_sets()
 {
   std::lock_guard<std::mutex> lock(interrupt_guard_cond_handles_mutex_);
   for (auto & kv : interrupt_guard_cond_handles_) {
     rcl_ret_t status = rcl_trigger_guard_condition(&(kv.second));
     if (status != RCL_RET_OK) {
       RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "failed to trigger guard condition in Context::interrupt_all_wait_sets(): %s",
+        "rclcpp", "failed to trigger guard condition in Context::interrupt_all_wait_sets(): %s",
         rcl_get_error_string().str);
     }
   }
 }
 
-void
-Context::clean_up()
+void Context::clean_up()
 {
   shutdown_reason_ = "";
   rcl_context_.reset();
 }
 
-std::vector<Context::SharedPtr>
-rclcpp::get_contexts()
+std::vector<Context::SharedPtr> rclcpp::get_contexts()
 {
   std::lock_guard<std::mutex> lock(g_contexts_mutex);
   std::vector<Context::SharedPtr> shared_contexts;

rclcpp/src/rclcpp/contexts/default_context.cpp

@@ -16,11 +16,9 @@
 
 using rclcpp::contexts::default_context::DefaultContext;
 
-DefaultContext::DefaultContext()
-{}
+DefaultContext::DefaultContext() {}
 
-DefaultContext::SharedPtr
-rclcpp::contexts::default_context::get_global_default_context()
+DefaultContext::SharedPtr rclcpp::contexts::default_context::get_global_default_context()
 {
   static DefaultContext::SharedPtr default_context = DefaultContext::make_shared();
   return default_context;

rclcpp/src/rclcpp/duration.cpp

@@ -37,10 +37,7 @@ Duration::Duration(int32_t seconds, uint32_t nanoseconds)
   rcl_duration_.nanoseconds += nanoseconds;
 }
 
-Duration::Duration(int64_t nanoseconds)
-{
-  rcl_duration_.nanoseconds = nanoseconds;
-}
+Duration::Duration(int64_t nanoseconds) { rcl_duration_.nanoseconds = nanoseconds; }
 
 Duration::Duration(std::chrono::nanoseconds nanoseconds)
 {
@@ -52,15 +49,13 @@ Duration::Duration(const Duration & rhs)
   rcl_duration_.nanoseconds = rhs.rcl_duration_.nanoseconds;
 }
 
-Duration::Duration(
-  const builtin_interfaces::msg::Duration & duration_msg)
+Duration::Duration(const builtin_interfaces::msg::Duration & duration_msg)
 {
   rcl_duration_.nanoseconds = RCL_S_TO_NS(static_cast<uint64_t>(duration_msg.sec));
   rcl_duration_.nanoseconds += duration_msg.nanosec;
 }
 
-Duration::Duration(const rcl_duration_t & duration)
-: rcl_duration_(duration)
+Duration::Duration(const rcl_duration_t & duration) : rcl_duration_(duration)
 {
   // noop
 }
@@ -74,110 +69,94 @@ Duration::operator builtin_interfaces::msg::Duration() const
   return msg_duration;
 }
 
-Duration &
-Duration::operator=(const Duration & rhs)
+Duration & Duration::operator=(const Duration & rhs)
 {
   rcl_duration_.nanoseconds = rhs.rcl_duration_.nanoseconds;
   return *this;
 }
 
-Duration &
-Duration::operator=(const builtin_interfaces::msg::Duration & duration_msg)
+Duration & Duration::operator=(const builtin_interfaces::msg::Duration & duration_msg)
 {
   rcl_duration_.nanoseconds = RCL_S_TO_NS(static_cast<int64_t>(duration_msg.sec));
   rcl_duration_.nanoseconds += duration_msg.nanosec;
   return *this;
 }
 
-bool
-Duration::operator==(const rclcpp::Duration & rhs) const
+bool Duration::operator==(const rclcpp::Duration & rhs) const
 {
   return rcl_duration_.nanoseconds == rhs.rcl_duration_.nanoseconds;
 }
 
-bool
-Duration::operator<(const rclcpp::Duration & rhs) const
+bool Duration::operator<(const rclcpp::Duration & rhs) const
 {
   return rcl_duration_.nanoseconds < rhs.rcl_duration_.nanoseconds;
 }
 
-bool
-Duration::operator<=(const rclcpp::Duration & rhs) const
+bool Duration::operator<=(const rclcpp::Duration & rhs) const
 {
   return rcl_duration_.nanoseconds <= rhs.rcl_duration_.nanoseconds;
 }
 
-bool
-Duration::operator>=(const rclcpp::Duration & rhs) const
+bool Duration::operator>=(const rclcpp::Duration & rhs) const
 {
   return rcl_duration_.nanoseconds >= rhs.rcl_duration_.nanoseconds;
 }
 
-bool
-Duration::operator>(const rclcpp::Duration & rhs) const
+bool Duration::operator>(const rclcpp::Duration & rhs) const
 {
   return rcl_duration_.nanoseconds > rhs.rcl_duration_.nanoseconds;
 }
 
-void
-bounds_check_duration_sum(int64_t lhsns, int64_t rhsns, uint64_t max)
+void bounds_check_duration_sum(int64_t lhsns, int64_t rhsns, uint64_t max)
 {
   auto abs_lhs = (uint64_t)std::abs(lhsns);
   auto abs_rhs = (uint64_t)std::abs(rhsns);
 
   if (lhsns > 0 && rhsns > 0) {
-    if (abs_lhs + abs_rhs > (uint64_t) max) {
+    if (abs_lhs + abs_rhs > (uint64_t)max) {
       throw std::overflow_error("addition leads to int64_t overflow");
     }
   } else if (lhsns < 0 && rhsns < 0) {
-    if (abs_lhs + abs_rhs > (uint64_t) max) {
+    if (abs_lhs + abs_rhs > (uint64_t)max) {
       throw std::underflow_error("addition leads to int64_t underflow");
     }
   }
 }
 
-Duration
-Duration::operator+(const rclcpp::Duration & rhs) const
+Duration Duration::operator+(const rclcpp::Duration & rhs) const
 {
   bounds_check_duration_sum(
-    this->rcl_duration_.nanoseconds,
-    rhs.rcl_duration_.nanoseconds,
+    this->rcl_duration_.nanoseconds, rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
-  return Duration(
-    rcl_duration_.nanoseconds + rhs.rcl_duration_.nanoseconds);
+  return Duration(rcl_duration_.nanoseconds + rhs.rcl_duration_.nanoseconds);
 }
 
-void
-bounds_check_duration_difference(int64_t lhsns, int64_t rhsns, uint64_t max)
+void bounds_check_duration_difference(int64_t lhsns, int64_t rhsns, uint64_t max)
 {
   auto abs_lhs = (uint64_t)std::abs(lhsns);
   auto abs_rhs = (uint64_t)std::abs(rhsns);
 
   if (lhsns > 0 && rhsns < 0) {
-    if (abs_lhs + abs_rhs > (uint64_t) max) {
+    if (abs_lhs + abs_rhs > (uint64_t)max) {
       throw std::overflow_error("duration subtraction leads to int64_t overflow");
     }
   } else if (lhsns < 0 && rhsns > 0) {
-    if (abs_lhs + abs_rhs > (uint64_t) max) {
+    if (abs_lhs + abs_rhs > (uint64_t)max) {
       throw std::underflow_error("duration subtraction leads to int64_t underflow");
     }
   }
 }
 
-Duration
-Duration::operator-(const rclcpp::Duration & rhs) const
+Duration Duration::operator-(const rclcpp::Duration & rhs) const
 {
   bounds_check_duration_difference(
-    this->rcl_duration_.nanoseconds,
-    rhs.rcl_duration_.nanoseconds,
+    this->rcl_duration_.nanoseconds, rhs.rcl_duration_.nanoseconds,
     std::numeric_limits<rcl_duration_value_t>::max());
 
-  return Duration(
-    rcl_duration_.nanoseconds - rhs.rcl_duration_.nanoseconds);
+  return Duration(rcl_duration_.nanoseconds - rhs.rcl_duration_.nanoseconds);
 }
 
-void
-bounds_check_duration_scale(int64_t dns, double scale, uint64_t max)
+void bounds_check_duration_scale(int64_t dns, double scale, uint64_t max)
 {
   auto abs_dns = static_cast<uint64_t>(std::abs(dns));
   auto abs_scale = std::abs(scale);
@@ -191,39 +170,26 @@ bounds_check_duration_scale(int64_t dns, double scale, uint64_t max)
   }
 }
 
-Duration
-Duration::operator*(double scale) const
+Duration Duration::operator*(double scale) const
 {
   if (!std::isfinite(scale)) {
     throw std::runtime_error("abnormal scale in rclcpp::Duration");
   }
   bounds_check_duration_scale(
-    this->rcl_duration_.nanoseconds,
-    scale,
-    std::numeric_limits<rcl_duration_value_t>::max());
+    this->rcl_duration_.nanoseconds, scale, std::numeric_limits<rcl_duration_value_t>::max());
   return Duration(static_cast<rcl_duration_value_t>(rcl_duration_.nanoseconds * scale));
 }
 
-rcl_duration_value_t
-Duration::nanoseconds() const
-{
-  return rcl_duration_.nanoseconds;
-}
+rcl_duration_value_t Duration::nanoseconds() const { return rcl_duration_.nanoseconds; }
 
-Duration
-Duration::max()
-{
-  return Duration(std::numeric_limits<int32_t>::max(), 999999999);
-}
+Duration Duration::max() { return Duration(std::numeric_limits<int32_t>::max(), 999999999); }
 
-double
-Duration::seconds() const
+double Duration::seconds() const
 {
   return std::chrono::duration<double>(std::chrono::nanoseconds(rcl_duration_.nanoseconds)).count();
 }
 
-rmw_time_t
-Duration::to_rmw_time() const
+rmw_time_t Duration::to_rmw_time() const
 {
   // reuse conversion logic from msg creation
   builtin_interfaces::msg::Duration msg = *this;
@@ -233,8 +199,7 @@ Duration::to_rmw_time() const
   return result;
 }
 
-Duration
-Duration::from_seconds(double seconds)
+Duration Duration::from_seconds(double seconds)
 {
   return Duration(static_cast<int64_t>(RCL_S_TO_NS(seconds)));
 }

rclcpp/src/rclcpp/event.cpp

@@ -17,25 +17,12 @@
 namespace rclcpp
 {
 
-Event::Event()
-: state_(false) {}
+Event::Event() : state_(false) {}
 
-bool
-Event::set()
-{
-  return state_.exchange(true);
-}
+bool Event::set() { return state_.exchange(true); }
 
-bool
-Event::check()
-{
-  return state_.load();
-}
+bool Event::check() { return state_.load(); }
 
-bool
-Event::check_and_clear()
-{
-  return state_.exchange(false);
-}
+bool Event::check_and_clear() { return state_.exchange(false); }
 
 }  // namespace rclcpp

rclcpp/src/rclcpp/exceptions.cpp

@@ -26,12 +26,8 @@ namespace rclcpp
 namespace exceptions
 {
 
-std::string
-NameValidationError::format_error(
-  const char * name_type,
-  const char * name,
-  const char * error_msg,
-  size_t invalid_index)
+std::string NameValidationError::format_error(
+  const char * name_type, const char * name, const char * error_msg, size_t invalid_index)
 {
   std::string msg = "";
   msg += "Invalid "s + name_type + ": " + error_msg + ":\n";
@@ -40,12 +36,9 @@ NameValidationError::format_error(
   return msg;
 }
 
-std::exception_ptr
-from_rcl_error(
-  rcl_ret_t ret,
-  const std::string & prefix,
-  const rcl_error_state_t * error_state,
-  void (* reset_error)())
+std::exception_ptr from_rcl_error(
+  rcl_ret_t ret, const std::string & prefix, const rcl_error_state_t * error_state,
+  void (*reset_error)())
 {
   if (RCL_RET_OK == ret) {
     throw std::invalid_argument("ret is RCL_RET_OK");
@@ -76,12 +69,9 @@ from_rcl_error(
   }
 }
 
-void
-throw_from_rcl_error(
-  rcl_ret_t ret,
-  const std::string & prefix,
-  const rcl_error_state_t * error_state,
-  void (* reset_error)())
+void throw_from_rcl_error(
+  rcl_ret_t ret, const std::string & prefix, const rcl_error_state_t * error_state,
+  void (*reset_error)())
 {
   // We expect this to either throw a standard error,
   // or to generate an error pointer (which is caught
@@ -91,56 +81,55 @@ throw_from_rcl_error(
 }
 
 RCLErrorBase::RCLErrorBase(rcl_ret_t ret, const rcl_error_state_t * error_state)
-: ret(ret), message(error_state->message), file(error_state->file), line(error_state->line_number),
+: ret(ret),
+  message(error_state->message),
+  file(error_state->file),
+  line(error_state->line_number),
   formatted_message(rcl_get_error_string().str)
-{}
+{
+}
 
-RCLError::RCLError(
-  rcl_ret_t ret,
-  const rcl_error_state_t * error_state,
-  const std::string & prefix)
+RCLError::RCLError(rcl_ret_t ret, const rcl_error_state_t * error_state, const std::string & prefix)
 : RCLError(RCLErrorBase(ret, error_state), prefix)
-{}
+{
+}
 
-RCLError::RCLError(
-  const RCLErrorBase & base_exc,
-  const std::string & prefix)
+RCLError::RCLError(const RCLErrorBase & base_exc, const std::string & prefix)
 : RCLErrorBase(base_exc), std::runtime_error(prefix + base_exc.formatted_message)
-{}
+{
+}
 
 RCLBadAlloc::RCLBadAlloc(rcl_ret_t ret, const rcl_error_state_t * error_state)
 : RCLBadAlloc(RCLErrorBase(ret, error_state))
-{}
+{
+}
 
-RCLBadAlloc::RCLBadAlloc(const RCLErrorBase & base_exc)
-: RCLErrorBase(base_exc), std::bad_alloc()
-{}
+RCLBadAlloc::RCLBadAlloc(const RCLErrorBase & base_exc) : RCLErrorBase(base_exc), std::bad_alloc()
+{
+}
 
 RCLInvalidArgument::RCLInvalidArgument(
-  rcl_ret_t ret,
-  const rcl_error_state_t * error_state,
-  const std::string & prefix)
+  rcl_ret_t ret, const rcl_error_state_t * error_state, const std::string & prefix)
 : RCLInvalidArgument(RCLErrorBase(ret, error_state), prefix)
-{}
+{
+}
 
-RCLInvalidArgument::RCLInvalidArgument(
-  const RCLErrorBase & base_exc,
-  const std::string & prefix)
+RCLInvalidArgument::RCLInvalidArgument(const RCLErrorBase & base_exc, const std::string & prefix)
 : RCLErrorBase(base_exc), std::invalid_argument(prefix + base_exc.formatted_message)
-{}
+{
+}
 
 RCLInvalidROSArgsError::RCLInvalidROSArgsError(
-  rcl_ret_t ret,
-  const rcl_error_state_t * error_state,
-  const std::string & prefix)
+  rcl_ret_t ret, const rcl_error_state_t * error_state, const std::string & prefix)
 : RCLInvalidROSArgsError(RCLErrorBase(ret, error_state), prefix)
-{}
+{
+}
 
 RCLInvalidROSArgsError::RCLInvalidROSArgsError(
-  const RCLErrorBase & base_exc,
-  const std::string & prefix)
+  const RCLErrorBase & base_exc, const std::string & prefix)
 : RCLErrorBase(base_exc), std::runtime_error(prefix + base_exc.formatted_message)
-{}
+{
+}
 
 }  // namespace exceptions
 }  // namespace rclcpp

rclcpp/src/rclcpp/executor.cpp

@@ -37,8 +37,7 @@ using rclcpp::executor::ExecutorArgs;
 using rclcpp::executor::FutureReturnCode;
 
 Executor::Executor(const ExecutorArgs & args)
-: spinning(false),
-  memory_strategy_(args.memory_strategy)
+: spinning(false), memory_strategy_(args.memory_strategy)
 {
   rcl_guard_condition_options_t guard_condition_options = rcl_guard_condition_get_default_options();
   rcl_ret_t ret = rcl_guard_condition_init(
@@ -60,20 +59,14 @@ Executor::Executor(const ExecutorArgs & args)
   // Store the context for later use.
   context_ = args.context;
 
-  ret = rcl_wait_set_init(
-    &wait_set_,
-    0, 2, 0, 0, 0, 0,
-    context_->get_rcl_context().get(),
-    allocator);
+  ret =
+    rcl_wait_set_init(&wait_set_, 0, 2, 0, 0, 0, 0, context_->get_rcl_context().get(), allocator);
   if (RCL_RET_OK != ret) {
-    RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "failed to create wait set: %s", rcl_get_error_string().str);
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "failed to create wait set: %s", rcl_get_error_string().str);
     rcl_reset_error();
     if (rcl_guard_condition_fini(&interrupt_guard_condition_) != RCL_RET_OK) {
       RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "failed to destroy guard condition: %s", rcl_get_error_string().str);
+        "rclcpp", "failed to destroy guard condition: %s", rcl_get_error_string().str);
       rcl_reset_error();
     }
     throw std::runtime_error("Failed to create wait set in Executor constructor");
@@ -98,16 +91,13 @@ Executor::~Executor()
 
   // Finalize the wait set.
   if (rcl_wait_set_fini(&wait_set_) != RCL_RET_OK) {
-    RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "failed to destroy wait set: %s", rcl_get_error_string().str);
+    RCUTILS_LOG_ERROR_NAMED("rclcpp", "failed to destroy wait set: %s", rcl_get_error_string().str);
     rcl_reset_error();
   }
   // Finalize the interrupt guard condition.
   if (rcl_guard_condition_fini(&interrupt_guard_condition_) != RCL_RET_OK) {
     RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "failed to destroy guard condition: %s", rcl_get_error_string().str);
+      "rclcpp", "failed to destroy guard condition: %s", rcl_get_error_string().str);
     rcl_reset_error();
   }
   // Remove and release the sigint guard condition
@@ -115,8 +105,7 @@ Executor::~Executor()
   context_->release_interrupt_guard_condition(&wait_set_, std::nothrow);
 }
 
-void
-Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
+void Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
 {
   // If the node already has an executor
   std::atomic_bool & has_executor = node_ptr->get_associated_with_executor_atomic();
@@ -144,14 +133,13 @@ Executor::add_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_pt
   memory_strategy_->add_guard_condition(node_ptr->get_notify_guard_condition());
 }
 
-void
-Executor::add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
+void Executor::add_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
 {
   this->add_node(node_ptr->get_node_base_interface(), notify);
 }
 
-void
-Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
+void Executor::remove_node(
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr, bool notify)
 {
   bool node_removed = false;
   {
@@ -183,16 +171,13 @@ Executor::remove_node(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node
   memory_strategy_->remove_guard_condition(node_ptr->get_notify_guard_condition());
 }
 
-void
-Executor::remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
+void Executor::remove_node(std::shared_ptr<rclcpp::Node> node_ptr, bool notify)
 {
   this->remove_node(node_ptr->get_node_base_interface(), notify);
 }
 
-void
-Executor::spin_node_once_nanoseconds(
-  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node,
-  std::chrono::nanoseconds timeout)
+void Executor::spin_node_once_nanoseconds(
+  rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node, std::chrono::nanoseconds timeout)
 {
   this->add_node(node, false);
   // non-blocking = true
@@ -200,40 +185,37 @@ Executor::spin_node_once_nanoseconds(
   this->remove_node(node, false);
 }
 
-void
-Executor::spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node)
+void Executor::spin_node_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node)
 {
   this->add_node(node, false);
   spin_some();
   this->remove_node(node, false);
 }
 
-void
-Executor::spin_node_some(std::shared_ptr<rclcpp::Node> node)
+void Executor::spin_node_some(std::shared_ptr<rclcpp::Node> node)
 {
   this->spin_node_some(node->get_node_base_interface());
 }
 
-void
-Executor::spin_some(std::chrono::nanoseconds max_duration)
+void Executor::spin_some(std::chrono::nanoseconds max_duration)
 {
   auto start = std::chrono::steady_clock::now();
   auto max_duration_not_elapsed = [max_duration, start]() {
-      if (std::chrono::nanoseconds(0) == max_duration) {
-        // told to spin forever if need be
-        return true;
-      } else if (std::chrono::steady_clock::now() - start < max_duration) {
-        // told to spin only for some maximum amount of time
-        return true;
-      }
-      // spun too long
-      return false;
-    };
+    if (std::chrono::nanoseconds(0) == max_duration) {
+      // told to spin forever if need be
+      return true;
+    } else if (std::chrono::steady_clock::now() - start < max_duration) {
+      // told to spin only for some maximum amount of time
+      return true;
+    }
+    // spun too long
+    return false;
+  };
 
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin_some() called while already spinning");
   }
-  RCLCPP_SCOPE_EXIT(this->spinning.store(false); );
+  RCLCPP_SCOPE_EXIT(this->spinning.store(false););
   while (spinning.load() && max_duration_not_elapsed()) {
     AnyExecutable any_exec;
     if (get_next_executable(any_exec, std::chrono::milliseconds::zero())) {
@@ -244,21 +226,19 @@ Executor::spin_some(std::chrono::nanoseconds max_duration)
   }
 }
 
-void
-Executor::spin_once(std::chrono::nanoseconds timeout)
+void Executor::spin_once(std::chrono::nanoseconds timeout)
 {
   if (spinning.exchange(true)) {
     throw std::runtime_error("spin_once() called while already spinning");
   }
-  RCLCPP_SCOPE_EXIT(this->spinning.store(false); );
+  RCLCPP_SCOPE_EXIT(this->spinning.store(false););
   AnyExecutable any_exec;
   if (get_next_executable(any_exec, timeout)) {
     execute_any_executable(any_exec);
   }
 }
 
-void
-Executor::cancel()
+void Executor::cancel()
 {
   spinning.store(false);
   if (rcl_trigger_guard_condition(&interrupt_guard_condition_) != RCL_RET_OK) {
@@ -266,8 +246,8 @@ Executor::cancel()
   }
 }
 
-void
-Executor::set_memory_strategy(rclcpp::memory_strategy::MemoryStrategy::SharedPtr memory_strategy)
+void Executor::set_memory_strategy(
+  rclcpp::memory_strategy::MemoryStrategy::SharedPtr memory_strategy)
 {
   if (memory_strategy == nullptr) {
     throw std::runtime_error("Received NULL memory strategy in executor.");
@@ -275,8 +255,7 @@ Executor::set_memory_strategy(rclcpp::memory_strategy::MemoryStrategy::SharedPtr
   memory_strategy_ = memory_strategy;
 }
 
-void
-Executor::execute_any_executable(AnyExecutable & any_exec)
+void Executor::execute_any_executable(AnyExecutable & any_exec)
 {
   if (!spinning.load()) {
     return;
@@ -308,9 +287,7 @@ Executor::execute_any_executable(AnyExecutable & any_exec)
   }
 }
 
-void
-Executor::execute_subscription(
-  rclcpp::SubscriptionBase::SharedPtr subscription)
+void Executor::execute_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
 {
   rmw_message_info_t message_info;
   message_info.from_intra_process = false;
@@ -318,15 +295,13 @@ Executor::execute_subscription(
   if (subscription->is_serialized()) {
     auto serialized_msg = subscription->create_serialized_message();
     auto ret = rcl_take_serialized_message(
-      subscription->get_subscription_handle().get(),
-      serialized_msg.get(), &message_info, nullptr);
+      subscription->get_subscription_handle().get(), serialized_msg.get(), &message_info, nullptr);
     if (RCL_RET_OK == ret) {
       auto void_serialized_msg = std::static_pointer_cast<void>(serialized_msg);
       subscription->handle_message(void_serialized_msg, message_info);
     } else if (RCL_RET_SUBSCRIPTION_TAKE_FAILED != ret) {
       RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "take_serialized failed for subscription on topic '%s': %s",
+        "rclcpp", "take_serialized failed for subscription on topic '%s': %s",
         subscription->get_topic_name(), rcl_get_error_string().str);
       rcl_reset_error();
     }
@@ -334,14 +309,12 @@ Executor::execute_subscription(
   } else {
     std::shared_ptr<void> message = subscription->create_message();
     auto ret = rcl_take(
-      subscription->get_subscription_handle().get(),
-      message.get(), &message_info, nullptr);
+      subscription->get_subscription_handle().get(), message.get(), &message_info, nullptr);
     if (RCL_RET_OK == ret) {
       subscription->handle_message(message, message_info);
     } else if (RCL_RET_SUBSCRIPTION_TAKE_FAILED != ret) {
       RCUTILS_LOG_ERROR_NAMED(
-        "rclcpp",
-        "could not deserialize serialized message on topic '%s': %s",
+        "rclcpp", "could not deserialize serialized message on topic '%s': %s",
         subscription->get_topic_name(), rcl_get_error_string().str);
       rcl_reset_error();
     }
@@ -349,81 +322,59 @@ Executor::execute_subscription(
   }
 }
 
-void
-Executor::execute_intra_process_subscription(
-  rclcpp::SubscriptionBase::SharedPtr subscription)
+void Executor::execute_intra_process_subscription(rclcpp::SubscriptionBase::SharedPtr subscription)
 {
   rcl_interfaces::msg::IntraProcessMessage ipm;
   rmw_message_info_t message_info;
   rcl_ret_t status = rcl_take(
-    subscription->get_intra_process_subscription_handle().get(),
-    &ipm,
-    &message_info,
-    nullptr);
+    subscription->get_intra_process_subscription_handle().get(), &ipm, &message_info, nullptr);
 
   if (status == RCL_RET_OK) {
     message_info.from_intra_process = true;
     subscription->handle_intra_process_message(ipm, message_info);
   } else if (status != RCL_RET_SUBSCRIPTION_TAKE_FAILED) {
     RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "take failed for intra process subscription on topic '%s': %s",
+      "rclcpp", "take failed for intra process subscription on topic '%s': %s",
       subscription->get_topic_name(), rcl_get_error_string().str);
     rcl_reset_error();
   }
 }
 
-void
-Executor::execute_timer(
-  rclcpp::TimerBase::SharedPtr timer)
-{
-  timer->execute_callback();
-}
+void Executor::execute_timer(rclcpp::TimerBase::SharedPtr timer) { timer->execute_callback(); }
 
-void
-Executor::execute_service(
-  rclcpp::ServiceBase::SharedPtr service)
+void Executor::execute_service(rclcpp::ServiceBase::SharedPtr service)
 {
   auto request_header = service->create_request_header();
   std::shared_ptr<void> request = service->create_request();
-  rcl_ret_t status = rcl_take_request(
-    service->get_service_handle().get(),
-    request_header.get(),
-    request.get());
+  rcl_ret_t status =
+    rcl_take_request(service->get_service_handle().get(), request_header.get(), request.get());
   if (status == RCL_RET_OK) {
     service->handle_request(request_header, request);
   } else if (status != RCL_RET_SERVICE_TAKE_FAILED) {
     RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "take request failed for server of service '%s': %s",
-      service->get_service_name(), rcl_get_error_string().str);
+      "rclcpp", "take request failed for server of service '%s': %s", service->get_service_name(),
+      rcl_get_error_string().str);
     rcl_reset_error();
   }
 }
 
-void
-Executor::execute_client(
-  rclcpp::ClientBase::SharedPtr client)
+void Executor::execute_client(rclcpp::ClientBase::SharedPtr client)
 {
   auto request_header = client->create_request_header();
   std::shared_ptr<void> response = client->create_response();
-  rcl_ret_t status = rcl_take_response(
-    client->get_client_handle().get(),
-    request_header.get(),
-    response.get());
+  rcl_ret_t status =
+    rcl_take_response(client->get_client_handle().get(), request_header.get(), response.get());
   if (status == RCL_RET_OK) {
     client->handle_response(request_header, response);
   } else if (status != RCL_RET_CLIENT_TAKE_FAILED) {
     RCUTILS_LOG_ERROR_NAMED(
-      "rclcpp",
-      "take response failed for client of service '%s': %s",
-      client->get_service_name(), rcl_get_error_string().str);
+      "rclcpp", "take response failed for client of service '%s': %s", client->get_service_name(),
+      rcl_get_error_string().str);
     rcl_reset_error();
   }
 }
 
-void
-Executor::wait_for_work(std::chrono::nanoseconds timeout)
+void Executor::wait_for_work(std::chrono::nanoseconds timeout)
 {
   {
     std::unique_lock<std::mutex> lock(memory_strategy_mutex_);
@@ -460,7 +411,7 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
       memory_strategy_->number_of_ready_events());
     if (RCL_RET_OK != ret) {
       throw std::runtime_error(
-              std::string("Couldn't resize the wait set : ") + rcl_get_error_string().str);
+        std::string("Couldn't resize the wait set : ") + rcl_get_error_string().str);
     }
 
     if (!memory_strategy_->add_handles_to_wait_set(&wait_set_)) {
@@ -471,8 +422,7 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
     rcl_wait(&wait_set_, std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count());
   if (status == RCL_RET_WAIT_SET_EMPTY) {
     RCUTILS_LOG_WARN_NAMED(
-      "rclcpp",
-      "empty wait set received in rcl_wait(). This should never happen.");
+      "rclcpp", "empty wait set received in rcl_wait(). This should never happen.");
   } else if (status != RCL_RET_OK && status != RCL_RET_TIMEOUT) {
     using rclcpp::exceptions::throw_from_rcl_error;
     throw_from_rcl_error(status, "rcl_wait() failed");
@@ -483,8 +433,8 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
   memory_strategy_->remove_null_handles(&wait_set_);
 }
 
-rclcpp::node_interfaces::NodeBaseInterface::SharedPtr
-Executor::get_node_by_group(rclcpp::callback_group::CallbackGroup::SharedPtr group)
+rclcpp::node_interfaces::NodeBaseInterface::SharedPtr Executor::get_node_by_group(
+  rclcpp::callback_group::CallbackGroup::SharedPtr group)
 {
   if (!group) {
     return nullptr;
@@ -504,8 +454,8 @@ Executor::get_node_by_group(rclcpp::callback_group::CallbackGroup::SharedPtr gro
   return nullptr;
 }
 
-rclcpp::callback_group::CallbackGroup::SharedPtr
-Executor::get_group_by_timer(rclcpp::TimerBase::SharedPtr timer)
+rclcpp::callback_group::CallbackGroup::SharedPtr Executor::get_group_by_timer(
+  rclcpp::TimerBase::SharedPtr timer)
 {
   for (auto & weak_node : weak_nodes_) {
     auto node = weak_node.lock();
@@ -517,8 +467,8 @@ Executor::get_group_by_timer(rclcpp::TimerBase::SharedPtr timer)
       if (!group) {
         continue;
       }
-      auto timer_ref = group->find_timer_ptrs_if(
-        [timer](const rclcpp::TimerBase::SharedPtr & timer_ptr) -> bool {
+      auto timer_ref =
+        group->find_timer_ptrs_if([timer](const rclcpp::TimerBase::SharedPtr & timer_ptr) -> bool {
           return timer_ptr == timer;
         });
       if (timer_ref) {
@@ -529,8 +479,7 @@ Executor::get_group_by_timer(rclcpp::TimerBase::SharedPtr timer)
   return rclcpp::callback_group::CallbackGroup::SharedPtr();
 }
 
-void
-Executor::get_next_timer(AnyExecutable & any_exec)
+void Executor::get_next_timer(AnyExecutable & any_exec)
 {
   for (auto & weak_node : weak_nodes_) {
     auto node = weak_node.lock();
@@ -543,9 +492,7 @@ Executor::get_next_timer(AnyExecutable & any_exec)
         continue;
       }
       auto timer_ref = group->find_timer_ptrs_if(
-        [](const rclcpp::TimerBase::SharedPtr & timer) -> bool {
-          return timer->is_ready();
-        });
+        [](const rclcpp::TimerBase::SharedPtr & timer) -> bool { return timer->is_ready(); });
       if (timer_ref) {
         any_exec.timer = timer_ref;
         any_exec.callback_group = group;
@@ -556,8 +503,7 @@ Executor::get_next_timer(AnyExecutable & any_exec)
   }
 }
 
-bool
-Executor::get_next_ready_executable(AnyExecutable & any_executable)
+bool Executor::get_next_ready_executable(AnyExecutable & any_executable)
 {
   // Check the timers to see if there are any that are ready, if so return
   get_next_timer(any_executable);
@@ -588,8 +534,7 @@ Executor::get_next_ready_executable(AnyExecutable & any_executable)
   return false;
 }
 
-bool
-Executor::get_next_executable(AnyExecutable & any_executable, std::chrono::nanoseconds timeout)
+bool Executor::get_next_executable(AnyExecutable & any_executable, std::chrono::nanoseconds timeout)
 {
   bool success = false;
   // Check to see if there are any subscriptions or timers needing service
@@ -613,8 +558,7 @@ Executor::get_next_executable(AnyExecutable & any_executable, std::chrono::nanos
     using callback_group::CallbackGroupType;
     if (
       any_executable.callback_group &&
-      any_executable.callback_group->type() == CallbackGroupType::MutuallyExclusive)
-    {
+      any_executable.callback_group->type() == CallbackGroupType::MutuallyExclusive) {
       // It should not have been taken otherwise
       assert(any_executable.callback_group->can_be_taken_from().load());
       // Set to false to indicate something is being run from this group
@@ -626,14 +570,13 @@ Executor::get_next_executable(AnyExecutable & any_executable, std::chrono::nanos
   return success;
 }
 
-std::ostream &
-rclcpp::executor::operator<<(std::ostream & os, const FutureReturnCode & future_return_code)
+std::ostream & rclcpp::executor::operator<<(
+  std::ostream & os, const FutureReturnCode & future_return_code)
 {
   return os << to_string(future_return_code);
 }
 
-std::string
-rclcpp::executor::to_string(const FutureReturnCode & future_return_code)
+std::string rclcpp::executor::to_string(const FutureReturnCode & future_return_code)
 {
   using enum_type = std::underlying_type<FutureReturnCode>::type;
   std::string prefix = "Unknown enum value (";

rclcpp/src/rclcpp/executors.cpp

@@ -14,21 +14,18 @@
 
 #include "rclcpp/executors.hpp"
 
-void
-rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
+void rclcpp::spin_some(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
   rclcpp::executors::SingleThreadedExecutor exec;
   exec.spin_node_some(node_ptr);
 }
 
-void
-rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
+void rclcpp::spin_some(rclcpp::Node::SharedPtr node_ptr)
 {
   rclcpp::spin_some(node_ptr->get_node_base_interface());
 }
 
-void
-rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
+void rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
 {
   rclcpp::executors::SingleThreadedExecutor exec;
   exec.add_node(node_ptr);
@@ -36,8 +33,7 @@ rclcpp::spin(rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_ptr)
   exec.remove_node(node_ptr);
 }
 
-void
-rclcpp::spin(rclcpp::Node::SharedPtr node_ptr)
+void rclcpp::spin(rclcpp::Node::SharedPtr node_ptr)
 {
   rclcpp::spin(node_ptr->get_node_base_interface());
 }