adding data to the storage class

docs/DataCollection.md

@@ -0,0 +1,70 @@
+## DataCollection Namespace
+
+The **DataCollection** namespace provides a set of classes and templates for managing and processing data related to agent actions and positions. This library offers flexibility and ease of use for storing, retrieving, and manipulating data within your C++ applications.
+
+### Classes
+
+1. **AgentData**
+
+   The `AgentData` class represents data collected for an agent, including their name, actions, positions, and associated IDs.
+
+   **Methods:**
+   - `StorePositions(cse491::GridPosition pos)`: Stores a grid position for the agent.
+   - `StoreAction(std::unordered_map<std::string, size_t> action)`: Stores an action for the agent.
+   - `StoreAgentId(int id)`: Stores an agent ID associated with an action.
+   - `GetActions() -> std::vector<std::unordered_map<std::string, size_t>>&`: Retrieves the stored actions.
+   - `SetActions(const std::vector<std::unordered_map<std::string, size_t>>& newActions)`: Sets the stored actions to a new set of actions.
+   - `GetPositionSize() const -> int`: Gets the size of the stored grid positions.
+   - `GetAgentIds() const -> std::vector<int>`: Gets the agent IDs associated with the stored actions.
+
+2. **DataReceiver\<T\>**
+
+   The `DataReceiver` class template provides a generic way to store and retrieve data objects of a specified type.
+
+   **Methods:**
+   - `StoreData(T obj)`: Stores a data object of type T.
+   - `getStorage() -> std::vector<T>&`: Retrieves the stored data objects.
+
+3. **AgentReceiver**
+
+   The `AgentReceiver` class extends `DataReceiver<AgentData>` and provides specific functionality for storing `AgentData` objects along with grid positions and last action IDs.
+
+   **Methods:**
+   - `StoreData(cse491::GridPosition pos, int last_action)`: Stores a grid position and last action ID associated with an agent.
+   - `GetPositionSize() -> int`: Gets the position size of the last stored `AgentData` object.
+   - `IsEmpty() -> bool`: Checks if the storage is empty.
+
+### Usage
+
+To use the **DataCollection** namespace in your C++ application, include the appropriate header files and create instances of the classes as needed. Make sure to follow the specific methods and their parameters as outlined in the class descriptions above.
+
+```cpp
+#include <DataCollection/AgentData.h>
+#include <DataCollection/DataReceiver.h>
+#include <DataCollection/AgentReceiver.h>
+
+// Example Usage
+DataCollection::AgentData agent;
+agent.StorePositions(cse491::GridPosition(1, 2));
+agent.StoreAction({{"up", 1}});
+agent.StoreAgentId(101);
+
+DataCollection::AgentReceiver agentReceiver;
+agentReceiver.StoreData(cse491::GridPosition(3, 4), 102);
+int positionSize = agentReceiver.GetPositionSize();
+bool isEmpty = agentReceiver.IsEmpty();
+```
+
+### Installation
+
+To use this library, simply include the necessary header files in your project. Ensure that you have C++11 or later enabled in your compiler settings.
+
+### Contributing
+
+Feel free to contribute by reporting issues, suggesting features, or submitting pull requests. We welcome any contributions that can improve the functionality, performance, or usability of this library.
+
+### License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.
+
+---

source/DataCollection/AgentData.hpp

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <string>
+#include <list>
+#include <utility>
+#include <vector>
+#include <unordered_map>
+#include "../core/GridPosition.hpp"
+
+namespace DataCollection
+{
+    /**
+     * @brief Represents data collected for an agent, including their name, actions, positions, and associated IDs.
+     */
+    class AgentData {
+    private:
+        std::string name;  ///< The name of the agent.
+        std::vector<int> actionIds;  ///< IDs associated with the agent's actions.
+        std::vector<cse491::GridPosition> position;  ///list of grid positions.
+        std::vector<std::unordered_map<std::string,size_t>> actions;  ///< Vector of action maps.
+
+    public:
+        /**
+         * @brief Default constructor for AgentData class.
+         */
+//        AgentData() = default;
+        AgentData(std::string name) : name(std::move(name)) {}
+
+        /**
+         * @brief Destructor for AgentData class.
+         */
+        ~AgentData() = default;
+
+        /**
+         * @brief Stores a grid position for the agent.
+         * @param pos The grid position to be stored.
+         */
+        void StorePositions(cse491::GridPosition pos) {
+            position.push_back(pos);
+        }
+
+        /**
+         * @brief Stores an action for the agent.
+         * @param action The action to be stored.
+         */
+        void StoreAction(std::unordered_map<std::string, size_t> action) {
+            actions.push_back(action);
+        }
+
+        /**
+         * @brief Stores an agent ID associated with an action.
+         * @param id The agent ID to be stored.
+         */
+        void StoreAgentId(int id) {
+            actionIds.push_back(id);
+        }
+
+        /**
+         * @brief Retrieves the stored actions.
+         * @return Reference to the vector of action maps.
+         */
+        auto& GetActions() {
+            return actions;
+        }
+
+        int GetActionSize() const {
+            return actions.size();
+        }
+
+        /**
+         * @brief Sets the stored actions to a new set of actions.
+         * @param newActions The new set of actions to be stored.
+         */
+        void SetActions(const std::vector<std::unordered_map<std::string, size_t>>& newActions) {
+            actions = newActions;
+        }
+
+        /**
+         * @brief Gets the size of the stored grid positions.
+         * @return The number of stored grid positions.
+         */
+        int GetPositionSize() const {
+            return position.size();
+        }
+
+        /**
+         * @brief Gets the agent IDs associated with the stored actions.
+         * @return The vector of agent IDs.
+         */
+        auto GetAgentIds() const {
+            return actionIds;
+        }
+
+        std::string GetName() const {
+            return name;
+        }
+    };
+} // namespace DataCollection

source/DataCollection/AgentReciever.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "DataReceiver.hpp"
+#include "AgentData.hpp"
+
+namespace DataCollection {
+
+    /**
+     * @brief Data receiver class specialized for storing AgentData objects.
+     *
+     * This class extends DataReceiver class and provides specific functionality
+     * for storing AgentData objects along with grid positions and last action IDs.
+     */
+    class AgentReceiver : public DataReceiver<AgentData> {
+    private:
+        std::unordered_map<std::string, std::shared_ptr<AgentData>> agent_map;
+
+    public:
+        /**
+         * @brief Stores a grid position and last action ID associated with an agent.
+         *
+         * @param pos The grid position to be stored.
+         * @param last_action The last action ID associated with the agent.
+         */
+        void StoreData(std::string name, cse491::GridPosition pos, int last_action) {
+            std::shared_ptr<AgentData> agent = GetAgent(name);
+            agent->StorePositions(pos);
+//            agent->StoreAction(last_action);
+            StoreIntoStorage(*agent);
+        }
+
+        void AddAgent(const std::string& name) {
+            AgentData agent(name);
+            agent_map[name] = std::make_shared<AgentData>(agent);
+        }
+
+        std::shared_ptr<AgentData> GetAgent(const std::string& name)
+        {
+            if (agent_map.find(name)==agent_map.end()) {
+                AddAgent(name);
+                return agent_map[name];
+            }
+            else {
+                return agent_map[name];
+            }
+        }
+
+        AgentData GetAgentData(const std::string& name) {
+            return *agent_map[name];
+        }
+    };
+} // namespace DataCollection

source/DataCollection/DataReceiver.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <vector>
+namespace DataCollection {
+
+    /**
+     * @brief Generic data receiver template class.
+     *
+     * This class provides a template for storing and retrieving data objects of a specified type.
+     * @tparam T The type of data to be stored.
+     */
+    template <typename T>
+    class DataReceiver {
+    public:
+        /**
+         * @brief Default constructor for DataReceiver class.
+         */
+        DataReceiver() = default;
+
+        /**
+         * @brief Virtual destructor for DataReceiver class.
+         */
+        virtual ~DataReceiver() = default;
+
+        /**
+         * @brief Retrieves the stored data objects.
+         * @return Reference to the vector containing stored data objects.
+         */
+        std::vector<T>& getStorage() {
+            return storage;
+        }
+
+        /**
+         * @brief Store a data object into the storage
+         * @param obj The data object to store
+         */
+        void StoreIntoStorage(T obj){
+            storage.push_back(obj);
+        }
+
+        /**
+         * @brief Checks if the storage is empty.
+         * @return True if the storage is empty, false otherwise.
+         */
+        bool IsEmpty() {
+            return storage.empty();
+        }
+
+    protected:
+        std::vector<T> storage; ///< Vector to store shared_ptr data objects of type T.
+    };
+} // namespace DataCollection