Improving types macros by adding make functions (make_share, make_unique)

Author: mgonzs13

README.md

@@ -184,25 +184,23 @@ <h2>1. Define the Action State</h2>
             std::bind(&FibonacciState::response_handler, this, _1, _2),
             std::bind(&FibonacciState::print_feedback, this, _1, _2)) {};
 
-  Fibonacci::Goal create_goal_handler(
-      yasmin::Blackboard::SharedPtr blackboard) {
+  Fibonacci::Goal
+  create_goal_handler(yasmin::Blackboard::SharedPtr blackboard) {
 
     auto goal = Fibonacci::Goal();
     goal.order = blackboard-&gt;get&lt;int&gt;("n");
     return goal;
   };
 
-  std::string
-  response_handler(yasmin::Blackboard::SharedPtr blackboard,
-                   Fibonacci::Result::SharedPtr response) {
+  std::string response_handler(yasmin::Blackboard::SharedPtr blackboard,
+                               Fibonacci::Result::SharedPtr response) {
 
     blackboard-&gt;set&lt;std::vector&lt;int&gt;&gt;("fibo_res", response-&gt;sequence);
     return yasmin_ros::basic_outcomes::SUCCEED;
   };
 
-  void
-  print_feedback(yasmin::Blackboard::SharedPtr blackboard,
-                 std::shared_ptr&lt;const Fibonacci::Feedback&gt; feedback) {
+  void print_feedback(yasmin::Blackboard::SharedPtr blackboard,
+                      std::shared_ptr&lt;const Fibonacci::Feedback&gt; feedback) {
     (void)blackboard;
 
     std::stringstream ss;
@@ -231,7 +229,6 @@ <h2>2. Create the State Machine</h2>
           first 10 Fibonacci numbers.
         </p>
         <pre><code class="language-cpp">int main(int argc, char *argv[]) {
-
   // Initialize ROS 2
   rclcpp::init(argc, argv);
 
@@ -240,18 +237,18 @@ <h2>2. Create the State Machine</h2>
   YASMIN_LOG_INFO("yasmin_action_client_demo");
 
   // Create the state machine
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
 
   // Add states to the state machine
-  sm-&gt;add_state("CALLING_FIBONACCI", std::make_shared&lt;FibonacciState&gt;(),
+  sm-&gt;add_state("CALLING_FIBONACCI", FibonacciState::make_shared(),
                 {
                     {yasmin_ros::basic_outcomes::SUCCEED, "PRINTING_RESULT"},
                     {yasmin_ros::basic_outcomes::CANCEL, "outcome4"},
                     {yasmin_ros::basic_outcomes::ABORT, "outcome4"},
                 });
   sm-&gt;add_state("PRINTING_RESULT",
-                std::make_shared&lt;yasmin::CbState&gt;(
+                yasmin::CbState::make_shared(
                     std::initializer_list&lt;std::string&gt;{
                         yasmin_ros::basic_outcomes::SUCCEED},
                     print_result),
@@ -263,8 +260,7 @@ <h2>2. Create the State Machine</h2>
   yasmin_viewer::YasminViewerPub yasmin_pub(sm, "YASMIN_ACTION_CLIENT_DEMO");
 
   // Create an initial blackboard and set the Fibonacci order
-  yasmin::Blackboard::SharedPtr blackboard =
-      std::make_shared&lt;yasmin::Blackboard&gt;();
+  yasmin::Blackboard::SharedPtr blackboard = yasmin::Blackboard::make_shared();
   blackboard-&gt;set&lt;int&gt;("n", 10);
 
   // Execute the state machine

docs/tutorials/cpp/action_client_demo.html

@@ -176,7 +176,7 @@ <h2>1. Create the FooState</h2>
   /**
    * @brief Constructs a FooState object, initializing the counter.
    */
-  FooState() : yasmin::State({"outcome1", "outcome2"}), counter(0){};
+  FooState() : yasmin::State({"outcome1", "outcome2"}), counter(0) {};
 
   /**
    * @brief Executes the Foo state logic.
@@ -189,8 +189,7 @@ <h2>1. Create the FooState</h2>
    * @param blackboard Shared pointer to the blackboard for state communication.
    * @return std::string The outcome of the execution: "outcome1" or "outcome2".
    */
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state FOO");
     std::this_thread::sleep_for(std::chrono::seconds(3));
 
@@ -240,8 +239,7 @@ <h2>2. Create the BarState</h2>
    * @param blackboard Shared pointer to the blackboard for state communication.
    * @return std::string The outcome of the execution: "outcome3".
    */
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state BAR");
     std::this_thread::sleep_for(std::chrono::seconds(3));
 
@@ -275,16 +273,16 @@ <h2>3. Main Function</h2>
   YASMIN_LOG_INFO("yasmin_demo");
 
   // Create a state machine
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
 
   // Add states to the state machine
-  sm-&gt;add_state("FOO", std::make_shared&lt;FooState&gt;(),
+  sm-&gt;add_state("FOO", FooState::make_shared(),
                 {
                     {"outcome1", "BAR"},
                     {"outcome2", "outcome4"},
                 });
-  sm-&gt;add_state("BAR", std::make_shared&lt;BarState&gt;(),
+  sm-&gt;add_state("BAR", BarState::make_shared(),
                 {
                     {"outcome3", "FOO"},
                 });

docs/tutorials/cpp/basic_fsm.html

@@ -191,8 +191,7 @@ <h2>1. Create the FooState</h2>
   FooState()
       : yasmin::State({"outcome1", "outcome2", "outcome3"}), counter(0) {};
 
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state FOO");
     std::this_thread::sleep_for(std::chrono::seconds(2));
 
@@ -232,8 +231,7 @@ <h2>2. Create the BarState</h2>
 public:
   BarState() : yasmin::State({"outcome3"}) {}
 
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state BAR");
     std::this_thread::sleep_for(std::chrono::seconds(4));
 
@@ -273,15 +271,15 @@ <h2>3. Create Concurrence Container</h2>
   YASMIN_LOG_INFO("yasmin_concurrence_demo");
 
   // Create a state machine
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
 
   // Create states to run concurrently
-  auto foo_state = std::make_shared&lt;FooState&gt;();
-  auto bar_state = std::make_shared&lt;BarState&gt;();
+  auto foo_state = FooState::make_shared();
+  auto bar_state = BarState::make_shared();
 
   // Create concurrent state
-  auto concurrent_state = std::make_shared&lt;yasmin::Concurrence&gt;(
+  auto concurrent_state = yasmin::Concurrence::make_shared(
       yasmin::StateMap{
           {"FOO", foo_state},
           {"BAR", bar_state},

docs/tutorials/cpp/concurrence_demo.html

@@ -198,9 +198,8 @@ <h2>1. Define the Monitor State</h2>
     this-&gt;times = times;
   };
 
-  std::string
-  monitor_handler(yasmin::Blackboard::SharedPtr blackboard,
-                  nav_msgs::msg::Odometry::SharedPtr msg) {
+  std::string monitor_handler(yasmin::Blackboard::SharedPtr blackboard,
+                              nav_msgs::msg::Odometry::SharedPtr msg) {
 
     (void)blackboard;
 
@@ -243,12 +242,12 @@ <h2>2. Create the State Machine</h2>
   YASMIN_LOG_INFO("yasmin_monitor_demo");
 
   // Create a state machine with a final outcome
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
 
   // Add states to the state machine
   sm-&gt;add_state(
-      "PRINTING_ODOM", std::make_shared&lt;PrintOdometryState&gt;(5),
+      "PRINTING_ODOM", PrintOdometryState::make_shared(5),
       {
           {"outcome1",
            "PRINTING_ODOM"},        // Transition back to itself on outcome1

docs/tutorials/cpp/monitor_demo.html

@@ -262,8 +262,7 @@ <h2>Source Code</h2>
   }
 };
 
-std::string
-create_waypoints(yasmin::Blackboard::SharedPtr blackboard) {
+std::string create_waypoints(yasmin::Blackboard::SharedPtr blackboard) {
   std::map&lt;std::string, std::vector&lt;double&gt;&gt; waypoints = {
       {"entrance", {1.25, 6.30, -0.78, 0.67}},
       {"bathroom", {4.89, 1.64, 0.0, 1.0}},
@@ -297,8 +296,7 @@ <h2>Source Code</h2>
   return yasmin_ros::basic_outcomes::SUCCEED;
 }
 
-std::string
-get_next_waypoint(yasmin::Blackboard::SharedPtr blackboard) {
+std::string get_next_waypoint(yasmin::Blackboard::SharedPtr blackboard) {
   auto random_waypoints =
       blackboard-&gt;get&lt;std::vector&lt;std::string&gt;&gt;("random_waypoints");
   auto waypoints =
@@ -332,26 +330,26 @@ <h2>Source Code</h2>
   rclcpp::init(argc, argv);
   yasmin_ros::set_ros_loggers();
 
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{yasmin_ros::basic_outcomes::SUCCEED,
                                          yasmin_ros::basic_outcomes::ABORT,
                                          yasmin_ros::basic_outcomes::CANCEL},
       true);
-  auto nav_sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto nav_sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{yasmin_ros::basic_outcomes::SUCCEED,
                                          yasmin_ros::basic_outcomes::ABORT,
                                          yasmin_ros::basic_outcomes::CANCEL});
 
   sm-&gt;add_state(
       "CREATING_WAYPOINTS",
-      std::make_shared&lt;yasmin::CbState&gt;(
+      yasmin::CbState::make_shared(
           std::initializer_list&lt;std::string&gt;{
               yasmin_ros::basic_outcomes::SUCCEED},
           create_waypoints),
       std::map&lt;std::string, std::string&gt;{
           {yasmin_ros::basic_outcomes::SUCCEED, "TAKING_RANDOM_WAYPOINTS"}});
   sm-&gt;add_state("TAKING_RANDOM_WAYPOINTS",
-                std::make_shared&lt;yasmin::CbState&gt;(
+                yasmin::CbState::make_shared(
                     std::initializer_list&lt;std::string&gt;{
                         yasmin_ros::basic_outcomes::SUCCEED},
                     take_random_waypoint),
@@ -360,13 +358,13 @@ <h2>Source Code</h2>
 
   nav_sm-&gt;add_state(
       "GETTING_NEXT_WAYPOINT",
-      std::make_shared&lt;yasmin::CbState&gt;(
+      yasmin::CbState::make_shared(
           std::initializer_list&lt;std::string&gt;{END, HAS_NEXT}, get_next_waypoint),
       std::map&lt;std::string, std::string&gt;{
           {END, yasmin_ros::basic_outcomes::SUCCEED},
           {HAS_NEXT, "NAVIGATING"}});
   nav_sm-&gt;add_state(
-      "NAVIGATING", std::make_shared&lt;Nav2State&gt;(),
+      "NAVIGATING", Nav2State::make_shared(),
       std::map&lt;std::string, std::string&gt;{
           {yasmin_ros::basic_outcomes::SUCCEED, "GETTING_NEXT_WAYPOINT"},
           {yasmin_ros::basic_outcomes::CANCEL,
@@ -385,7 +383,7 @@ <h2>Source Code</h2>
 
   yasmin_viewer::YasminViewerPub yasmin_pub(sm, "YASMIN_NAV2_DEMO");
 
-  auto blackboard = std::make_shared&lt;yasmin::Blackboard&gt;();
+  auto blackboard = yasmin::Blackboard::make_shared();
   blackboard-&gt;set&lt;int&gt;("waypoints_num", 2);
 
   try {

docs/tutorials/cpp/nav2_demo.html

@@ -194,8 +194,7 @@ <h2>1. Define the States</h2>
 
   FooState() : yasmin::State({"outcome1", "outcome2"}), counter(0) {};
 
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state FOO");
     std::this_thread::sleep_for(std::chrono::seconds(3));
 
@@ -216,8 +215,7 @@ <h2>1. Define the States</h2>
 public:
   BarState() : yasmin::State({"outcome3"}) {}
 
-  std::string
-  execute(yasmin::Blackboard::SharedPtr blackboard) override {
+  std::string execute(yasmin::Blackboard::SharedPtr blackboard) override {
     YASMIN_LOG_INFO("Executing state BAR");
     std::this_thread::sleep_for(std::chrono::seconds(3));
 
@@ -252,12 +250,12 @@ <h2>2. Create the State Machine</h2>
   YASMIN_LOG_INFO("yasmin_parameters_demo");
 
   // Create a state machine
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
 
   // Add states to the state machine
   sm-&gt;add_state("GETTING_PARAMETERS",
-                std::make_shared&lt;yasmin_ros::GetParametersState&gt;(
+                yasmin_ros::GetParametersState::make_shared(
                     yasmin_ros::GetParametersState::Parameters{
                         {"max_counter", 3},
                         {"counter_str", std::string("Counter")},
@@ -266,12 +264,12 @@ <h2>2. Create the State Machine</h2>
                     {yasmin_ros::basic_outcomes::SUCCEED, "FOO"},
                     {yasmin_ros::basic_outcomes::ABORT, "outcome4"},
                 });
-  sm-&gt;add_state("FOO", std::make_shared&lt;FooState&gt;(),
+  sm-&gt;add_state("FOO", FooState::make_shared(),
                 {
                     {"outcome1", "BAR"},
                     {"outcome2", "outcome4"},
                 });
-  sm-&gt;add_state("BAR", std::make_shared&lt;BarState&gt;(),
+  sm-&gt;add_state("BAR", BarState::make_shared(),
                 {
                     {"outcome3", "FOO"},
                 });

docs/tutorials/cpp/parameters_demo.html

@@ -216,8 +216,7 @@ <h2>2. Create the State Machine</h2>
           before completing. This pattern is useful for sending sequences of
           commands, periodic status updates, or controlled test data generation.
         </p>
-        <pre><code class="language-cpp">std::string
-check_count(yasmin::Blackboard::SharedPtr blackboard) {
+        <pre><code class="language-cpp">std::string check_count(yasmin::Blackboard::SharedPtr blackboard) {
 
   // Sleep for 1 second to simulate some processing time
   rclcpp::sleep_for(std::chrono::seconds(1));
@@ -239,18 +238,18 @@ <h2>2. Create the State Machine</h2>
   YASMIN_LOG_INFO("yasmin_publisher_demo");
 
   // Create a state machine with a final outcome
-  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+  auto sm = yasmin::StateMachine::make_shared(
       std::initializer_list&lt;std::string&gt;{yasmin_ros::basic_outcomes::SUCCEED},
       true);
 
   // Add states to the state machine
-  sm-&gt;add_state("PUBLISHING_INT", std::make_shared&lt;PublishIntState&gt;(),
+  sm-&gt;add_state("PUBLISHING_INT", PublishIntState::make_shared(),
                 {
                     {yasmin_ros::basic_outcomes::SUCCEED,
                      "CHECKINNG_COUNTS"}, // Transition back to itself
                 });
   sm-&gt;add_state("CHECKINNG_COUNTS",
-                std::make_shared&lt;yasmin::CbState&gt;(
+                yasmin::CbState::make_shared(
                     std::initializer_list&lt;std::string&gt;{"outcome1", "outcome2"},
                     check_count),
                 {{"outcome1", yasmin_ros::basic_outcomes::SUCCEED},
@@ -261,7 +260,7 @@ <h2>2. Create the State Machine</h2>
 
   // Execute the state machine
   yasmin::Blackboard::SharedPtr blackboard =
-      std::make_shared&lt;yasmin::Blackboard&gt;();
+      yasmin::Blackboard::make_shared();
   blackboard-&gt;set&lt;int&gt;("counter", 0);
   blackboard-&gt;set&lt;int&gt;("max_count", 10);
   try {