Memory.h

Go to the documentation of this file.

#pragma once
 
#include <list>
 
// Base Class
#include "detail/MemoryBase.h"
#include "detail/mixins/BufferedMemoryMixin.h"
#include "detail/mixins/CachedMemoryMixin.h"
 
// Persistence
#include "persistence/MemoryPersistenceStrategy.h"
#include "persistence/RedundantPersistenceStrategy.h"
 
// Segmnet Type
#include "CoreSegment.h"
 
namespace armarx::armem::server::ltm
{
    /// @brief A memory storing data on the hard drive and in mongodb (needs 'armarx memory start' to start the mongod instance)
    class Memory :
        public detail::MemoryBase<CoreSegment>,
        public detail::mixin::BufferedMemoryMixin<CoreSegment>,
        public detail::mixin::CachedMemoryMixin<CoreSegment>
    {
    public:
        using MemoryBase = detail::MemoryBase<CoreSegment>;
        using BufferedBase = detail::mixin::BufferedMemoryMixin<CoreSegment>;
        using CachedBase = detail::mixin::CachedMemoryMixin<CoreSegment>;
 
        Memory();
 
        Memory(const std::string& exportName, const std::string& memoryName);
 
        Memory(
            const std::string& exportName,
            const std::string& memoryName,
            const std::shared_ptr<persistence::RedundantPersistenceStrategy>& persistenceStrategy);
 
        void _setExportName(const std::string& memoryName) final;
        void _setMemoryID(const MemoryID& memoryId) final;
        void _enable() final;
        void _disable() final;
        void _configure(const nlohmann::json& config) final;
 
        bool forEachCoreSegment(std::function<void(CoreSegment&)> func) const final;
        bool hasCoreSegment(const std::string& coreSegmentName) const final;
        std::shared_ptr<CoreSegment>
        findCoreSegment(const std::string& coreSegmentName) const final;
 
        void createPropertyDefinitions(PropertyDefinitionsPtr& defs,
                                       const std::string& prefix) override;
 
        /**
         * @brief getAndSaveStatistics generates and saves statistics for a LTM recording
         */
        void getAndSaveStatistics();
 
        void
        setPersistenceStrategy(
            std::shared_ptr<persistence::RedundantPersistenceStrategy> persistenceStrategy)
        {
            persistenceStrategy_ = persistenceStrategy;
        }
 
        std::shared_ptr<persistence::RedundantPersistenceStrategy>
        getPersistenceStrategy() const
        {
            return persistenceStrategy_;
        }
 
    protected:
        void _loadAllReferences(armem::wm::Memory& wmMemory) final;
        void _loadLatestNReferences(int n, armem::wm::Memory& wmMemory) final;
        void _loadLatestNReferences(int n,
                                    armem::wm::Memory& wmMemory,
                                    std::list<std::string> coreSegNames) final;
        void _resolve(armem::wm::Memory& wmMemory) final;
        void _store(const armem::wm::Memory& wmMemory) final;
        void _directlyStore(const armem::wm::Memory& wmMemory, bool simulatedVersion) final;
        void _loadOnStartup() final;
 
    private:
        std::time_t current_date;
 
        std::shared_ptr<persistence::RedundantPersistenceStrategy> persistenceStrategy_;
 
        std::vector<std::string> split(std::string str, char delimiter);
    };
} // namespace armarx::armem::server::ltm