memory_definitions.h

Go to the documentation of this file.

#pragma once
 
#include <RobotAPI/libraries/armem/core/base/CoreSegmentBase.h>
#include <RobotAPI/libraries/armem/core/base/EntityBase.h>
#include <RobotAPI/libraries/armem/core/base/EntityInstanceBase.h>
#include <RobotAPI/libraries/armem/core/base/EntitySnapshotBase.h>
#include <RobotAPI/libraries/armem/core/base/MemoryBase.h>
#include <RobotAPI/libraries/armem/core/base/ProviderSegmentBase.h>
#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
 
#include "detail/data_lookup_mixins.h"
 
namespace armarx::armem::wm
{
    /**
     * @brief Client-side working memory entity instance metadata.
     */
    using EntityInstanceMetadata = base::EntityInstanceMetadata;
    /**
     * @brief Client-side working memory entity instance data (payload).
     */
    using EntityInstanceData = armarx::aron::data::Dict;
    /**
     * @brief Pointer type of EntityInstanceData.
     */
    using EntityInstanceDataPtr = armarx::aron::data::DictPtr;
 
    /**
     * @brief Client-side working entity instance.
     * @see base::EntityInstanceBase
     */
    class EntityInstance :
        public base::EntityInstanceBase<EntityInstanceDataPtr, EntityInstanceMetadata>
    {
        using Base = base::EntityInstanceBase<EntityInstanceDataPtr, EntityInstanceMetadata>;
 
    public:
        using Base::EntityInstanceBase;
 
        /**
         * @brief Fill `*this` with the update's values.
         * @param update The update.
         * @param index The instances index.
         */
        void update(const EntityUpdate& update);
 
        bool equalsDeep(const EntityInstance& other) const;
    };
 
    /**
     * @brief Entity instance with a concrete ARON DTO type as data.
     *
     * This is the return type of EntityInstance::withDataAs<AronDtoT>().
     *
     * Usage example:
     * @code
     * #include <RobotAPI/libraries/aron/common/aron/time.aron.generated.h>
     *
     * armarx::arondto::Duration duration;
     * duration.microSeconds = 1000;
     *
     * armarx::armem::wm::EntityInstance instance;
     * instance.data() = duration.toAron();
     *
     * const armarx::armem::wm::EntityInstanceBase<armarx::arondto::Duration> cast =
     * instance.withDataAs<armarx::arondto::Duration>();
     *
     * const armarx::arondto::Duration& durationOut = cast.data();
     *
     * assert(durationOut.microseconds == 1000);
     * @endcode
     */
    template <class AronDtoT>
    using EntityInstanceBase = base::EntityInstanceBase<AronDtoT, EntityInstanceMetadata>;
 
    /**
     * @brief Client-side working memory entity snapshot.
     * @see base::EntitySnapshotBase
     */
    class EntitySnapshot :
        public base::EntitySnapshotBase<EntityInstance, EntitySnapshot>,
        public detail::FindInstanceDataMixinForSnapshot<EntitySnapshot>
 
    {
    public:
        using base::EntitySnapshotBase<EntityInstance, EntitySnapshot>::EntitySnapshotBase;
    };
 
    /**
     * @brief Client-side working memory entity.
     * @see base::EntityBase
     */
    class Entity :
        public base::EntityBase<EntitySnapshot, Entity>,
        public detail::FindInstanceDataMixinForEntity<Entity>
    {
    public:
        using base::EntityBase<EntitySnapshot, Entity>::EntityBase;
    };
 
    /**
     * @brief Client-side working memory provider segment.
     * @see base::ProviderSegmentBase
     */
    class ProviderSegment :
        public base::ProviderSegmentBase<Entity, ProviderSegment>,
        public detail::FindInstanceDataMixin<ProviderSegment>
    {
        using Base = base::ProviderSegmentBase<Entity, ProviderSegment>;
 
    public:
        using Base::ProviderSegmentBase;
    };
 
    /**
     * @brief Client-side working memory core segment.
     * @see base::CoreSegmentBase
     */
    class CoreSegment :
        public base::CoreSegmentBase<ProviderSegment, CoreSegment>,
        public detail::FindInstanceDataMixin<CoreSegment>
    {
        using Base = base::CoreSegmentBase<ProviderSegment, CoreSegment>;
 
    public:
        using Base::CoreSegmentBase;
    };
 
    /**
     * @brief Client-side working memory.
     * @see base::MemoryBase
     */
    class Memory :
        public base::MemoryBase<CoreSegment, Memory>,
        public detail::FindInstanceDataMixin<Memory>
    {
        using Base = base::MemoryBase<CoreSegment, Memory>;
 
    public:
        using Base::MemoryBase;
    };
 
} // namespace armarx::armem::wm