Builder.cpp

Go to the documentation of this file.

#include "Builder.h"
 
namespace armarx::armem::client::query
{
 
    Builder::Builder(armem::query::DataMode dataMode, armem::query::QueryTarget target) :
        dataMode(dataMode), queryTarget(target)
    {
    }
 
    QueryInput
    Builder::buildQueryInput() const
    {
        QueryInput input;
        input.memoryQueries = buildMemoryQueries();
        input.dataMode = dataMode;
        return input;
    }
 
    armem::query::data::Input
    Builder::buildQueryInputIce() const
    {
        return buildQueryInput().toIce();
    }
 
    armem::query::data::MemoryQuerySeq
    Builder::buildMemoryQueries() const
    {
        armem::query::data::MemoryQuerySeq memoryQueries;
        for (const CoreSegmentSelector& child : _children)
        {
            for (armem::query::data::MemoryQueryPtr& query : child.buildQueries())
            {
                toIce(query->target, queryTarget);
                memoryQueries.push_back(query);
            }
        }
        return memoryQueries;
    }
 
    CoreSegmentSelector&
    Builder::coreSegments()
    {
        return _addChild();
    }
 
    CoreSegmentSelector&
    Builder::coreSegments(const CoreSegmentSelector& selector)
    {
        return _addChild(selector);
    }
 
    void
    Builder::all()
    {
        coreSegments().all().providerSegments().all().entities().all().snapshots().all();
    }
 
    void
    Builder::allLatest()
    {
        coreSegments().all().providerSegments().all().entities().all().snapshots().latest();
    }
 
    void
    Builder::allInCoreSegment(const MemoryID& coreSegmentID)
    {
        coreSegments()
            .withName(coreSegmentID.coreSegmentName)
            .providerSegments()
            .all()
            .entities()
            .all()
            .snapshots()
            .all();
    }
 
    void
    Builder::allLatestInCoreSegment(const MemoryID& coreSegmentID)
    {
        coreSegments()
            .withName(coreSegmentID.coreSegmentName)
            .providerSegments()
            .all()
            .entities()
            .all()
            .snapshots()
            .latest();
    }
 
    void
    Builder::allInProviderSegment(const MemoryID& providerSegmentID)
    {
        coreSegments()
            .withName(providerSegmentID.coreSegmentName)
            .providerSegments()
            .withName(providerSegmentID.providerSegmentName)
            .entities()
            .all()
            .snapshots()
            .all();
    }
 
    void
    Builder::allLatestInProviderSegment(const MemoryID& providerSegmentID)
    {
        coreSegments()
            .withName(providerSegmentID.coreSegmentName)
            .providerSegments()
            .withName(providerSegmentID.providerSegmentName)
            .entities()
            .all()
            .snapshots()
            .latest();
    }
 
    void
    Builder::allEntitySnapshots(const MemoryID& entityID)
    {
        coreSegments()
            .withName(entityID.coreSegmentName)
            .providerSegments()
            .withName(entityID.providerSegmentName)
            .entities()
            .withName(entityID.entityName)
            .snapshots()
            .all();
    }
 
    void
    Builder::latestEntitySnapshot(const MemoryID& entityID)
    {
        coreSegments()
            .withName(entityID.coreSegmentName)
            .providerSegments()
            .withName(entityID.providerSegmentName)
            .entities()
            .withName(entityID.entityName)
            .snapshots()
            .latest();
    }
 
    void
    Builder::singleEntitySnapshot(const MemoryID& snapshotID)
    {
        coreSegments()
            .withName(snapshotID.coreSegmentName)
            .providerSegments()
            .withName(snapshotID.providerSegmentName)
            .entities()
            .withName(snapshotID.entityName)
            .snapshots()
            .atTime(snapshotID.timestamp);
    }
 
    void
    Builder::multipleEntitySnapshots(const std::vector<MemoryID>& snapshotIDs)
    {
        for (const MemoryID& snapshotID : snapshotIDs)
        {
            singleEntitySnapshot(snapshotID);
        }
    }
 
} // namespace armarx::armem::client::query