CachedMemoryMixin.h

Go to the documentation of this file.

#pragma once
 
#include <SimoxUtility/json.h>
 
#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
 
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 
namespace armarx::armem::server::ltm::detail::mixin
{
    template <class _CoreSegmentT>
    class CachedMemoryMixin
    {
    public:
        CachedMemoryMixin(const MemoryID& id) : cache(std::make_unique<armem::wm::Memory>(id))
        {
        }
 
    protected:
        armem::wm::Memory
        getCache() const
        {
            std::lock_guard l(this->cache_mutex);
            return *cache;
        }
 
        /// configuration
        void
        configureMixin(const nlohmann::json& json)
        {
            // TODO: Max cache size
        }
 
        void
        setMixinMemoryID(const MemoryID& id)
        {
            ARMARX_CHECK_NOT_EMPTY(id.memoryName) << " The full id was: " << id.str();
 
            cache->id() = id.getMemoryID();
        }
 
        void
        addToCache(const armem::wm::Memory& memory)
        {
            std::lock_guard l(cache_mutex);
            cache->append(memory);
        }
 
        bool
        cacheHasCoreSegment(const std::string& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasCoreSegment(n);
        }
 
        bool
        cacheHasCoreSegment(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasCoreSegment(n);
        }
 
        bool
        cacheHasProviderSegment(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasProviderSegment(n);
        }
 
        bool
        cacheHasEntity(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasEntity(n);
        }
 
        bool
        cacheHasEntitySnapshot(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasSnapshot(n);
        }
 
        bool
        cacheHasEntityInstance(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasInstance(n);
        }
 
 
    protected:
        std::unique_ptr<armem::wm::Memory> cache;
 
    private:
        mutable std::recursive_mutex cache_mutex;
    };
} // namespace armarx::armem::server::ltm::detail::mixin