RedundantPersistenceStrategy.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
 
#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);
            }
        }
 
        /**
         * @brief Whether anything would actually be stored, i.e. whether at least one sink is
         * enabled.
         *
         * storeItem() fans out to every strategy and each skips the write when disabled, so the
         * composite is still doing work as long as one of them is live. A composite holding no
         * strategies stores nothing and is reported disabled, which falls out of this on its own.
         *
         * This was seeded to false and combined with `&=`, so it could only ever return false --
         * two mistakes in three lines, unnoticed because nothing calls it yet.
         */
        bool
        isEnabled() override
        {
            return std::any_of(strategies_.begin(),
                               strategies_.end(),
                               [](const auto& s) { return s->isEnabled(); });
        }
 
        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