EntityInstanceBase.h

Go to the documentation of this file.

#pragma once
 
#include <RobotAPI/libraries/armem/core/Commit.h>
#include <RobotAPI/libraries/armem/core/Time.h>
 
#include "detail/MemoryItem.h"
 
namespace armarx::armem::base
{
 
    /**
     * @brief Default data of an entity instance (empty).
     */
    struct NoData
    {
        virtual ~NoData() = default;
 
        bool
        operator==(const NoData& other)
        {
            return true;
        }
 
        bool
        operator!=(const NoData& other)
        {
            return false;
        }
    };
 
    /**
     * @brief Metadata of an entity instance.
     */
    struct EntityInstanceMetadata
    {
 
        virtual ~EntityInstanceMetadata() = default;
 
        /**
         * @brief Time this instance refers to.
         *
         * For example, the physical time point when an image was captured.
         * If the image is processed, the result should have the same
         * referencedTime as the image.
         */
        Time referencedTime = Time::Invalid();
 
        /// Time when this value was sent to the memory.
        Time sentTime = Time::Invalid();
        /// Time when this value has arrived at the memory.
        Time arrivedTime = Time::Invalid();
 
        /// An optional confidence, may be used for things like decay.
        float confidence = 1.0;
 
        /// An optional value indicating the time of last access.
        mutable Time lastAccessedTime = Time::Invalid();
 
        /// A counter how often the instance has been accessed.
        mutable unsigned long numAccessed = 0;
 
        /// Indicates the source of the instance e.g. from a specific LTM
        std::string origin = "undefinied";
 
        /// Called whenever the entity instance this metadata belongs to is accessed (e.g. queried).
        void access() const;
 
        bool operator==(const EntityInstanceMetadata& other) const;
 
        inline bool
        operator!=(const EntityInstanceMetadata& other) const
        {
            return !(*this == other);
        }
    };
 
    std::ostream& operator<<(std::ostream& os, const EntityInstanceMetadata& rhs);
 
    /**
     * @brief Data of a single entity instance.
     */
    template <class _DataT = NoData, class _MetadataT = EntityInstanceMetadata>
    class EntityInstanceBase : public detail::MemoryItem
    {
        using Base = detail::MemoryItem;
 
    public:
        using MetadataT = _MetadataT;
        using DataT = _DataT;
 
        EntityInstanceBase()
        {
        }
 
        explicit EntityInstanceBase(int index, const MemoryID& parentID = {}) :
            EntityInstanceBase(parentID.withInstanceIndex(index))
        {
        }
 
        explicit EntityInstanceBase(const MemoryID& id) : Base(id)
        {
        }
 
        // Key
        inline int&
        index()
        {
            return id().instanceIndex;
        }
 
        inline int
        index() const
        {
            return id().instanceIndex;
        }
 
        // Data
 
        MetadataT&
        metadata()
        {
            return _metadata;
        }
 
        const MetadataT&
        metadata() const
        {
            return _metadata;
        }
 
        const DataT&
        data() const
        {
            return _data;
        }
 
        DataT&
        data()
        {
            return _data;
        }
 
        void
        setData(const DataT& data)
        {
            _data = data;
        }
 
        void
        setMetadata(const MetadataT& metadata)
        {
            _metadata = metadata;
        }
 
        /**
         * @brief Get the data converted to a generated Aron DTO class.
         */
        template <class AronDtoT>
        AronDtoT
        dataAs() const
        {
            return AronDtoT::FromAron(_data);
        }
 
        template <class AronDtoT>
        EntityInstanceBase<AronDtoT, MetadataT>
        withDataAs() const
        {
            EntityInstanceBase<AronDtoT, MetadataT> instance{_id};
            instance.data() = dataAs<AronDtoT>();
            instance.metadata() = _metadata;
            return instance;
        }
 
        // Misc
 
        static std::string
        getLevelName()
        {
            return "entity instance";
        }
 
        std::string
        getKeyString() const
        {
            return std::to_string(index());
        }
 
 
    protected:
        /// The metadata.
        MetadataT _metadata;
 
        /// The data. May be nullptr.
        DataT _data;
    };
 
} // namespace armarx::armem::base