Make the action tutorials work for dashing as well. (ros2#1083)

Signed-off-by: Chris Lalancette <[email protected]>

Author: clalancette

source/Tutorials/Actions/Writing-a-Cpp-Action-Server-Client.rst

@@ -128,29 +128,49 @@ Let's focus on writing an action server that computes the Fibonacci sequence usi
 
 Open up ``action_tutorials_cpp/src/fibonacci_action_server.cpp``, and put the following code in:
 
-.. literalinclude:: server.cpp
-    :language: c++
-    :linenos:
+.. tabs::
+
+  .. group-tab:: Eloquent and newer
+
+    .. literalinclude:: server-eloquent-and-newer.cpp
+        :language: c++
+        :linenos:
+
+  .. group-tab:: Dashing
+
+    .. literalinclude:: server-dashing.cpp
+        :language: c++
+        :linenos:
 
 The first few lines include all of the headers we need to compile.
 
 Next we create a class that is a derived class of ``rclcpp::Node``:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 14
 
 The constructor for the ``FibonacciActionServer`` class initializes the node name as ``fibonacci_action_server``:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 21-22
 
 The constructor also instantiates a new action server:
 
-.. literalinclude:: server.cpp
-    :language: c++
-    :lines: 26-31
+.. tabs::
+
+  .. group-tab:: Eloquent and newer
+
+    .. literalinclude:: server-eloquent-and-newer.cpp
+        :language: c++
+        :lines: 26-31
+
+  .. group-tab:: Dashing
+
+    .. literalinclude:: server-dashing.cpp
+        :language: c++
+        :lines: 26-34
 
 An action server requires 6 things:
 
@@ -166,31 +186,31 @@ Note that all of the callbacks need to return quickly, otherwise we risk starvin
 
 We start with the callback for handling new goals:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 37-44
 
 This implementation just accepts all goals.
 
 Next up is the callback for dealing with cancellation:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 46-52
 
 This implementation just tells the client that it accepted the cancellation.
 
 The last of the callbacks accepts a new goal and starts processing it:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 54-59
 
 Since the execution is a long-running operation, we spawn off a thread to do the actual work and return from ``handle_accepted`` quickly.
 
 All further processing and updates are done in the ``execute`` method in the new thread:
 
-.. literalinclude:: server.cpp
+.. literalinclude:: server-eloquent-and-newer.cpp
     :language: c++
     :lines: 61-95
 
@@ -255,29 +275,49 @@ Source the workspace we just built (``action_ws``), and try to run the action se
 
 Open up ``action_tutorials_cpp/src/fibonacci_action_client.cpp``, and put the following code in:
 
-.. literalinclude:: client.cpp
-    :language: c++
-    :linenos:
+.. tabs::
+
+  .. group-tab:: Eloquent and newer
+
+    .. literalinclude:: client-eloquent-and-newer.cpp
+        :language: c++
+        :linenos:
+
+  .. group-tab:: Dashing
+
+    .. literalinclude:: client-dashing.cpp
+        :language: c++
+        :linenos:
 
 The first few lines include all of the headers we need to compile.
 
 Next we create a class that is a derived class of ``rclcpp::Node``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 15
 
 The constructor for the ``FibonacciActionClient`` class initializes the node name as ``fibonacci_action_client``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 20-22
 
 The constructor also instantiates a new action client:
 
-.. literalinclude:: client.cpp
-    :language: c++
-    :lines: 24-26
+.. tabs::
+
+  .. group-tab:: Eloquent and newer
+
+    .. literalinclude:: client-eloquent-and-newer.cpp
+        :language: c++
+        :lines: 24-26
+
+  .. group-tab:: Dashing
+
+    .. literalinclude:: client-dashing.cpp
+        :language: c++
+        :lines: 24-29
 
 An action client requires 3 things:
 
@@ -287,13 +327,13 @@ An action client requires 3 things:
 
 We also instantiate a ROS timer that will kick off the one and only call to ``send_goal``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 27-30
 
 When the timer expires, it will call ``send_goal``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 32-57
 
@@ -308,21 +348,21 @@ This function does the following:
 When the server receives and accepts the goal, it will send a response to the client.
 That response is handled by ``goal_response_callback``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 62-71
 
 Assuming the goal was accepted by the server, it will start processing.
 Any feedback to the client will be handled by the ``feedback_callback``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 72-83
 
 When the server is finished processing, it will return a result to the client.
 The result is handled by the ``result_callback``:
 
-.. literalinclude:: client.cpp
+.. literalinclude:: client-eloquent-and-newer.cpp
     :language: c++
     :lines: 84-107
 

source/Tutorials/Actions/client-dashing.cpp

@@ -0,0 +1,115 @@
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
+#include <sstream>
+
+#include "action_tutorials_interfaces/action/fibonacci.hpp"
+
+#include "rclcpp/rclcpp.hpp"
+#include "rclcpp_action/rclcpp_action.hpp"
+#include "rclcpp_components/register_node_macro.hpp"
+
+namespace action_tutorials_cpp
+{
+class FibonacciActionClient : public rclcpp::Node
+{
+public:
+  using Fibonacci = action_tutorials_interfaces::action::Fibonacci;
+  using GoalHandleFibonacci = rclcpp_action::ClientGoalHandle<Fibonacci>;
+
+  explicit FibonacciActionClient(const rclcpp::NodeOptions & options)
+  : Node("fibonacci_action_client", options)
+  {
+    this->client_ptr_ = rclcpp_action::create_client<Fibonacci>(
+      this->get_node_base_interface(),
+      this->get_node_graph_interface(),
+      this->get_node_logging_interface(),
+      this->get_node_waitables_interface(),
+      "fibonacci");
+
+    this->timer_ = this->create_wall_timer(
+      std::chrono::milliseconds(500),
+      std::bind(&FibonacciActionClient::send_goal, this));
+  }
+
+  void send_goal()
+  {
+    using namespace std::placeholders;
+
+    this->timer_->cancel();
+
+    if (!this->client_ptr_->wait_for_action_server()) {
+      RCLCPP_ERROR(this->get_logger(), "Action server not available after waiting");
+      rclcpp::shutdown();
+    }
+
+    auto goal_msg = Fibonacci::Goal();
+    goal_msg.order = 10;
+
+    RCLCPP_INFO(this->get_logger(), "Sending goal");
+
+    auto send_goal_options = rclcpp_action::Client<Fibonacci>::SendGoalOptions();
+    send_goal_options.goal_response_callback =
+      std::bind(&FibonacciActionClient::goal_response_callback, this, _1);
+    send_goal_options.feedback_callback =
+      std::bind(&FibonacciActionClient::feedback_callback, this, _1, _2);
+    send_goal_options.result_callback =
+      std::bind(&FibonacciActionClient::result_callback, this, _1);
+    this->client_ptr_->async_send_goal(goal_msg, send_goal_options);
+  }
+
+private:
+  rclcpp_action::Client<Fibonacci>::SharedPtr client_ptr_;
+  rclcpp::TimerBase::SharedPtr timer_;
+
+  void goal_response_callback(std::shared_future<GoalHandleFibonacci::SharedPtr> future)
+  {
+    auto goal_handle = future.get();
+    if (!goal_handle) {
+      RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
+    } else {
+      RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
+    }
+  }
+
+  void feedback_callback(
+    GoalHandleFibonacci::SharedPtr,
+    const std::shared_ptr<const Fibonacci::Feedback> feedback)
+  {
+    std::stringstream ss;
+    ss << "Next number in sequence received: ";
+    for (auto number : feedback->partial_sequence) {
+      ss << number << " ";
+    }
+    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
+  }
+
+  void result_callback(const GoalHandleFibonacci::WrappedResult & result)
+  {
+    switch (result.code) {
+      case rclcpp_action::ResultCode::SUCCEEDED:
+        break;
+      case rclcpp_action::ResultCode::ABORTED:
+        RCLCPP_ERROR(this->get_logger(), "Goal was aborted");
+        return;
+      case rclcpp_action::ResultCode::CANCELED:
+        RCLCPP_ERROR(this->get_logger(), "Goal was canceled");
+        return;
+      default:
+        RCLCPP_ERROR(this->get_logger(), "Unknown result code");
+        return;
+    }
+    std::stringstream ss;
+    ss << "Result received: ";
+    for (auto number : result.result->sequence) {
+      ss << number << " ";
+    }
+    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
+    rclcpp::shutdown();
+  }
+};  // class FibonacciActionClient
+
+}  // namespace action_tutorials_cpp
+
+RCLCPP_COMPONENTS_REGISTER_NODE(action_tutorials_cpp::FibonacciActionClient)