EntityBase.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 "EntitySnapshotBase.h"
#include "MemoryItem.h"
 
namespace armarx::armem::server::ltm::detail
{
    /// @brief Interface functions for the longterm memory classes
    template <class _EntitySnapshotT>
    class EntityBase : public MemoryItem
    {
    public:
        struct Statistics
        {
            long recordedSnapshots = 0;
        };
 
    public:
        using EntitySnapshotT = _EntitySnapshotT;
 
        using MemoryItem::MemoryItem;
 
        /// return the full sub-ltm as a wm::Entity with only references
        /// the ltm may be huge, use with caution
        void
        loadAllReferences(armem::wm::Entity& e)
        {
            _loadAllReferences(e);
        }
 
        void
        loadLatestNReferences(int n, armem::wm::Entity& e)
        {
            _loadLatestNReferences(n, e);
        }
 
        /// convert the references of the input into a wm::Memory
        void
        resolve(armem::wm::Entity& e)
        {
            _resolve(e);
        }
 
        /// encode the content of a wm::Memory and store
        void
        store(const armem::wm::Entity& e, bool simulatedVersion)
        {
            _store(e, simulatedVersion);
        }
 
        /// statistics
        void
        resetStatistics()
        {
            statistics.recordedSnapshots = 0;
        }
 
        Statistics
        getStatistics() const
        {
            return statistics;
        }
 
        /// iterate over all entity snapshots of this ltm
        bool
        forEachSnapshot(std::function<void(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshot(func);
        }
 
        bool
        forEachSnapshotInIndexRange(long first,
                                    long last,
                                    std::function<void(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshotInIndexRange(first, last, func);
        }
 
        bool
        forEachSnapshotInTimeRange(const Time& min,
                                   const Time& max,
                                   std::function<void(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshotInTimeRange(min, max, func);
        }
 
        bool
        forEachSnapshotBeforeOrAt(const Time& time,
                                  std::function<void(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshotBeforeOrAt(time, func);
        }
 
        bool
        forEachSnapshotBefore(const Time& time,
                              std::function<void(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshotBefore(time, func);
        }
 
        bool
        forEachSnapshotBeforeReverse(const Time& time,
                                     std::function<bool(EntitySnapshotT&)> func) const
        {
            return _implForEachSnapshotBeforeReverse(time, func);
        }
 
        /// check if snapshot segment exists
        bool
        hasSnapshot(const Time& time) const
        {
            return _implHasSnapshot(time);
        }
 
        /// find entity snapshot segment
        std::shared_ptr<EntitySnapshotT>
        findSnapshot(const Time& time) const
        {
            return _implFindSnapshot(time);
        }
 
        std::shared_ptr<EntitySnapshotT>
        findLatestSnapshot() const
        {
            return _implFindLatestSnapshot();
        }
 
        std::shared_ptr<EntitySnapshotT>
        findLatestSnapshotBefore(const Time& time) const
        {
            return _implFindLatestSnapshotBefore(time);
        }
 
        std::shared_ptr<EntitySnapshotT>
        findLatestSnapshotBeforeOrAt(const Time& time) const
        {
            return _implFindLatestSnapshotBeforeOrAt(time);
        }
 
        std::shared_ptr<EntitySnapshotT>
        findFirstSnapshotAfter(const Time& time) const
        {
            return _implFindFirstSnapshotAfter(time);
        }
 
        std::shared_ptr<EntitySnapshotT>
        findFirstSnapshotAfterOrAt(const Time& time) const
        {
            return _implFindFirstSnapshotAfterOrAt(time);
        }
 
        static std::string
        getLevelName()
        {
            return "LT-Entity";
        }
 
    protected:
        virtual void _loadAllReferences(armem::wm::Entity&) = 0;
        virtual void _loadLatestNReferences(int n, armem::wm::Entity& e) = 0;
        virtual void _resolve(armem::wm::Entity&) = 0;
        virtual void _store(const armem::wm::Entity& e, bool simulatedVersion = false) = 0;
 
        // Implementation methods - subclasses override these
        // Thread safety is handled by DiskPersistence's per-directory mutexes
        virtual bool _implForEachSnapshot(std::function<void(EntitySnapshotT&)> func) const = 0;
        virtual bool
        _implForEachSnapshotInIndexRange(long first,
                                         long last,
                                         std::function<void(EntitySnapshotT&)> func) const = 0;
        virtual bool
        _implForEachSnapshotInTimeRange(const Time& min,
                                        const Time& max,
                                        std::function<void(EntitySnapshotT&)> func) const = 0;
        virtual bool
        _implForEachSnapshotBeforeOrAt(const Time& time,
                                       std::function<void(EntitySnapshotT&)> func) const = 0;
        virtual bool
        _implForEachSnapshotBefore(const Time& time,
                                   std::function<void(EntitySnapshotT&)> func) const = 0;
        virtual bool
        _implForEachSnapshotBeforeReverse(const Time& time,
                                          std::function<bool(EntitySnapshotT&)> func) const = 0;
 
        virtual bool _implHasSnapshot(const Time&) const = 0;
 
        virtual std::shared_ptr<EntitySnapshotT> _implFindSnapshot(const Time&) const = 0;
        virtual std::shared_ptr<EntitySnapshotT> _implFindLatestSnapshot() const = 0;
        virtual std::shared_ptr<EntitySnapshotT>
        _implFindLatestSnapshotBefore(const Time& time) const = 0;
        virtual std::shared_ptr<EntitySnapshotT>
        _implFindLatestSnapshotBeforeOrAt(const Time& time) const = 0;
        virtual std::shared_ptr<EntitySnapshotT>
        _implFindFirstSnapshotAfter(const Time& time) const = 0;
        virtual std::shared_ptr<EntitySnapshotT>
        _implFindFirstSnapshotAfterOrAt(const Time& time) const = 0;
 
    protected:
        Statistics statistics;
    };
} // namespace armarx::armem::server::ltm::detail