CoreSegmentBase.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
 
// BaseClass
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/core/wm/aron_conversions.h>
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 
#include "MemoryItem.h"
#include "ProviderSegmentBase.h"
 
namespace armarx::armem::server::ltm::detail
{
    /// @brief Interface functions for the longterm memory classes
    template <class _ProviderSegmentT>
    class CoreSegmentBase : public MemoryItem
    {
    public:
        struct Statistics
        {
            long recordedProviderSegments = 0;
        };
 
    public:
        using ProviderSegmentT = _ProviderSegmentT;
 
        using MemoryItem::MemoryItem;
 
        /// return the full sub-ltm as a wm::CoreSegment with only references
        /// the ltm may be huge, use with caution
        void
        loadAllReferences(armem::wm::CoreSegment& coreSeg)
        {
            _loadAllReferences(coreSeg);
        }
 
        void
        loadLatestNReferences(int n, armem::wm::CoreSegment& coreSeg)
        {
            _loadLatestNReferences(n, coreSeg);
        }
 
        /// convert the references of the input into a wm::Memory
        void
        resolve(armem::wm::CoreSegment& coreSeg)
        {
            _resolve(coreSeg);
        }
 
        /// encode the content of a wm::Memory and store
        void
        store(const armem::wm::CoreSegment& coreSeg, bool simulatedVersion)
        {
            _store(coreSeg, simulatedVersion);
        }
 
        /// statistics
        void
        resetStatistics()
        {
            statistics.recordedProviderSegments = 0;
        }
 
        Statistics
        getStatistics() const
        {
            return statistics;
        }
 
        /// iterate over all provider segments of this ltm
        bool
        forEachProviderSegment(std::function<void(ProviderSegmentT&)> func) const
        {
            return _implForEachProviderSegment(func);
        }
 
        /// check if provider segment exists
        bool
        hasProviderSegment(const std::string& providerSegmentName) const
        {
            return _implHasProviderSegment(providerSegmentName);
        }
 
        /// find provider segment
        std::shared_ptr<ProviderSegmentT>
        findProviderSegment(const std::string& providerSegmentName) const
        {
            return _implFindProviderSegment(providerSegmentName);
        }
 
        /// get aron type
        aron::type::ObjectPtr
        aronType() const
        {
            return nullptr;
        }
 
        /// get level name
        static std::string
        getLevelName()
        {
            return "LT-CoreSegment";
        }
 
    protected:
        virtual void _loadAllReferences(armem::wm::CoreSegment&) = 0;
        virtual void _loadLatestNReferences(int n, armem::wm::CoreSegment& c) = 0;
        virtual void _resolve(armem::wm::CoreSegment&) = 0;
        virtual void _store(const armem::wm::CoreSegment& c, bool simulatedVersion = false) = 0;
 
        // Implementation methods - subclasses override these
        // Thread safety is handled by DiskPersistence's per-directory mutexes
        virtual bool _implForEachProviderSegment(std::function<void(ProviderSegmentT&)> func) const = 0;
        virtual bool _implHasProviderSegment(const std::string& providerSegmentName) const = 0;
        virtual std::shared_ptr<ProviderSegmentT> _implFindProviderSegment(const std::string& providerSegmentName) const = 0;
 
    protected:
        Statistics statistics;
    };
} // namespace armarx::armem::server::ltm::detail