creating alias for Parameters and fixing style of concurrence demo

Author: mgonzs13

README.md

@@ -2059,15 +2059,15 @@ int main(int argc, char *argv[]) {
 
   // Create concurrent state
   auto concurrent_state = std::make_shared<yasmin::Concurrence>(
-      std::map<std::string, std::shared_ptr<yasmin::State>>{{"FOO", foo_state},
-                                                            {"BAR", bar_state}},
+      yasmin::StateMap{
+          {"FOO", foo_state},
+          {"BAR", bar_state},
+      },
       "defaulted",
-      yasmin::Concurrence::OutcomeMap{
-          {"outcome1",
-           yasmin::Concurrence::StateOutcomeMap{{"FOO", "outcome1"},
-                                                {"BAR", "outcome3"}}},
-          {"outcome2", yasmin::Concurrence::StateOutcomeMap{
-                           {"FOO", "outcome2"}, {"BAR", "outcome3"}}}});
+      yasmin::OutcomeMap{
+          {"outcome1", {{"FOO", "outcome1"}, {"BAR", "outcome3"}}},
+          {"outcome2", {{"FOO", "outcome2"}, {"BAR", "outcome3"}}},
+      });
 
   // Add concurrent state to the state machine
   sm->add_state("CONCURRENCE", concurrent_state,
@@ -2875,7 +2875,7 @@ int main(int argc, char *argv[]) {
   // Add states to the state machine
   sm->add_state("GETTING_PARAMETERS",
                 std::make_shared<yasmin_ros::GetParametersState>(
-                    std::map<std::string, std::any>{
+                    yasmin_ros::GetParametersState::Parameters{
                         {"max_counter", 3},
                         {"counter_str", std::string("Counter")},
                     }),

docs/tutorials/cpp/concurrence_demo.html

@@ -272,25 +272,25 @@ <h2>3. Create Concurrence Container</h2>
   yasmin_ros::set_ros_loggers();
   YASMIN_LOG_INFO("yasmin_concurrence_demo");
 
-auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
-    std::initializer_list&lt;std::string&gt;{"outcome4"}, true);
-
-auto foo_state = std::make_shared&lt;FooState&gt;();
-auto bar_state = std::make_shared&lt;BarState&gt;();
-
-auto concurrent_state = std::make_shared&lt;yasmin::Concurrence&gt;(
-    std::map&lt;std::string, std::shared_ptr&lt;yasmin::State&gt;&gt;{
-        {"FOO", foo_state},
-        {"BAR", bar_state}
-    },
-    "defaulted",
-    yasmin::Concurrence::OutcomeMap{
-        {"outcome1",
-         yasmin::Concurrence::StateOutcomeMap{{"FOO", "outcome1"},
-                                              {"BAR", "outcome3"}}},
-        {"outcome2", yasmin::Concurrence::StateOutcomeMap{
-                         {"FOO", "outcome2"}, {"BAR", "outcome3"}}}
-    });</code></pre>
+  // Create a state machine
+  auto sm = std::make_shared&lt;yasmin::StateMachine&gt;(
+      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;();
+
+  // Create concurrent state
+  auto concurrent_state = std::make_shared&lt;yasmin::Concurrence&gt;(
+      yasmin::StateMap{
+          {"FOO", foo_state},
+          {"BAR", bar_state},
+      },
+      "defaulted",
+      yasmin::OutcomeMap{
+          {"outcome1", {{"FOO", "outcome1"}, {"BAR", "outcome3"}}},
+          {"outcome2", {{"FOO", "outcome2"}, {"BAR", "outcome3"}}},
+      });</code></pre>
 
         <h2>4. Add to State Machine</h2>
         <p>
@@ -301,23 +301,29 @@ <h2>4. Add to State Machine</h2>
           <code>outcome4</code>. This setup enables the demonstration to run
           through several concurrent executions before terminating.
         </p>
-        <pre><code class="language-cpp">sm-&gt;add_state("CONCURRENCE", concurrent_state,
-              {
-                  {"outcome1", "CONCURRENCE"},
-                  {"outcome2", "CONCURRENCE"},
-                  {"defaulted", "outcome4"},
-              });
+        <pre><code class="language-cpp">  // Add concurrent state to the state machine
+  sm-&gt;add_state("CONCURRENCE", concurrent_state,
+                {
+                    {"outcome1", "CONCURRENCE"},
+                    {"outcome2", "CONCURRENCE"},
+                    {"defaulted", "outcome4"},
+                });
 
-yasmin_viewer::YasminViewerPub yasmin_pub(sm, "YASMIN_CONCURRENCE_DEMO");
+  // Publish state machine updates
+  yasmin_viewer::YasminViewerPub yasmin_pub(sm, "YASMIN_CONCURRENCE_DEMO");
 
-try {
+  // Execute the state machine
+  try {
     std::string outcome = (*sm.get())();
     YASMIN_LOG_INFO(outcome.c_str());
-} catch (const std::exception &e) {
+  } catch (const std::exception &amp;e) {
     YASMIN_LOG_WARN(e.what());
-}
+  }
+
+  rclcpp::shutdown();
 
-rclcpp::shutdown();</code></pre>
+  return 0;
+}</code></pre>
 
         <h2>5. Run the Demo</h2>
         <p>

docs/tutorials/cpp/monitor_demo.html

@@ -200,7 +200,7 @@ <h2>1. Define the Monitor State</h2>
 
   std::string
   monitor_handler(yasmin::Blackboard::SharedPtr blackboard,
-                  std::shared_ptr&lt;nav_msgs::msg::Odometry&gt; msg) {
+                  nav_msgs::msg::Odometry::SharedPtr msg) {
 
     (void)blackboard;
 

docs/tutorials/cpp/parameters_demo.html

@@ -258,7 +258,7 @@ <h2>2. Create the State Machine</h2>
   // Add states to the state machine
   sm-&gt;add_state("GETTING_PARAMETERS",
                 std::make_shared&lt;yasmin_ros::GetParametersState&gt;(
-                    std::map&lt;std::string, std::any&gt;{
+                    yasmin_ros::GetParametersState::Parameters{
                         {"max_counter", 3},
                         {"counter_str", std::string("Counter")},
                     }),

yasmin_demos/src/concurrence_demo.cpp

@@ -134,12 +134,15 @@ int main(int argc, char *argv[]) {
 
   // Create concurrent state
   auto concurrent_state = std::make_shared<yasmin::Concurrence>(
-      yasmin::StateMap{{"FOO", foo_state}, {"BAR", bar_state}}, "defaulted",
+      yasmin::StateMap{
+          {"FOO", foo_state},
+          {"BAR", bar_state},
+      },
+      "defaulted",
       yasmin::OutcomeMap{
-          {"outcome1",
-           yasmin::StateOutcomeMap{{"FOO", "outcome1"}, {"BAR", "outcome3"}}},
-          {"outcome2",
-           yasmin::StateOutcomeMap{{"FOO", "outcome2"}, {"BAR", "outcome3"}}}});
+          {"outcome1", {{"FOO", "outcome1"}, {"BAR", "outcome3"}}},
+          {"outcome2", {{"FOO", "outcome2"}, {"BAR", "outcome3"}}},
+      });
 
   // Add concurrent state to the state machine
   sm->add_state("CONCURRENCE", concurrent_state,

yasmin_demos/src/parameters_demo.cpp

@@ -17,7 +17,6 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <unordered_map>
 
 #include "rclcpp/rclcpp.hpp"
 #include "yasmin/logs.hpp"
@@ -119,7 +118,7 @@ int main(int argc, char *argv[]) {
   // Add states to the state machine
   sm->add_state("GETTING_PARAMETERS",
                 std::make_shared<yasmin_ros::GetParametersState>(
-                    std::unordered_map<std::string, std::any>{
+                    yasmin_ros::GetParametersState::Parameters{
                         {"max_counter", 3},
                         {"counter_str", std::string("Counter")},
                     }),

yasmin_ros/include/yasmin_ros/get_parameters_state.hpp

@@ -36,15 +36,19 @@ namespace yasmin_ros {
  */
 class GetParametersState : public yasmin::State {
 public:
+  /**
+   * @brief Type alias for a map of parameters.
+   */
+  using Parameters = std::unordered_map<std::string, std::any>;
+
   /**
    * @brief Constructs a GetParametersState with a map of parameters.
    *
    * @param parameters A map of parameter names to their default values.
    * @param node A shared pointer to the ROS 2 node.
    */
-  GetParametersState(
-      const std::unordered_map<std::string, std::any> &parameters,
-      rclcpp::Node::SharedPtr node = nullptr);
+  GetParametersState(const Parameters &parameters,
+                     rclcpp::Node::SharedPtr node = nullptr);
 
   /**
    * @brief Executes the state to retrieve parameters.