Processors.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <mutex>
#include <optional>
#include <set>
#include <string>
#include <vector>
 
#include <RobotAPI/libraries/armem/core/MemoryID.h>
 
#include "converter/data/Converter.h"
#include "converter/data/object/json/JsonConverter.h"
#include "converter/type/object/json/JsonConverter.h"
#include "extractor/Extractor.h"
#include "filter/Filter.h"
 
namespace armarx::armem::server::ltm
{
    /// all necessary classes to filter and convert an entry of the ltm to some other format(s)
    class Processors
    {
    public:
        Processors() = default;
 
        void configure(const nlohmann::json& config);
 
        /**
         * @brief Decide whether a snapshot of the given segment should be stored to LTM.
         *
         * Combines two mechanisms configured via the LTM `configuration` JSON:
         *  1. Segment whitelist (`storeSegments`): if set, the snapshot is rejected unless its
         *     segment is admitted. A core segment is admitted if either its core-segment name
         *     (`"Core"`) or its provider-segment path (`"Core/Provider"`) is listed.
         *  2. Snapshot filters: per-segment filter overrides (`segments`) are applied if present
         *     for this segment (provider path takes precedence over core), otherwise the global
         *     `snapFilters` are applied.
         *
         * If neither `storeSegments` nor `segmentSnapFilters` is configured, this falls back to
         * the global snapshot filters only, reproducing the previous behavior.
         */
        bool acceptSnapshotForSegment(const std::string& coreSegmentName,
                                      const std::string& providerSegmentName,
                                      const armem::wm::EntitySnapshot& snapshot,
                                      bool simulatedVersion = false);
 
        /**
         * @brief Whether any segment-based selection or per-segment filtering is configured.
         *
         * When false, callers may use the global `snapFilters` directly.
         */
        bool hasSegmentSelection() const;
 
        std::map<std::string, processor::SnapshotFilter::FilterStatistics>
        getSnapshotFilterStatistics();
 
        /**
         * @brief resetFilterStatisticsForNewEpisode runs resetFilterStatisticsForNewEpisode on all
         * snapshot filters
         */
        void resetFilterStatisticsForNewEpisode();
 
    private:
        /// Build a list of snapshot filters from a JSON config block (keyed by filter NAME).
        std::vector<std::unique_ptr<processor::SnapshotFilter>>
        buildSnapshotFilters(const nlohmann::json& config);
 
        /// Whether the given segment is admitted by the `storeSegments` whitelist (or no whitelist).
        bool isSegmentWhitelisted(const std::string& coreSegmentName,
                                  const std::string& providerSegmentName) const;
 
    public:
        // Unique Memory Filters
        std::vector<std::unique_ptr<processor::MemoryFilter>> memFilters;
 
        // Unique Snapshot filters (global / default set)
        std::vector<std::unique_ptr<processor::SnapshotFilter>> snapFilters;
 
        /// Optional whitelist of segments to store. Absent => store all segments.
        /// Entries are either "CoreSegment" or "CoreSegment/ProviderSegment".
        std::optional<std::set<std::string>> storeSegments;
 
        /// Per-segment snapshot filter overrides, keyed by "CoreSegment" or
        /// "CoreSegment/ProviderSegment". A segment without an entry uses `snapFilters`.
        std::map<std::string, std::vector<std::unique_ptr<processor::SnapshotFilter>>>
            segmentSnapFilters;
 
        // Special Extractors
        std::vector<std::unique_ptr<processor::Extractor>> extractors;
 
        // Special Converters
        std::vector<std::unique_ptr<processor::DataConverter>> converters;
 
        // Default converters
        processor::converter::data::object::JsonConverter defaultObjectConverter;
        processor::converter::type::object::JsonConverter defaultTypeConverter;
    };
} // namespace armarx::armem::server::ltm