CoreSegmentQueryProcessorBase.h

Go to the documentation of this file.

#pragma once
 
#include <regex>
 
#include <RobotAPI/interface/armem/query.h>
#include <RobotAPI/libraries/armem/core/error.h>
 
#include "BaseQueryProcessorBase.h"
 
namespace armarx::armem::server::query_proc::base
{
 
    /**
     * @brief Handles memory queries.
     */
    template <class _CoreSegmentT, class _ResultCoreSegmentT, class _ChildProcessorT>
    class CoreSegmentQueryProcessorBase :
        public BaseQueryProcessorBase<_CoreSegmentT,
                                      _ResultCoreSegmentT,
                                      armem::query::data::CoreSegmentQuery>
    {
    protected:
        using Base = BaseQueryProcessorBase<_CoreSegmentT,
                                            _ResultCoreSegmentT,
                                            armem::query::data::CoreSegmentQuery>;
 
    public:
        using CoreSegmentT = _CoreSegmentT;
        using ProviderSegmentT = typename CoreSegmentT::ProviderSegmentT;
 
        using ResultCoreSegmentT = _ResultCoreSegmentT;
        using ResultProviderSegmentT = typename ResultCoreSegmentT::ProviderSegmentT;
 
        using ChildProcessorT = _ChildProcessorT;
 
 
    public:
        CoreSegmentQueryProcessorBase()
        {
        }
 
        CoreSegmentQueryProcessorBase(ChildProcessorT&& childProcessor) :
            childProcessor(childProcessor)
        {
        }
 
        using Base::process;
 
        virtual void
        process(ResultCoreSegmentT& result,
                const armem::query::data::CoreSegmentQuery& query,
                const CoreSegmentT& coreSegment) const override
        {
            if (auto q = dynamic_cast<const armem::query::data::core::All*>(&query))
            {
                process(result, *q, coreSegment);
            }
            else if (auto q = dynamic_cast<const armem::query::data::core::Single*>(&query))
            {
                process(result, *q, coreSegment);
            }
            else if (auto q = dynamic_cast<const armem::query::data::core::Regex*>(&query))
            {
                process(result, *q, coreSegment);
            }
            else
            {
                throw armem::error::UnknownQueryType("core segment", query);
            }
        }
 
        virtual void
        process(ResultCoreSegmentT& result,
                const armem::query::data::core::All& query,
                const CoreSegmentT& coreSegment) const
        {
            coreSegment.forEachProviderSegment(
                [this, &query, &result](const ProviderSegmentT& providerSegment)
                { this->_processResult(result, providerSegment, query); });
        }
 
        virtual void
        process(ResultCoreSegmentT& result,
                const armem::query::data::core::Single& query,
                const CoreSegmentT& coreSegment) const
        {
            if (auto providerSegment = coreSegment.findProviderSegment(query.providerSegmentName))
            {
                this->_processResult(result, *providerSegment, query);
            }
        }
 
        virtual void
        process(ResultCoreSegmentT& result,
                const armem::query::data::core::Regex& query,
                const CoreSegmentT& coreSegment) const
        {
            const std::regex regex(query.providerSegmentNameRegex);
            coreSegment.forEachProviderSegment(
                [this, &result, &query, &regex](const ProviderSegmentT& providerSegment)
                {
                    if (std::regex_search(providerSegment.name(), regex))
                    {
                        this->_processResult(result, providerSegment, query);
                    }
                });
        }
 
 
    protected:
        void
        _processResult(ResultCoreSegmentT& result,
                       const ProviderSegmentT& providerSegment,
                       const armem::query::data::CoreSegmentQuery& query) const
        {
            ResultProviderSegmentT* child = result.findProviderSegment(providerSegment.name());
            if (child == nullptr)
            {
                child =
                    &result.addProviderSegment(providerSegment.name(), providerSegment.aronType());
            }
 
            childProcessor.process(*child, query.providerSegmentQueries, providerSegment);
        }
 
 
    protected:
        ChildProcessorT childProcessor;
    };
} // namespace armarx::armem::server::query_proc::base