RedundantPersistenceStrategy.h

Go to the documentation of this file.

#pragma once
 
#include "RobotAPI/libraries/armem/core/MemoryID.h"
#include "RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h"
 
namespace armarx::armem::server::ltm::persistence 
{
 
  /**
   * Basically the option to use multiple ltm sinks as source or target.
   * Holds a list to different persistence strategies potentially also another
   * redundant strategy resulting in tree structure.
   *
   * Why the name 'redundant'?
   * -> Comes from the possibility to search in multiple ltm sinks for an item or store item to different 
   *    sinks that are potentially at different location/different implementations.
   *    But you won't find any more redundancies features.
   * 
   * What if an item key occurs multiple times?
   * -> FIFO: Strategy that was added first is choosen. In case we have a tree, you go from "left to right through the graph".
   */
  class RedundantPersistenceStrategy : public MemoryPersistenceStrategy
  {
    public:
      RedundantPersistenceStrategy() = default;
 
      RedundantPersistenceStrategy(std::vector<std::shared_ptr<MemoryPersistenceStrategy>>& strategies) : strategies_(strategies)
      {
 
      }
 
      /**
       * Returns all containers over all strategies.
       * Duplicates are not treated.
       */
      std::vector<std::string> getContainerKeys(const armarx::armem::MemoryID& id) override
      {
        std::vector<std::string> keys;
 
        for (auto& strategy : strategies_)
        {
          std::vector<std::string> strategyKeys = strategy->getContainerKeys(id);
          keys.insert(keys.end(), strategyKeys.begin(), strategyKeys.end());
        }
 
        return keys;
      }
 
      /**
       * Returns all items over all strategies.
       * Duplicates are not treated.
       */
      std::vector<std::string> getItemKeys(const armarx::armem::MemoryID& id) override
      {
        std::vector<std::string> keys;
 
        for (auto& strategy : strategies_)
        {
          std::vector<std::string> strategyKeys = strategy->getItemKeys(id);
          keys.insert(keys.end(), strategyKeys.begin(), strategyKeys.end());
        }
 
        return keys;
      }
 
      /**
       * Checks if any strategy contains the container.
       */
      bool containsContainer(const armarx::armem::MemoryID& id, std::string key) override
      {
        for (auto& s : strategies_)
        {
          if (s->containsContainer(id, key))
          {
            return true;
          }
        }
 
        return false;
      }
 
      /**
       * Checks if any strategy contains the item.
       */
      bool containsItem(const armarx::armem::MemoryID& id, std::string key) override 
      {
        for (auto& s : strategies_)
        {
          if (s->containsItem(id, key))
          {
            return true;
          }
        }
 
        return false;
      }
 
      /**
       * Stores the item to every strategy
       */
      void storeItem(const armarx::armem::MemoryID& id, const std::string key, std::vector<unsigned char>& data) override 
      {
        for (auto& s : strategies_)
        {
          s->storeItem(id, key, data);
        }
      }
 
      /**
       * Retrieves the data of the item following the FIFO principle (if the item exists at any strategy).
       */
      std::vector<unsigned char> retrieveItem(const armarx::armem::MemoryID& id, std::string key) override
      {
        for (auto& s : strategies_)
        {
          if (s->containsItem(id, key))
          {
            return s->retrieveItem(id, key);
          }
        }
        
        return std::vector<unsigned char>();
      }
 
      ItemResult retrieveItemWithOrigin(const armarx::armem::MemoryID& id, std::string& key) override
      {
        for (auto& s : strategies_)
        {
          if (s->containsItem(id, key))
          {
             return s->retrieveItemWithOrigin(id, key);
          }
        }
 
        return {"undefined4", std::vector<unsigned char>()};
      }
 
 
      /**
       * Sets the export name for all strategies
       */
      void setExportName(const std::string& exportName) override
      {
        exportName_ = exportName;
 
        for (auto& s : strategies_)
        {
          s->setExportName(exportName);
        }
      }
 
      /**
       * Add another strategy to the end.
       * Will be last in the item/container FIFO.
       */
      void addStrategy(std::shared_ptr<MemoryPersistenceStrategy> strategy)
      {
        strategies_.emplace_back(strategy);
      }
 
      /**
       * Removes all strategies
       */
      void clearStrategies()
      {
        strategies_.clear();
      }
 
      void createPropertyDefinitions(PropertyDefinitionsPtr& defs, const std::string& prefix) override
      {
        for (auto& s : strategies_)
        {
          s->createPropertyDefinitions(defs, prefix);
        }
      }
 
      bool isEnabled() override
      {
        bool enabled = false;
        
        for (auto&s : strategies_)
        {
          enabled &= s->isEnabled();
        }
 
        return enabled;
      }
 
      void disable() override
      {
        for (auto&s : strategies_)
        {
          s->disable();
        }
      }
 
      void enable() override
      {
        for (auto&s : strategies_)
        {
          s->enable();
        }
      }
 
 
    private:
      std::vector<std::shared_ptr<MemoryPersistenceStrategy>> strategies_;
  };
} // namespace armarx::armem::server::ltm::persistence