ProviderSegmentQueryProcessorBase.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
{
 
    template <class _ProviderSegmentT, class _ResultProviderSegmentT, class _ChildProcessorT>
    class ProviderSegmentQueryProcessorBase :
        public BaseQueryProcessorBase<_ProviderSegmentT,
                                      _ResultProviderSegmentT,
                                      armem::query::data::ProviderSegmentQuery>
    {
    protected:
        using Base = BaseQueryProcessorBase<_ProviderSegmentT,
                                            _ResultProviderSegmentT,
                                            armem::query::data::ProviderSegmentQuery>;
 
 
    public:
        using ProviderSegmentT = _ProviderSegmentT;
        using EntityT = typename ProviderSegmentT::EntityT;
 
        using ResultProviderSegmentT = _ResultProviderSegmentT;
        using ResultEntityT = typename ResultProviderSegmentT::EntityT;
 
        using ChildProcessorT = _ChildProcessorT;
 
 
    public:
        ProviderSegmentQueryProcessorBase()
        {
        }
 
        ProviderSegmentQueryProcessorBase(ChildProcessorT&& childProcessor) :
            childProcessor(childProcessor)
        {
        }
 
        using Base::process;
 
        virtual void
        process(ResultProviderSegmentT& result,
                const armem::query::data::ProviderSegmentQuery& query,
                const ProviderSegmentT& providerSegment) const override
        {
            if (auto q = dynamic_cast<const armem::query::data::provider::All*>(&query))
            {
                process(result, *q, providerSegment);
            }
            else if (auto q = dynamic_cast<const armem::query::data::provider::Single*>(&query))
            {
                process(result, *q, providerSegment);
            }
            else if (auto q = dynamic_cast<const armem::query::data::provider::Regex*>(&query))
            {
                process(result, *q, providerSegment);
            }
            else
            {
                throw armem::error::UnknownQueryType(ProviderSegmentT::getLevelName(), query);
            }
        }
 
        virtual void
        process(ResultProviderSegmentT& result,
                const armem::query::data::provider::All& query,
                const ProviderSegmentT& providerSegment) const
        {
            providerSegment.forEachEntity([this, &result, &query](const EntityT& entity)
                                          { this->_processResult(result, entity, query); });
        }
 
        virtual void
        process(ResultProviderSegmentT& result,
                const armem::query::data::provider::Single& query,
                const ProviderSegmentT& providerSegment) const
        {
            if (auto entity = providerSegment.findEntity(query.entityName))
            {
                this->_processResult(result, *entity, query);
            }
        }
 
        virtual void
        process(ResultProviderSegmentT& result,
                const armem::query::data::provider::Regex& query,
                const ProviderSegmentT& providerSegment) const
        {
            const std::regex regex(query.entityNameRegex);
            providerSegment.forEachEntity(
                [this, &result, &query, &regex](const EntityT& entity)
                {
                    if (std::regex_search(entity.name(), regex))
                    {
                        this->_processResult(result, entity, query);
                    }
                    return true;
                });
        }
 
 
    protected:
        void
        _processResult(ResultProviderSegmentT& result,
                       const EntityT& entity,
                       const armem::query::data::ProviderSegmentQuery& query) const
        {
            ResultEntityT* child = result.findEntity(entity.name());
            if (child == nullptr)
            {
                child = &result.addEntity(entity.name());
            }
            childProcessor.process(*child, query.entityQueries, entity);
        }
 
 
    protected:
        ChildProcessorT childProcessor;
    };
} // namespace armarx::armem::server::query_proc::base