selectors.cpp

Go to the documentation of this file.

#include "selectors.h"
 
#include <ArmarXCore/core/ice_conversions.h>
#include <ArmarXCore/core/ice_conversions/ice_conversions_templates.h>
#include <ArmarXCore/core/time/ice_conversions.h>
 
#include <RobotAPI/libraries/armem/core/ice_conversions.h>
#include <RobotAPI/libraries/armem/core/wm/ice_conversions.h>
 
 
namespace dq = ::armarx::armem::query::data;
 
namespace armarx::armem::client::query
{
    dq::EntityQuerySeq
    SnapshotSelector::buildQueries() const
    {
        return _queries;
    }
 
    SnapshotSelector&
    SnapshotSelector::all()
    {
        auto& q = _addQuery<dq::entity::All>();
        (void)q;
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::latest()
    {
        auto& q = _addQuery<dq::entity::Single>();
        toIce(q.timestamp, Time::Invalid());
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::atTime(Time timestamp)
    {
        auto& q = _addQuery<dq::entity::Single>();
        toIce(q.timestamp, timestamp);
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::timeRange(Time min, Time max)
    {
        auto& q = _addQuery<dq::entity::TimeRange>();
        toIce(q.minTimestamp, min);
        toIce(q.maxTimestamp, max);
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::atTimeApprox(Time timestamp, Duration eps)
    {
        auto& q = _addQuery<dq::entity::TimeApprox>();
        toIce(q.timestamp, timestamp);
        toIce(q.eps, eps);
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::indexRange(long first, long last)
    {
        auto& q = _addQuery<dq::entity::IndexRange>();
        q.first = first;
        q.last = last;
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::beforeOrAtTime(Time timestamp)
    {
        auto& q = _addQuery<dq::entity::BeforeOrAtTime>();
        toIce(q.timestamp, timestamp);
        return *this;
    }
 
    SnapshotSelector&
    SnapshotSelector::beforeTime(Time timestamp, long maxEntries)
    {
        using armarx::toIce;
 
        auto& q = _addQuery<dq::entity::BeforeTime>();
        toIce(q.timestamp, timestamp);
        toIce(q.maxEntries, maxEntries);
        return *this;
    }
 
    SnapshotSelector&
    EntitySelector::snapshots()
    {
        return _addChild();
    }
 
    SnapshotSelector&
    EntitySelector::snapshots(const ChildT& selector)
    {
        return _addChild(selector);
    }
 
    EntitySelector&
    EntitySelector::all()
    {
        auto& q = _addQuery<dq::provider::All>();
        (void)q;
        return *this;
    }
 
    EntitySelector&
    EntitySelector::withName(const std::string& name)
    {
        auto& q = _addQuery<dq::provider::Single>();
        q.entityName = name;
        return *this;
    }
 
    EntitySelector&
    EntitySelector::withNamesMatching(const std::string& regex)
    {
        auto& q = _addQuery<dq::provider::Regex>();
        q.entityNameRegex = regex;
        return *this;
    }
 
    void
    EntitySelector::_setChildQueries(dq::ProviderSegmentQueryPtr& query,
                                     const dq::EntityQuerySeq& childQueries) const
    {
        query->entityQueries = childQueries;
    }
 
    EntitySelector&
    ProviderSegmentSelector::entities()
    {
        return _addChild();
    }
 
    EntitySelector&
    ProviderSegmentSelector::entities(const EntitySelector& selector)
    {
        return _addChild(selector);
    }
 
    ProviderSegmentSelector&
    ProviderSegmentSelector::all()
    {
        auto& q = _addQuery<dq::core::All>();
        (void)q;
        return *this;
    }
 
    ProviderSegmentSelector&
    ProviderSegmentSelector::withName(const std::string& name)
    {
        auto& q = _addQuery<dq::core::Single>();
        q.providerSegmentName = name;
        return *this;
    }
 
    ProviderSegmentSelector&
    ProviderSegmentSelector::withNamesMatching(const std::string& regex)
    {
        auto& q = _addQuery<dq::core::Regex>();
        q.providerSegmentNameRegex = regex;
        return *this;
    }
 
    void
    ProviderSegmentSelector::_setChildQueries(dq::CoreSegmentQueryPtr& query,
                                              const dq::ProviderSegmentQuerySeq& childQueries) const
    {
        query->providerSegmentQueries = childQueries;
    }
 
    ProviderSegmentSelector&
    CoreSegmentSelector::providerSegments()
    {
        return _addChild();
    }
 
    ProviderSegmentSelector&
    CoreSegmentSelector::providerSegments(const ProviderSegmentSelector& selector)
    {
        return _addChild(selector);
    }
 
    CoreSegmentSelector&
    CoreSegmentSelector::all()
    {
        auto& q = _addQuery<dq::memory::All>();
        (void)q;
        return *this;
    }
 
    CoreSegmentSelector&
    CoreSegmentSelector::withName(const std::string& name)
    {
        auto& q = _addQuery<dq::memory::Single>();
        q.coreSegmentName = name;
        return *this;
    }
 
    CoreSegmentSelector&
    CoreSegmentSelector::withNamesMatching(const std::string& regex)
    {
        auto& q = _addQuery<dq::memory::Regex>();
        q.coreSegmentNameRegex = regex;
        return *this;
    }
 
    void
    CoreSegmentSelector::_setChildQueries(dq::MemoryQueryPtr& query,
                                          const dq::CoreSegmentQuerySeq& childQueries) const
    {
        query->coreSegmentQueries = childQueries;
    }
 
} // namespace armarx::armem::client::query