Refactor cl_mission_tracker to pure component base architecture

Author: brettpac

smacc2_client_library/cl_foundation_pose/include/cl_foundation_pose/cl_foundation_pose.hpp

@@ -35,7 +35,9 @@ class ClFoundationPose : public smacc2::ISmaccClient
 
   void onInitialize() override
   {
-    //auto subcomponent = this->createComponent<CpTopicSubscriber<vision_msgs::msg::Detection3DArray>>("/detection3d_array");
+    auto subcomponent =
+      this->createComponent<CpTopicSubscriber<vision_msgs::msg::Detection3DArray>>(
+        "/detection3d_array");
   }
 };
 

smacc2_client_library/cl_mission_tracker/include/cl_mission_tracker/cl_mission_tracker.hpp

@@ -22,37 +22,59 @@
 #include <smacc2/smacc.hpp>
 #include <smacc2/smacc_client.hpp>
 
+#include <cl_mission_tracker/components/cp_decision_manager.hpp>
+
 namespace cl_mission_tracker
 {
+
+// Event: Battery load decision
 template <typename AsyncCB, typename Orthogonal>
 struct EvBatteryLoad : sc::event<EvBatteryLoad<AsyncCB, Orthogonal>>
 {
 };
 
+// Event: Radial motion decision
 template <typename AsyncCB, typename Orthogonal>
 struct EvRadialMotion : sc::event<EvRadialMotion<AsyncCB, Orthogonal>>
 {
 };
 
+// Event: S-pattern decision
 template <typename AsyncCB, typename Orthogonal>
 struct EvSPattern : sc::event<EvSPattern<AsyncCB, Orthogonal>>
 {
 };
 
+// Event: F-pattern decision
 template <typename AsyncCB, typename Orthogonal>
 struct EvFPattern : sc::event<EvFPattern<AsyncCB, Orthogonal>>
 {
 };
 
+/**
+ * @brief Client for mission tracking and decision sequencing.
+ *
+ * This client follows the pure component-based architecture pattern.
+ * It acts as an orchestrator that creates and wires components:
+ *
+ * - CpDecisionManager: Manages decision counter state
+ *
+ * Client behaviors should use requiresComponent() to access the
+ * decision manager, not direct client fields.
+ */
 class ClMissionTracker : public smacc2::ISmaccClient
 {
-private:
-  int decission_counter = 0;
-
 public:
   ClMissionTracker() {}
-  void nextDecission() { decission_counter++; }
-  int getDecissionCounter() { return decission_counter; }
+
+  virtual ~ClMissionTracker() {}
+
+  template <typename TOrthogonal, typename TClient>
+  void onComponentInitialization()
+  {
+    // Create decision manager component
+    this->createComponent<CpDecisionManager, TOrthogonal, ClMissionTracker>();
+  }
 };
 
 }  // namespace cl_mission_tracker

smacc2_client_library/cl_mission_tracker/include/cl_mission_tracker/client_behaviors/cb_battery_decission.hpp

@@ -19,16 +19,28 @@
  ******************************************************************************************************************/
 #pragma once
 
+#include <cl_mission_tracker/cl_mission_tracker.hpp>
+#include <cl_mission_tracker/components/cp_decision_manager.hpp>
 #include <smacc2/smacc.hpp>
 #include <smacc2/smacc_asynchronous_client_behavior.hpp>
 
 namespace cl_mission_tracker
 {
 
+/**
+ * @brief Behavior that makes mission decisions based on a counter.
+ *
+ * This behavior uses requiresComponent() to access:
+ * - CpDecisionManager: For decision counter state
+ *
+ * Based on the current decision count, it posts different events
+ * to control the mission flow.
+ */
 class CbBatteryDecission : public smacc2::SmaccAsyncClientBehavior
 {
 private:
-  cl_mission_tracker::ClMissionTracker * missionTracker_ = nullptr;
+  // Component accessed via requiresComponent (NOT direct client!)
+  CpDecisionManager * decisionManager_ = nullptr;
   std::function<void()> postEventFn_;
 
 public:
@@ -45,11 +57,13 @@ class CbBatteryDecission : public smacc2::SmaccAsyncClientBehavior
   {
     postEventFn_ = [this]()
     {
-      this->requiresClient(missionTracker_);
-      int decission_count = missionTracker_->getDecissionCounter();
-      missionTracker_->nextDecission();
+      // Get component via requiresComponent pattern (NOT requiresClient!)
+      this->requiresComponent(decisionManager_, true);
 
-      switch (decission_count)
+      // Get current decision and advance counter
+      int decisionCount = decisionManager_->nextDecision();
+
+      switch (decisionCount)
       {
         case 0:
         case 2:
@@ -71,4 +85,5 @@ class CbBatteryDecission : public smacc2::SmaccAsyncClientBehavior
     };
   }
 };
+
 }  // namespace cl_mission_tracker

smacc2_client_library/cl_mission_tracker/include/cl_mission_tracker/components/cp_decision_manager.hpp

@@ -0,0 +1,98 @@
+// Copyright 2021 RobosoftAI Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*****************************************************************************************************************
+ *
+ * 	 Authors: Pablo Inigo Blasco, Brett Aldrich
+ *
+ ******************************************************************************************************************/
+#pragma once
+
+#include <smacc2/component.hpp>
+
+#include <mutex>
+
+namespace cl_mission_tracker
+{
+
+/**
+ * @brief Component that manages mission decision state.
+ *
+ * This component tracks the decision counter for mission sequencing.
+ * It provides thread-safe access to decision state, separating
+ * mission logic from the client orchestrator.
+ */
+class CpDecisionManager : public smacc2::ISmaccComponent
+{
+public:
+  CpDecisionManager() = default;
+
+  virtual ~CpDecisionManager() = default;
+
+  void onInitialize() override
+  {
+    RCLCPP_INFO(getLogger(), "[CpDecisionManager] Initialized");
+  }
+
+  /**
+   * @brief Get the current decision counter value.
+   * @return Current decision count
+   */
+  int getDecisionCounter() const
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return decisionCounter_;
+  }
+
+  /**
+   * @brief Increment the decision counter and return the previous value.
+   * @return Decision count before incrementing
+   */
+  int nextDecision()
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    int current = decisionCounter_;
+    decisionCounter_++;
+    RCLCPP_INFO_STREAM(
+      getLogger(), "[CpDecisionManager] Decision " << current << " -> " << decisionCounter_);
+    return current;
+  }
+
+  /**
+   * @brief Reset the decision counter to zero.
+   */
+  void resetDecisionCounter()
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    decisionCounter_ = 0;
+    RCLCPP_INFO(getLogger(), "[CpDecisionManager] Decision counter reset");
+  }
+
+  /**
+   * @brief Set the decision counter to a specific value.
+   * @param value New counter value
+   */
+  void setDecisionCounter(int value)
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    decisionCounter_ = value;
+    RCLCPP_INFO_STREAM(getLogger(), "[CpDecisionManager] Decision counter set to " << value);
+  }
+
+private:
+  mutable std::mutex mutex_;
+  int decisionCounter_ = 0;
+};
+
+}  // namespace cl_mission_tracker