lookup_mixins.h

Go to the documentation of this file.

#pragma once
 
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/core/error/ArMemError.h>
 
#include "derived.h"
 
namespace armarx::armem::base::detail
{
 
    /// Throw armem::error::InvalidMemoryID if the given ID has no instance index.
    void checkHasInstanceIndex(const MemoryID& instanceID);
    /// Throw armem::error::InvalidMemoryID if the given ID has no timestamp.
    void checkHasTimestamp(const MemoryID& snapshotID);
    /// Throw armem::error::InvalidMemoryID if the given ID has no entity name.
    void checkHasEntityName(const MemoryID& entityID);
    /// Throw armem::error::InvalidMemoryID if the given ID has provider segment name.
    void checkHasProviderSegmentName(const MemoryID& providerSegmentID);
    /// Throw armem::error::InvalidMemoryID if the given ID has core segment name.
    void checkHasCoreSegmentName(const MemoryID& coreSegmentID);
    /// Throw armem::error::InvalidMemoryID if the given ID has memory name.
    void checkHasMemoryName(const MemoryID& memory);
 
    /**
     * @brief Find a child in a container by its key.
     * @param key The child's key.
     * @param container The child's container.
     * @return A pointer to the child, or nullptr if it was not found.
     */
    template <class KeyT, class ContainerT>
    auto*
    findChildByKey(const KeyT& key, ContainerT&& container)
    {
        auto it = container.find(key);
        return it != container.end() ? &it->second : nullptr;
    }
 
    /**
     * @brief Retrieve a child in a container by its key.
     * @param key The child's key.
     * @param container The container.
     * @param parent The container's owner. Used for the error message.
     * @param keyStringFn A function which turns key into a string. Used for the error message.
     * @return A reference to the child.
     * @throw armem::error::ArMemError If the child was not found.
     */
    template <class KeyT, class ContainerT, class ParentT, class KeyStringFn>
    auto&
    getChildByKey(const KeyT& key,
                  ContainerT&& container,
                  const ParentT& owner,
                  KeyStringFn&& keyStringFn)
    {
        if (auto* child = findChildByKey(key, container))
        {
            return *child;
        }
        else
        {
            throw armem::error::MissingEntry::create<typename ParentT::ChildT>(keyStringFn(key),
                                                                               owner);
        }
    }
 
    /**
     * @brief Retrieve a child in a container by its key.
     * @param key The child's key.
     * @param container The container.
     * @param parent The container's owner. Used for the error message.
     * @return A reference to the child.
     * @throw armem::error::ArMemError If the child was not found.
     */
    template <class KeyT, class ContainerT, class ParentT>
    auto&
    getChildByKey(const KeyT& key, ContainerT&& container, const ParentT& parent)
    {
        return getChildByKey(key, container, parent, [](const KeyT& key) { return key; });
    }
 
    template <class DerivedT>
    struct GetFindInstanceMixin
    {
        // Relies on this->find/get/forEachInstance()
 
        /**
         * @brief Indicate whether this container contains at least one entity instance.
         * @return True if there is at least one entity instance.
         */
        bool
        hasInstances() const
        {
            bool has = false;
            derived<DerivedT>(this).forEachInstance(
                [&has](const auto& snapshot)
                {
                    has = true;
                    return false;
                });
            return has;
        }
 
        /**
         * @brief Indicate whether this container has an instance with the given ID.
         * @param instanceID The instance ID.
         * @return ... WIP
         */
        bool
        hasInstance(const MemoryID& instanceID) const
        {
            return derived<DerivedT>(this).findInstance(instanceID) != nullptr;
        }
 
        /**
         * @brief Find an entity instance.
         * @param id The instance ID.
         * @return The instance or nullptr if it is missing.
         */
        auto*
        findInstance(const MemoryID& instanceID)
        {
            auto* snapshot = derived<DerivedT>(this).findSnapshot(instanceID);
            return snapshot ? snapshot->findInstance(instanceID) : nullptr;
        }
 
        const auto*
        findInstance(const MemoryID& instanceID) const
        {
            const auto* snapshot = derived<DerivedT>(this).findSnapshot(instanceID);
            return snapshot ? snapshot->findInstance(instanceID) : nullptr;
        }
 
        /**
         * @brief Retrieve an entity instance.
         * @param id The instance ID.
         * @return The instance if it is found.
         * @throw armem::error::ArMemError if it is missing.
         */
        auto&
        getInstance(const MemoryID& instanceID)
        {
            return derived<DerivedT>(this).getSnapshot(instanceID).getInstance(instanceID);
        }
 
        const auto&
        getInstance(const MemoryID& instanceID) const
        {
            return derived<DerivedT>(this).getSnapshot(instanceID).getInstance(instanceID);
        }
    };
 
    template <class DerivedT>
    struct GetLatestInstanceMixin
    {
        // Relies on findLatestInstance()
 
        /**
         * @brief Retrieve the latest entity instance.
         * @param instanceIndex The instance's index in the latest snapshot.
         * @return The latest entity instance.
         * @throw armem::error::ArMemError If there is no entity instance.
         */
        auto&
        getLatestInstance(int instanceIndex = 0)
        {
            auto* instance = derived<DerivedT>(this).findLatestInstance();
            if (not instance)
            {
                throw armem::error::NoSuchEntries(
                    "entity instances", DerivedT::getLevelName(), derived<DerivedT>(this).id());
            }
            return *instance;
        }
 
        const auto&
        getLatestInstance(int instanceIndex = 0) const
        {
            const auto* instance = derived<DerivedT>(this).findLatestInstance();
            if (not instance)
            {
                throw armem::error::NoSuchEntries(
                    "entity instances", DerivedT::getLevelName(), derived<DerivedT>(this).id());
            }
            return *instance;
        }
    };
 
    template <class DerivedT>
    struct GetLatestSnapshotMixin
    {
        // Relies on findLatestSnapshot()
 
        /**
         * @brief Retrieve the latest entity snapshot.
         * @param snapshotIndex The snapshot's index in the latest snapshot.
         * @return The latest entity snapshot.
         * @throw armem::error::ArMemError If there is no entity snapshot.
         */
        auto&
        getLatestSnapshot(int snapshotIndex = 0)
        {
            auto* snapshot = derived<DerivedT>(this).findLatestSnapshot();
            if (not snapshot)
            {
                throw armem::error::NoSuchEntries(
                    "entity snapshots", DerivedT::getLevelName(), derived<DerivedT>(this).id());
            }
            return *snapshot;
        }
 
        const auto&
        getLatestSnapshot(int snapshotIndex = 0) const
        {
            const auto* snapshot = derived<DerivedT>(this).findLatestSnapshot();
            if (not snapshot)
            {
                throw armem::error::NoSuchEntries(
                    "entity snapshots", DerivedT::getLevelName(), derived<DerivedT>(this).id());
            }
            return *snapshot;
        }
    };
 
    template <class DerivedT>
    struct GetFindSnapshotMixin :
        public GetLatestInstanceMixin<DerivedT>,
        public GetLatestSnapshotMixin<DerivedT>
    {
        // Relies on this->find/getEntity, forEachSnapshot()
 
        /**
         * @brief Indicate whether this container contains at least one entity snapshot.
         * @return True if there is at least one entity snapshot.
         */
        bool
        hasSnapshots() const
        {
            bool has = false;
            derived<DerivedT>(this).forEachSnapshot(
                [&has](const auto& snapshot)
                {
                    has = true;
                    return false;
                });
            return has;
        }
 
        /**
         * @brief Indicates whether a snapshot with the given ID exists.
         * @param snapshotID The snapshot ID.
         * @return True if the snapshot exists, false otherwise.
         */
        bool
        hasSnapshot(const MemoryID& snapshotID) const
        {
            return derived<DerivedT>(this).findSnapshot(snapshotID) != nullptr;
        }
 
        // Snapshot by ID
 
        /**
         * @brief Find an entity snapshot.
         * @param id The snapshot ID.
         * @return The snapshot, or nullptr if it is missing.
         */
        auto*
        findSnapshot(const MemoryID& snapshotID)
        {
            auto* entity = derived<DerivedT>(this).findEntity(snapshotID);
            return entity ? entity->findSnapshot(snapshotID) : nullptr;
        }
 
        const auto*
        findSnapshot(const MemoryID& snapshotID) const
        {
            auto* entity = derived<DerivedT>(this).findEntity(snapshotID);
            return entity ? entity->findSnapshot(snapshotID) : nullptr;
        }
 
        /**
         * @brief Retrieve an entity snapshot.
         * @param id The snapshot ID.
         * @return The snapshot if it is found.
         * @throw armem::error::ArMemError if it is missing.
         */
        auto&
        getSnapshot(const MemoryID& snapshotID)
        {
            return derived<DerivedT>(this).getEntity(snapshotID).getSnapshot(snapshotID);
        }
 
        const auto&
        getSnapshot(const MemoryID& snapshotID) const
        {
            return derived<DerivedT>(this).getEntity(snapshotID).getSnapshot(snapshotID);
        }
 
        // Latest snapshot in container.
 
        /**
         * @brief Find the latest entity snapshot.
         * @return A pointer to the latest instance, or nullptr if there is no snapshot.
         */
        const auto*
        findLatestSnapshot() const
        {
            const typename DerivedT::EntitySnapshotT* latestSnapshot = nullptr;
            derived<DerivedT>(this).forEachEntity(
                [&latestSnapshot](const auto& entity)
                {
                    const auto* snapshot = entity.findLatestSnapshot();
                    if (latestSnapshot == nullptr)
                    {
                        latestSnapshot = snapshot;
                    }
                    else if (snapshot and snapshot->time() > latestSnapshot->time())
                    {
                        latestSnapshot = snapshot;
                    }
                });
            return latestSnapshot;
        }
 
        auto*
        findLatestSnapshot()
        {
            typename DerivedT::EntitySnapshotT* latestSnapshot = nullptr;
            derived<DerivedT>(this).forEachEntity(
                [&latestSnapshot](auto& entity)
                {
                    auto* snapshot = entity.findLatestSnapshot();
                    if (latestSnapshot == nullptr)
                    {
                        latestSnapshot = snapshot;
                    }
                    else if (snapshot and snapshot->time() > latestSnapshot->time())
                    {
                        latestSnapshot = snapshot;
                    }
                });
            return latestSnapshot;
        }
 
        // Latest snapshot in entity
 
        /**
         * @brief Find the latest entity snapshot in the given entity.
         * @param entityID The entity's ID.
         * @return A pointer to the latest snapshot in the specified entity, or nullptr if the
         * entity does not exist or it has no snapshot.
         */
        auto*
        findLatestSnapshot(const MemoryID& entityID)
        {
            auto* entity = derived<DerivedT>(this).findEntity(entityID);
            return entity ? entity->findLatestSnapshot() : nullptr;
        }
 
        const auto*
        findLatestSnapshot(const MemoryID& entityID) const
        {
            auto* entity = derived<DerivedT>(this).findEntity(entityID);
            return entity ? entity->findLatestSnapshot() : nullptr;
        }
 
        // Latest instance in container.
 
        /**
         * @brief Find the latest entity instance.
         * @return A pointer to the latest instance, or nullptr if there is no instance.
         */
        const auto*
        findLatestInstance(int instanceIndex = 0) const
        {
            auto* snapshot = derived<DerivedT>(this).findLatestSnapshot();
            return snapshot ? snapshot->findInstance(instanceIndex) : nullptr;
        }
 
        auto*
        findLatestInstance(int instanceIndex = 0)
        {
            auto* snapshot = derived<DerivedT>(this).findLatestSnapshot();
            return snapshot ? snapshot->findInstance(instanceIndex) : nullptr;
        }
 
        // Latest instance in entity.
 
        /**
         * @brief Find the latest entity instance in the given entity.
         * @param entityID The entity's ID.
         * @return A pointer to the latest instance in the specified entity, or nullptr if the
         * entity does not exist or it has no instance.
         */
        auto*
        findLatestInstance(const MemoryID& entityID, int instanceIndex = 0)
        {
            auto* snapshot = derived<DerivedT>(this).findLatestSnapshot(entityID);
            return snapshot ? snapshot->findInstance(instanceIndex) : nullptr;
        }
 
        const auto*
        findLatestInstance(const MemoryID& entityID, int instanceIndex = 0) const
        {
            auto* snapshot = derived<DerivedT>(this).findLatestSnapshot(entityID);
            return snapshot ? snapshot->findInstance(instanceIndex) : nullptr;
        }
    };
 
    template <class DerivedT>
    struct GetFindEntityMixin
    {
        // Relies on this->find/getProviderSegment()
 
        bool
        hasEntity(const MemoryID& entityID) const
        {
            return derived<DerivedT>(this).findEntity(entityID) != nullptr;
        }
 
        /**
         * @brief Find an entity.
         * @param id The entity ID.
         * @return The entity or nullptr if it is missing.
         */
        auto*
        findEntity(const MemoryID& entityID)
        {
            auto* provSeg = derived<DerivedT>(this).findProviderSegment(entityID);
            return provSeg ? provSeg->findEntity(entityID) : nullptr;
        }
 
        const auto*
        findEntity(const MemoryID& entityID) const
        {
            auto* provSeg = derived<DerivedT>(this).findProviderSegment(entityID);
            return provSeg ? provSeg->findEntity(entityID) : nullptr;
        }
 
        /**
         * @brief Retrieve an entity.
         * @param id The entity ID.
         * @return The entity if it is found.
         * @throw armem::error::ArMemError if it is missing.
         */
        auto&
        getEntity(const MemoryID& entityID)
        {
            return derived<DerivedT>(this).getProviderSegment(entityID).getEntity(entityID);
        }
 
        const auto&
        getEntity(const MemoryID& entityID) const
        {
            return derived<DerivedT>(this).getProviderSegment(entityID).getEntity(entityID);
        }
    };
 
    template <class DerivedT>
    struct GetFindProviderSegmentMixin
    {
        // Relies on this->find/getCoreSegment()
 
        bool
        hasProviderSegment(const MemoryID& providerSegmentID) const
        {
            return derived<DerivedT>(this).findProviderSegment(providerSegmentID) != nullptr;
        }
 
        /**
         * @brief Retrieve a provider segment.
         * @param id The provider segment ID.
         * @return The provider segment if it is found or nullptr if it missing.
         */
        auto*
        findProviderSegment(const MemoryID& providerSegmentID)
        {
            auto* provSeg = derived<DerivedT>(this).findCoreSegment(providerSegmentID);
            return provSeg ? provSeg->findProviderSegment(providerSegmentID) : nullptr;
        }
 
        const auto*
        findProviderSegment(const MemoryID& providerSegmentID) const
        {
            auto* provSeg = derived<DerivedT>(this).findCoreSegment(providerSegmentID);
            return provSeg ? provSeg->findProviderSegment(providerSegmentID) : nullptr;
        }
 
        /**
         * @brief Retrieve a provider segment.
         * @param id The provider segment ID.
         * @return The provider segment if it is found.
         * @throw armem::error::ArMemError if it is missing.
         */
        auto&
        getProviderSegment(const MemoryID& providerSegmentID)
        {
            return derived<DerivedT>(this)
                .getCoreSegment(providerSegmentID)
                .getProviderSegment(providerSegmentID);
        }
 
        const auto&
        getProviderSegment(const MemoryID& providerSegmentID) const
        {
            return derived<DerivedT>(this)
                .getCoreSegment(providerSegmentID)
                .getProviderSegment(providerSegmentID);
        }
    };
 
} // namespace armarx::armem::base::detail