Migrate std::bind calls to lambda expressions

source/How-To-Guides/Using-callback-groups.rst

@@ -210,25 +210,25 @@ We have two nodes - one providing a simple service:
         public:
             ServiceNode() : Node("service_node")
             {
+                auto service_callback = [this](
+                    const std::shared_ptr<rmw_request_id_t> request_header,
+                    const std::shared_ptr<std_srvs::srv::Empty::Request> request,
+                    const std::shared_ptr<std_srvs::srv::Empty::Response> response)
+                {
+                    (void)request_header;
+                    (void)request;
+                    (void)response;
+                    RCLCPP_INFO(this->get_logger(), "Received request, responding...");
+                };
                 service_ptr_ = this->create_service<std_srvs::srv::Empty>(
                         "test_service",
-                        std::bind(&ServiceNode::service_callback, this, _1, _2, _3)
+                        service_callback
                 );
             }
 
         private:
             rclcpp::Service<std_srvs::srv::Empty>::SharedPtr service_ptr_;
 
-            void service_callback(
-                    const std::shared_ptr<rmw_request_id_t> request_header,
-                    const std::shared_ptr<std_srvs::srv::Empty::Request> request,
-                    const std::shared_ptr<std_srvs::srv::Empty::Response> response)
-            {
-                (void)request_header;
-                (void)request;
-                (void)response;
-                RCLCPP_INFO(this->get_logger(), "Received request, responding...");
-            }
         };  // class ServiceNode
         }   // namespace cb_group_demo
 
@@ -306,8 +306,18 @@ service calls:
               timer_cb_group_ = nullptr;
               client_ptr_ = this->create_client<std_srvs::srv::Empty>("test_service", rmw_qos_profile_services_default,
                                                                       client_cb_group_);
-              timer_ptr_ = this->create_wall_timer(1s, std::bind(&DemoNode::timer_callback, this),
-                                                  timer_cb_group_);
+
+              auto timer_callback = [this](){
+                  RCLCPP_INFO(this->get_logger(), "Sending request");
+                  auto request = std::make_shared<std_srvs::srv::Empty::Request>();
+                  auto result_future = client_ptr_->async_send_request(request);
+                  std::future_status status = result_future.wait_for(10s);  // timeout to guarantee a graceful finish
+                  if (status == std::future_status::ready) {
+                      RCLCPP_INFO(this->get_logger(), "Received response");
+                  }
+              };
+
+              timer_ptr_ = this->create_wall_timer(1s, timer_callback, timer_cb_group_);
           }
 
       private:
@@ -316,16 +326,6 @@ service calls:
           rclcpp::Client<std_srvs::srv::Empty>::SharedPtr client_ptr_;
           rclcpp::TimerBase::SharedPtr timer_ptr_;
 
-          void timer_callback()
-          {
-              RCLCPP_INFO(this->get_logger(), "Sending request");
-              auto request = std::make_shared<std_srvs::srv::Empty::Request>();
-              auto result_future = client_ptr_->async_send_request(request);
-              std::future_status status = result_future.wait_for(10s);  // timeout to guarantee a graceful finish
-              if (status == std::future_status::ready) {
-                  RCLCPP_INFO(this->get_logger(), "Received response");
-              }
-          }
       };  // class DemoNode
       }   // namespace cb_group_demo
 

source/Tutorials/Advanced/FastDDS-Configuration.rst

@@ -112,41 +112,38 @@ Note that the synchronous publisher will be publishing on topic ``sync_topic``,
             // Create the asynchronous publisher on topic 'async_topic'
             async_publisher_ = this->create_publisher<std_msgs::msg::String>("async_topic", 10);
 
-            // This timer will trigger the publication of new data every half a second
-            timer_ = this->create_wall_timer(
-                    500ms, std::bind(&SyncAsyncPublisher::timer_callback, this));
-        }
+            // Actions to run every time the timer expires
+            auto timer_callback = [this](){
 
-    private:
-        /**
-         * Actions to run every time the timer expires
-         */
-        void timer_callback()
-        {
-            // Create a new message to be sent
-            auto sync_message = std_msgs::msg::String();
-            sync_message.data = "SYNC: Hello, world! " + std::to_string(count_);
+                // Create a new message to be sent
+                auto sync_message = std_msgs::msg::String();
+                sync_message.data = "SYNC: Hello, world! " + std::to_string(count_);
 
-            // Log the message to the console to show progress
-            RCLCPP_INFO(this->get_logger(), "Synchronously publishing: '%s'", sync_message.data.c_str());
+                // Log the message to the console to show progress
+                RCLCPP_INFO(this->get_logger(), "Synchronously publishing: '%s'", sync_message.data.c_str());
 
-            // Publish the message using the synchronous publisher
-            sync_publisher_->publish(sync_message);
+                // Publish the message using the synchronous publisher
+                sync_publisher_->publish(sync_message);
 
-            // Create a new message to be sent
-            auto async_message = std_msgs::msg::String();
-            async_message.data = "ASYNC: Hello, world! " + std::to_string(count_);
+                // Create a new message to be sent
+                auto async_message = std_msgs::msg::String();
+                async_message.data = "ASYNC: Hello, world! " + std::to_string(count_);
 
-            // Log the message to the console to show progress
-            RCLCPP_INFO(this->get_logger(), "Asynchronously publishing: '%s'", async_message.data.c_str());
+                // Log the message to the console to show progress
+                RCLCPP_INFO(this->get_logger(), "Asynchronously publishing: '%s'", async_message.data.c_str());
 
-            // Publish the message using the asynchronous publisher
-            async_publisher_->publish(async_message);
+                // Publish the message using the asynchronous publisher
+                async_publisher_->publish(async_message);
 
-            // Prepare the count for the next message
-            count_++;
+                // Prepare the count for the next message
+                count_++;
+            };
+
+            // This timer will trigger the publication of new data every half a second
+            timer_ = this->create_wall_timer(500ms, timer_callback);
         }
 
+    private:
         // This timer will trigger the publication of new data every half a second
         rclcpp::TimerBase::SharedPtr timer_;
 
@@ -322,42 +319,36 @@ In a new source file named ``src/sync_async_reader.cpp`` write the following con
 
 .. code-block:: C++
 
-    #include <functional>
     #include <memory>
 
     #include "rclcpp/rclcpp.hpp"
     #include "std_msgs/msg/string.hpp"
 
-    using std::placeholders::_1;
-
     class SyncAsyncSubscriber : public rclcpp::Node
     {
     public:
 
         SyncAsyncSubscriber()
             : Node("sync_async_subscriber")
         {
+            // Lambda function to run every time a new message is received
+            auto topic_callback = [this](const std_msgs::msg::String & msg){
+                RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg.data.c_str());
+            };
+
             // Create the synchronous subscriber on topic 'sync_topic'
             // and tie it to the topic_callback
             sync_subscription_ = this->create_subscription<std_msgs::msg::String>(
-                "sync_topic", 10, std::bind(&SyncAsyncSubscriber::topic_callback, this, _1));
+                "sync_topic", 10, topic_callback);
 
             // Create the asynchronous subscriber on topic 'async_topic'
             // and tie it to the topic_callback
             async_subscription_ = this->create_subscription<std_msgs::msg::String>(
-                "async_topic", 10, std::bind(&SyncAsyncSubscriber::topic_callback, this, _1));
+                "async_topic", 10, topic_callback);
         }
 
     private:
 
-        /**
-         * Actions to run every time a new message is received
-         */
-        void topic_callback(const std_msgs::msg::String & msg) const
-        {
-            RCLCPP_INFO(this->get_logger(), "I heard: '%s'", msg.data.c_str());
-        }
-
         // A subscriber that listens to topic 'sync_topic'
         rclcpp::Subscription<std_msgs::msg::String>::SharedPtr sync_subscription_;
 

source/Tutorials/Advanced/Reading-From-A-Bag-File-CPP.rst

@@ -86,8 +86,9 @@ Inside your package's ``src`` directory, create a new file called ``simple_bag_r
         : Node("playback_node")
         {
           publisher_ = this->create_publisher<turtlesim::msg::Pose>("/turtle1/pose", 10);
-          timer_ = this->create_wall_timer(
-              100ms, std::bind(&PlaybackNode::timer_callback, this));
+
+          auto timer_callback_lambda = [this](){return this->timer_callback();};
+          timer_ = this->create_wall_timer(100ms, timer_callback_lambda);
 
           reader_.open(bag_filename);
         }
@@ -158,8 +159,8 @@ Note the constructor takes a path to the bag file as a parameter.
       : Node("playback_node")
       {
         publisher_ = this->create_publisher<turtlesim::msg::Pose>("/turtle1/pose", 10);
-        timer_ = this->create_wall_timer(
-            100ms, std::bind(&PlaybackNode::timer_callback, this));
+        auto timer_callback_lambda = [this](){return this->timer_callback();};
+        timer_ = this->create_wall_timer(100ms, timer_callback_lambda);
 
 We also open the bag in the constructor.
 

source/Tutorials/Advanced/Recording-A-Bag-From-Your-Own-Node-CPP.rst

@@ -84,8 +84,6 @@ Inside the ``ros2_ws/src/bag_recorder_nodes/src`` directory, create a new file c
 
     #include <rosbag2_cpp/writer.hpp>
 
-    using std::placeholders::_1;
-
     class SimpleBagRecorder : public rclcpp::Node
     {
     public:
@@ -96,17 +94,17 @@ Inside the ``ros2_ws/src/bag_recorder_nodes/src`` directory, create a new file c
 
         writer_->open("my_bag");
 
+        auto subscription_callback_lambda = [this](std::shared_ptr<rclcpp::SerializedMessage> msg){
+          rclcpp::Time time_stamp = this->now();
+
+          writer_->write(msg, "chatter", "std_msgs/msg/String", time_stamp);
+        };
+
         subscription_ = create_subscription<std_msgs::msg::String>(
-          "chatter", 10, std::bind(&SimpleBagRecorder::topic_callback, this, _1));
+          "chatter", 10, subscription_callback_lambda);
       }
 
     private:
-      void topic_callback(std::shared_ptr<rclcpp::SerializedMessage> msg) const
-      {
-        rclcpp::Time time_stamp = this->now();
-
-        writer_->write(msg, "chatter", "std_msgs/msg/String", time_stamp);
-      }
 
       rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscription_;
       std::unique_ptr<rosbag2_cpp::Writer> writer_;
@@ -146,8 +144,14 @@ We will write data to the bag in the callback.
 
 .. code-block:: C++
 
+        auto subscription_callback_lambda = [this](std::shared_ptr<rclcpp::SerializedMessage> msg){
+          rclcpp::Time time_stamp = this->now();
+
+          writer_->write(msg, "chatter", "std_msgs/msg/String", time_stamp);
+        };
+
         subscription_ = create_subscription<std_msgs::msg::String>(
-          "chatter", 10, std::bind(&SimpleBagRecorder::topic_callback, this, _1));
+          "chatter", 10, subscription_callback_lambda);
 
 The callback itself is different from a typical callback.
 Rather than receiving an instance of the data type of the topic, we instead receive a ``rclcpp::SerializedMessage``.
@@ -158,8 +162,7 @@ We do this for two reasons.
 
 .. code-block:: C++
 
-      void topic_callback(std::shared_ptr<rclcpp::SerializedMessage> msg) const
-      {
+        auto subscription_callback_lambda = [this](std::shared_ptr<rclcpp::SerializedMessage> msg){
 
 Within the subscription callback, the first thing to do is determine the time stamp to use for the stored message.
 This can be anything appropriate to your data, but two common values are the time at which the data was produced, if known, and the time it is received.
@@ -349,7 +352,8 @@ Inside the ``ros2_ws/src/bag_recorder_nodes/src`` directory, create a new file c
            rmw_get_serialization_format(),
            ""});
 
-        timer_ = create_wall_timer(1s, std::bind(&DataGenerator::timer_callback, this));
+        auto timer_callback_lambda = [this](){return this->timer_callback();};
+        timer_ = create_wall_timer(1s, timer_callback_lambda);
       }
 
     private:
@@ -401,7 +405,8 @@ The timer fires with a one-second period, and calls the given member function wh
 
 .. code-block:: C++
 
-        timer_ = create_wall_timer(1s, std::bind(&DataGenerator::timer_callback, this));
+        auto timer_callback_lambda = [this](){return this->timer_callback();};
+        timer_ = create_wall_timer(1s, timer_callback_lambda);
 
 Within the timer callback, we generate (or otherwise obtain, e.g. read from a serial port connected to some hardware) the data we wish to store in the bag.
 The important difference between this and the previous sample is that the data is not yet serialised.

source/Tutorials/Beginner-Client-Libraries/Custom-ROS2-Interfaces.rst

@@ -1,3 +1,5 @@
+//! SEE
+
 .. redirect-from::
 
     Tutorials/Custom-ROS2-Interfaces
@@ -266,18 +268,17 @@ Since you'll be changing the standard string msg to a numerical one, the output
         : Node("minimal_publisher"), count_(0)
         {
           publisher_ = this->create_publisher<tutorial_interfaces::msg::Num>("topic", 10);  // CHANGE
-          timer_ = this->create_wall_timer(
-            500ms, std::bind(&MinimalPublisher::timer_callback, this));
+
+          auto timer_callback = [this](){
+            auto message = tutorial_interfaces::msg::Num();                                   // CHANGE
+            message.num = this->count_++;                                                     // CHANGE
+            RCLCPP_INFO_STREAM(this->get_logger(), "Publishing: '" << message.num << "'");    // CHANGE
+            publisher_->publish(message);
+          };
+          timer_ = this->create_wall_timer(500ms, timer_callback);
         }
 
       private:
-        void timer_callback()
-        {
-          auto message = tutorial_interfaces::msg::Num();                                   // CHANGE
-          message.num = this->count_++;                                                     // CHANGE
-          RCLCPP_INFO_STREAM(this->get_logger(), "Publishing: '" << message.num << "'");    // CHANGE
-          publisher_->publish(message);
-        }
         rclcpp::TimerBase::SharedPtr timer_;
         rclcpp::Publisher<tutorial_interfaces::msg::Num>::SharedPtr publisher_;             // CHANGE
         size_t count_;
@@ -355,15 +356,14 @@ Since you'll be changing the standard string msg to a numerical one, the output
         MinimalSubscriber()
         : Node("minimal_subscriber")
         {
+          auto topic_callback = [this](const tutorial_interfaces::msg::Num & msg){     // CHANGE
+            RCLCPP_INFO_STREAM(this->get_logger(), "I heard: '" << msg.num << "'");    // CHANGE
+          };
           subscription_ = this->create_subscription<tutorial_interfaces::msg::Num>(    // CHANGE
-            "topic", 10, std::bind(&MinimalSubscriber::topic_callback, this, _1));
+            "topic", 10, topic_callback);
         }
 
       private:
-        void topic_callback(const tutorial_interfaces::msg::Num & msg) const  // CHANGE
-        {
-          RCLCPP_INFO_STREAM(this->get_logger(), "I heard: '" << msg.num << "'");     // CHANGE
-        }
         rclcpp::Subscription<tutorial_interfaces::msg::Num>::SharedPtr subscription_;  // CHANGE
       };