update movement set

components/movements/MovementSetManager.cpp

@@ -9,38 +9,85 @@ MovementSetManager::MovementSetManager(){
         ESP_LOGE(MOVEMENTS_DEBUG_TAG, "Failed to open nvs for %s", MOVEMENTS_NVS_NAMESPACE);
         return;
     }
+
+    if (!topology_manager->is_ready()){
+        ESP_LOGE(MOVEMENTS_DEBUG_TAG, "Topology Manager is not ready!");
+        return;
+    }
+
+    ready = true;
 };
 
 MovementSetManager::~MovementSetManager(){
     nvs_close(handle);
 }
 
-// esp_err_t MovementSetManager::add_movement(struct MovementEntry& entry, uint8_t& index){
-//     return ESP_OK;
-// }
+esp_err_t MovementSetManager::add_movement(Movement::MovementEntry& entry, uint8_t& index){
+    if (!ready){
+        return ESP_ERR_INVALID_STATE;
+    }
 
-// esp_err_t MovementSetManager::remove_movement(uint8_t index){
-//     return ESP_OK;
-// }
+    if (entry.board_id() == PC_ADDR || entry.board_id() == BROADCAST_ADDR){
+        return ESP_ERR_INVALID_ARG;
+    }
 
-// esp_err_t MovementSetManager::update_movement(struct MovementEntry& entry, uint8_t index){
-//     return ESP_OK;
-// }
+    if (movements.find(index) != movements.end()){
+        for (Movement::MovementEntry& e : movements[index]){
+            if (e.board_id() == entry.board_id()){
+                return ESP_ERR_INVALID_ARG; //only unique board ids per index
+            }
+        }
+    }
+    
+    movements[index].push_back(entry);
 
-// esp_err_t MovementSetManager::get_curr_movement_set(struct MovementSet& set){
-//     return ESP_OK;
-// }
+    return ESP_OK;
+}
 
-// esp_err_t MovementSetManager::verify_movement_set(){
-//     return ESP_OK;
-// }
+esp_err_t MovementSetManager::remove_movement(uint8_t index, uint8_t board_id){
+    if (board_id == PC_ADDR || board_id == BROADCAST_ADDR){
+        return ESP_ERR_INVALID_ARG;
+    }
 
-// esp_err_t MovementSetManager::get_nvs_movement_set(struct MovementSet& set){
-//     return ESP_OK;
-// }
+    if (movements.find(index) == movements.end()){
+        return ESP_ERR_INVALID_ARG;
+    }
 
-// esp_err_t MovementSetManager::write_nvs_movement_set(){
-//     return ESP_OK;
-// }
+    bool found = false;
+
+    for (auto it = movements[index].begin(); it != movements[index].end(); ++it) {
+        if (it->board_id() == board_id){
+            movements[index].erase(it);
+            found = true;
+            break;
+        }
+    }
+
+    if (!found){
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t MovementSetManager::update_movement(Movement::MovementEntry& entry, uint8_t index){
+    return ESP_OK;
+}
+
+esp_err_t MovementSetManager::get_curr_movement_set(Movement::MovementSet& set){
+    return ESP_OK;
+}
+
+esp_err_t MovementSetManager::verify_movement_set(){
+    return ESP_OK;
+}
+
+esp_err_t MovementSetManager::get_nvs_movement_set(Movement::MovementSet& set){
+    return ESP_OK;
+}
+
+esp_err_t MovementSetManager::write_nvs_movement_set(){
+    return ESP_OK;
+}
 
 #endif //MOVEMENTS

components/movements/TopologyManager.cpp

@@ -17,6 +17,10 @@ TopologyManager::~TopologyManager(){
     nvs_close(handle);
 }
 
+bool TopologyManager::is_ready(){
+    return ready;
+}
+
 /**
  * @brief Creates a `Topology::NeighbourBlob` based on the input parameters and adds the blob to the internal topology map
  * 
@@ -72,6 +76,14 @@ esp_err_t TopologyManager::add_board_to_topology(const std::vector<std::pair<uin
     return ESP_OK;
 }
 
+/**
+ * @brief Removes the board associated with `board_id`
+ * 
+ * @warning This function does not remove any existing links on other boards on the topology
+ * 
+ * @param board_id 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::remove_board_from_topology(uint16_t board_id){
     if (!ready){
         return ESP_ERR_INVALID_STATE;
@@ -86,6 +98,13 @@ esp_err_t TopologyManager::remove_board_from_topology(uint16_t board_id){
     return ESP_OK;
 }
 
+/**
+ * @brief Returns a vector of connections that represents the channel connection to a board id from `curr_board_id`
+ * 
+ * @param connections 
+ * @param curr_board_id 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::get_board_in_topology(std::vector<std::pair<uint8_t, uint16_t>>& connections, uint16_t curr_board_id){
     if (!ready){
         return ESP_ERR_INVALID_STATE;
@@ -106,12 +125,23 @@ esp_err_t TopologyManager::get_board_in_topology(std::vector<std::pair<uint8_t,
     return ESP_OK;
 }
 
+/**
+ * @brief Verifies the topology
+ * 
+ * Conditions to fail:
+ * 
+ * 1. Any board that is referenced in the topology does not have a reciprocal connection (eg. A -> B and B -> A)
+ * 
+ * 2. The topology contains 2 separate graphs (a board in the topology should be in the same graph with some sort of path to all other boards)
+ * 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::verify_topology(){
     if (!ready){
         return ESP_ERR_INVALID_STATE;
     }
 
-    if (topology.size() == 0){
+    if (topology.size() == 0 || topology.size() >= RIP_MAX_ROUTES){
         return ESP_ERR_INVALID_STATE;
     }
 
@@ -187,6 +217,12 @@ esp_err_t TopologyManager::verify_topology(){
     return ESP_OK;
 }
 
+/**
+ * @brief Gets the current topology stored in the manager
+ * 
+ * @param topology 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::get_curr_topology(std::unordered_map<uint16_t, std::vector<std::pair<uint8_t, uint16_t>>>& topology){
     if (!ready){
         return ESP_ERR_INVALID_STATE;
@@ -204,6 +240,11 @@ esp_err_t TopologyManager::get_curr_topology(std::unordered_map<uint16_t, std::v
     return ESP_OK;
 }
 
+/**
+ * @brief Writes the topology stored in the manager onto the board's NVS
+ * 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::write_nvs_topology(){
     if (!ready){
         return ESP_ERR_INVALID_STATE;
@@ -237,6 +278,12 @@ esp_err_t TopologyManager::write_nvs_topology(){
     return ESP_OK;
 }
 
+/**
+ * @brief Read's the board NVS to retreve the saved topology (if it exists)
+ * 
+ * @param topology 
+ * @return esp_err_t 
+ */
 esp_err_t TopologyManager::get_nvs_topology(std::unordered_map<uint16_t, std::vector<std::pair<uint8_t, uint16_t>>>& topology){
     if (!ready) {
         return ESP_ERR_INVALID_STATE;

components/movements/include/MovementSetManager.h

@@ -3,6 +3,8 @@
 #include "TopologyManager.h"
 #include <memory>
 #include <vector>
+#include "MovementSetBuilder.h"
+#include "unordered_map"
 
 #ifdef MOVEMENTS
 #pragma once
@@ -11,18 +13,20 @@ class MovementSetManager {
     public: 
         MovementSetManager();
         ~MovementSetManager();
-        // esp_err_t add_movement(struct MovementEntry& entry, uint8_t& index);
-        // esp_err_t remove_movement(uint8_t index);
-        // esp_err_t update_movement(struct MovementEntry& entry, uint8_t index);
-        // esp_err_t get_curr_movement_set(struct MovementSet& set);
-        // esp_err_t verify_movement_set();
-        // esp_err_t get_nvs_movement_set(struct MovementSet& set);
-        // esp_err_t write_nvs_movement_set();
+        esp_err_t add_movement(Movement::MovementEntry& entry, uint8_t& index);
+        esp_err_t remove_movement(uint8_t index, uint8_t board_id);
+        esp_err_t update_movement(Movement::MovementEntry& entry, uint8_t index);
+        esp_err_t get_curr_movement_set(Movement::MovementSet& set);
+        esp_err_t verify_movement_set();
+        esp_err_t get_nvs_movement_set(Movement::MovementSet& set);
+        esp_err_t write_nvs_movement_set();
 
     private:
-        std::unique_ptr<TopologyManager> topology_manager;
-        // std::vector<struct MovementEntry> movements;
+        std::unique_ptr<TopologyManager> topology_manager = std::make_unique<TopologyManager>();
+        std::unordered_map<uint8_t, std::vector<Movement::MovementEntry>> movements;
         nvs_handle_t handle;
+        bool ready = false;
+        Flatbuffers::MovementSetBuilder builder;
 };
 
 #endif //MOVEMENTS

components/movements/include/TopologyManager.h

@@ -20,6 +20,7 @@ class TopologyManager {
     public:
         TopologyManager();
         ~TopologyManager();
+        bool is_ready();
         esp_err_t add_board_to_topology(const std::vector<std::pair<uint8_t, uint16_t>>& connections, uint16_t curr_board_id);
         esp_err_t remove_board_from_topology(uint16_t board_id);
         esp_err_t get_board_in_topology(std::vector<std::pair<uint8_t, uint16_t>>& connections, uint16_t curr_board_id);