aron_conversions.cpp

Go to the documentation of this file.

#include "aron_conversions.h"
 
#include <RobotAPI/libraries/aron/core/data/variant/All.h>
 
namespace armarx::armem
{
    constexpr const char* DATA_WRAPPER_TIME_STORED_FIELD = "__WRITER_METADATA__TIME_STORED";
    constexpr const char* DATA_WRAPPER_TIME_REFERENCED_FIELD = "__ENTITY_METADATA__TIME_REFERENCED";
    constexpr const char* DATA_WRAPPER_TIME_SENT_FIELD = "__ENTITY_METADATA__TIME_SENT";
    constexpr const char* DATA_WRAPPER_TIME_ARRIVED_FIELD = "__ENTITY_METADATA__TIME_ARRIVED";
    constexpr const char* DATA_WRAPPER_CONFIDENCE_FIELD = "__ENTITY_METADATA__CONFIDENCE";
    constexpr const char* DATA_WRAPPER_ORIGIN_FIELD = "__ENTITY_METADATA__ORIGIN";
} // namespace armarx::armem
 
void
armarx::armem::from_aron(const aron::data::DictPtr& metadata,
                         const aron::data::DictPtr& data,
                         wm::EntityInstance& e)
{
    ARMARX_CHECK_NOT_NULL(metadata);
    // Todo: What if data is null?
 
    wm::EntityInstanceMetadata& m = e.metadata();
 
    e.data() = data;
 
    auto referencedTime = aron::data::Long::DynamicCastAndCheck(
        metadata->getElement(DATA_WRAPPER_TIME_REFERENCED_FIELD));
    m.referencedTime = Time(Duration::MicroSeconds(referencedTime->toAronLongDTO()->value));
 
    auto timeSent =
        aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_SENT_FIELD));
    m.sentTime = Time(Duration::MicroSeconds(timeSent->toAronLongDTO()->value));
 
    auto timeArrived = aron::data::Long::DynamicCastAndCheck(
        metadata->getElement(DATA_WRAPPER_TIME_ARRIVED_FIELD));
    m.arrivedTime = Time(Duration::MicroSeconds(timeArrived->toAronLongDTO()->value));
 
    auto confidence = aron::data::Double::DynamicCastAndCheck(
        metadata->getElement(DATA_WRAPPER_CONFIDENCE_FIELD));
    m.confidence = static_cast<float>(confidence->toAronDoubleDTO()->value);
    
    std::vector<std::string> keys = metadata->getAllKeys();
 
    if (std::find(keys.begin(), keys.end(), DATA_WRAPPER_ORIGIN_FIELD) != keys.end()) 
    {
        auto origin = aron::data::String::DynamicCastAndCheck(
            metadata->getElement(DATA_WRAPPER_ORIGIN_FIELD));
        m.origin = origin->toAronStringDTO()->value;
    }
    else
    {   
        // Might occur for old memory exports
        ARMARX_WARNING << "DATA_WRAPPER_ORIGIN_FIELD not found";
        m.origin = "undefined2";
    }
}
 
void
armarx::armem::to_aron(aron::data::DictPtr& metadata,
                       aron::data::DictPtr& data,
                       const wm::EntityInstance& e)
{
    data = e.data();
    metadata = std::make_shared<aron::data::Dict>();
 
    auto timeWrapped = std::make_shared<aron::data::Long>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_TIME_STORED_FIELD}));
    timeWrapped->setValue(Time::Now().toMicroSecondsSinceEpoch());
    metadata->addElement(DATA_WRAPPER_TIME_STORED_FIELD, timeWrapped);
 
    const wm::EntityInstanceMetadata& m = e.metadata();
    auto referencedTime = std::make_shared<aron::data::Long>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_TIME_REFERENCED_FIELD}));
    referencedTime->setValue(m.referencedTime.toMicroSecondsSinceEpoch());
    metadata->addElement(DATA_WRAPPER_TIME_REFERENCED_FIELD, referencedTime);
 
    auto timeSent = std::make_shared<aron::data::Long>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_TIME_SENT_FIELD}));
    timeSent->setValue(m.sentTime.toMicroSecondsSinceEpoch());
    metadata->addElement(DATA_WRAPPER_TIME_SENT_FIELD, timeSent);
 
    auto timeArrived = std::make_shared<aron::data::Long>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_TIME_ARRIVED_FIELD}));
    timeArrived->setValue(m.arrivedTime.toMicroSecondsSinceEpoch());
    metadata->addElement(DATA_WRAPPER_TIME_ARRIVED_FIELD, timeArrived);
 
    auto confidence = std::make_shared<aron::data::Double>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_CONFIDENCE_FIELD}));
    confidence->setValue(static_cast<double>(m.confidence));
    metadata->addElement(DATA_WRAPPER_CONFIDENCE_FIELD, confidence);
 
    auto origin = std::make_shared<aron::data::String>(
        armarx::aron::Path(std::vector<std::string>{DATA_WRAPPER_ORIGIN_FIELD}));
    origin->setValue(m.origin);
    metadata->addElement(DATA_WRAPPER_ORIGIN_FIELD, origin);
}