MemoryContainerBase.h

Go to the documentation of this file.

#pragma once
 
#include <RobotAPI/libraries/armem/core/error/ArMemError.h>
 
#include "MemoryItem.h"
#include "iteration_mixins.h"
 
namespace armarx::armem::base::detail
{
    /**
     * Provides default implmentations of `MemoryContainer`, as well as
     * iterators (which requires a template).
     */
    template <class _ContainerT, class _DerivedT>
    class MemoryContainerBase : public MemoryItem
    {
        using Base = MemoryItem;
 
    public:
        using DerivedT = _DerivedT;
        using ContainerT = _ContainerT;
 
 
    public:
        MemoryContainerBase()
        {
        }
 
        explicit MemoryContainerBase(const MemoryID& id) : MemoryItem(id)
        {
        }
 
        MemoryContainerBase(const MemoryContainerBase& other) = default;
        MemoryContainerBase(MemoryContainerBase&& other) = default;
        MemoryContainerBase& operator=(const MemoryContainerBase& other) = default;
        MemoryContainerBase& operator=(MemoryContainerBase&& other) = default;
 
        // Container methods
 
        bool
        empty() const
        {
            return _container.empty();
        }
 
        std::size_t
        size() const
        {
            return _container.size();
        }
 
        void
        clear()
        {
            return _container.clear();
        }
 
        // ITERATION
 
        /**
         * @param func Function like: bool process(ChildT& provSeg)
         */
        template <class ChildFunctionT>
        bool
        forEachChild(ChildFunctionT&& func)
        {
            return base::detail::forEachChild(this->_container, func);
        }
 
        /**
         * @param func Function like: bool process(const ChildT& provSeg)
         */
        template <class ChildFunctionT>
        bool
        forEachChild(ChildFunctionT&& func) const
        {
            return base::detail::forEachChild(this->_container, func);
        }
 
        [[deprecated("Direct container access is deprecated. Use forEach*() instead.")]]
        typename ContainerT::const_iterator
        begin() const
        {
            return _container.begin();
        }
 
        [[deprecated("Direct container access is deprecated. Use forEach*() instead.")]]
        typename ContainerT::iterator
        begin()
        {
            return _container.begin();
        }
 
        [[deprecated("Direct container access is deprecated. Use forEach*() instead.")]]
        typename ContainerT::const_iterator
        end() const
        {
            return _container.end();
        }
 
        [[deprecated("Direct container access is deprecated. Use forEach*() instead.")]]
        typename ContainerT::iterator
        end()
        {
            return _container.end();
        }
 
 
    protected:
        const ContainerT&
        container() const
        {
            return _container;
        }
 
        ContainerT&
        container()
        {
            return _container;
        }
 
        DerivedT&
        _derived()
        {
            return static_cast<DerivedT&>(*this);
        }
 
        const DerivedT&
        _derived() const
        {
            return static_cast<DerivedT&>(*this);
        }
 
        /**
         * @throw `armem::error::ContainerNameMismatch` if `gottenName` does not match `actualName`.
         */
        void
        _checkContainerName(const std::string& gottenName,
                            const std::string& actualName,
                            bool emptyOk = true) const
        {
            if (!((emptyOk && gottenName.empty()) || gottenName == actualName))
            {
                throw armem::error::ContainerNameMismatch(
                    gottenName, DerivedT::getLevelName(), actualName);
            }
        }
 
        template <class ChildT, class KeyT, class... ChildArgs>
        ChildT&
        _addChild(const KeyT& key, ChildArgs... childArgs)
        {
            auto [it, inserted] = this->_container.try_emplace(key, childArgs...);
            if (not inserted)
            {
                throw armem::error::ContainerEntryAlreadyExists(
                    ChildT::getLevelName(), key, DerivedT::getLevelName(), this->_derived().name());
            }
            return it->second;
        }
 
 
    protected:
        mutable ContainerT _container;
    };
 
} // namespace armarx::armem::base::detail