EntityInstance.cpp

Go to the documentation of this file.

// Header
#include "EntityInstance.h"
 
// STD / STL
#include <SimoxUtility/algorithm/string/string_tools.h>
 
// ArmarX
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
#include "RobotAPI/libraries/armem/server/ltm/persistence/MemoryPersistenceStrategy.h"
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
namespace armarx::armem::server::ltm
{
    EntityInstance::EntityInstance(const std::string& exportName,
                                   const armem::MemoryID& id /* UNESCAPED */,
                                   const std::shared_ptr<Processors>& filters,
                                   const std::shared_ptr<persistence::MemoryPersistenceStrategy>& persistenceStrategy) :
        EntityInstanceBase(exportName, id, filters),
        persistenceStrategy_(persistenceStrategy)
    {
        //start();
    }
 
    void
    EntityInstance::_implLoadAllReferences(armem::wm::EntitySnapshot& wmEntitySnapshot) const
    {
        ARMARX_TRACE;
        
        int index = std::stoi(getMemoryID().getEntityInstanceID().getLeafItem());
 
        armem::wm::EntityInstance wmEntityInstance = armem::wm::EntityInstance(index, wmEntitySnapshot.id());
 
        // add instance. Do not set data, since we only return references
        wmEntitySnapshot.addInstance(wmEntityInstance);
    }
 
    void
    EntityInstance::_implResolve(armem::wm::EntityInstance& wmEntityInstance) const
    {
        ARMARX_TRACE;
 
        ARMARX_DEBUG << "Resolve entity instance id=" << id().cleanID().str();
 
        std::string origin = "undefined3";
 
        auto& dictConverter = processors->defaultObjectConverter;
 
 
        aron::data::DictPtr datadict = nullptr;
        aron::data::DictPtr metadatadict = nullptr;
 
 
        std::string dataFilename = (persistence::MemoryPersistenceStrategy::DATA_FILENAME + dictConverter.suffix);
        std::string metadataFilename = (persistence::MemoryPersistenceStrategy::METADATA_FILENAME + dictConverter.suffix);
 
        if (persistenceStrategy_->containsItem(id(), dataFilename))
        {
            auto datafilecontent = persistenceStrategy_->retrieveItem(id(), dataFilename);
 
            try 
            {
                auto dataaron = dictConverter.convert({datafilecontent, ""}, {});
                datadict = aron::data::Dict::DynamicCastAndCheck(dataaron);
            } 
            catch (std::exception& ex)
            {
                ARMARX_ERROR << "Exception during conversion from file into json object. At entity instance=" << id().cleanID().str() << ", file=" << dataFilename << ", error message=" << ex.what();
                return;
            }
        }
        else
        {
            // Not "continuing": the loop below dereferences datadict, and from_aron() would be
            // handed a null data dict. A half-written export -- the LTM drops or fails writes
            // without telling the caller -- used to segfault the server on load.
            ARMARX_WARNING << "Could not find the data file '" << dataFilename
                           << "' for entity instance=" << id().cleanID().str()
                           << ". Skipping this instance.";
            return;
        }
 
        if (persistenceStrategy_->containsItem(id(), metadataFilename))
        {
            auto itemResult = persistenceStrategy_->retrieveItemWithOrigin(id(), metadataFilename);
            auto metadatafilecontent = itemResult.data;
            origin = itemResult.origin;
 
            try
            {
                auto metadataaron = dictConverter.convert({metadatafilecontent, ""}, {});
                metadatadict = aron::data::Dict::DynamicCastAndCheck(metadataaron);
            } 
            catch (std::exception& ex)
            {
                ARMARX_ERROR << "Exception during conversion from file into json object. At entity instance=" << id().cleanID().str() << ", file=" << metadataFilename << ", error message=" << ex.what();
                return;
            }
        }
        else
        {
            // Likewise not "continuing": every field from_aron() reads -- referencedTime, sentTime,
            // arrivedTime, confidence -- lives in the metadata, and it opens with
            // ARMARX_CHECK_NOT_NULL(metadata), so this threw from deep inside instead.
            ARMARX_WARNING << "Could not find the metadata file '" << metadataFilename
                           << "' for entity instance=" << id().cleanID().str()
                           << ". Skipping this instance.";
            return;
        }
        
        for (const auto& [key, m] : datadict->getElements())
        {
            for (auto& f : processors->converters)
            {
                // iterate over all files and search for matching ones.
                // We cannot simply check for the existence of a file because we do not know the
                // mode (filename = memberName.mode.suffix)
                for (const auto& entityInstanceKey : persistenceStrategy_->getItemKeys(id()))
                {
                    if (simox::alg::starts_with(entityInstanceKey, key) and
                        simox::alg::ends_with(entityInstanceKey, f->suffix))
                    {
                        std::string mode = simox::alg::remove_suffix(
                            simox::alg::remove_prefix(entityInstanceKey, key), f->suffix);
 
                        auto memberfilecontent = persistenceStrategy_->retrieveItem(id(), entityInstanceKey);
                        auto memberaron = f->convert(
                            {memberfilecontent, mode},
                            armarx::aron::Path(datadict->getPath(), std::vector<std::string>{key}));
                        datadict->setElement(key, memberaron);
                        break;
                    }
                }
            }
        }
        
        from_aron(metadatadict, datadict, wmEntityInstance);
        
        // TODO: as parameter
        bool usePersistenceStrategyAsOrigin = true;
 
        if (usePersistenceStrategyAsOrigin)
        {
            wmEntityInstance.metadata().origin = origin;
        }
    }
 
    nlohmann::json
    EntityInstance::_implStore(const armem::wm::EntityInstance& wmEntitySnapshot)
    {
        ARMARX_TRACE;
 
        if (id().instanceIndex < 0)
        {
            ARMARX_WARNING
                << "During storage of segment '" << wmEntitySnapshot.id().str()
                << "' I noticed that the corresponding LTM has no id set. "
                << "I set the id of the LTM to the same name, however this should not happen!";
            id().timestamp = wmEntitySnapshot.id().timestamp;
        }
 
        auto& dictConverter = processors->defaultObjectConverter;
 
        ARMARX_DEBUG << "Storing entity instance id=" << id().cleanID().str();
 
        // data
        auto dataAron = std::make_shared<aron::data::Dict>();
        auto metadataAron = std::make_shared<aron::data::Dict>();
        to_aron(metadataAron, dataAron, wmEntitySnapshot);
 
        std::shared_ptr<aron::data::Dict> source;
 
        bool saveAndExtract =
            false; //if true the data is saved in extracted form and in data.aron.json
        // this is needed if several LTMs are recorded at once because otherwise the data from the data.aron.json
        // is not there anymore to extract from
 
        if (saveAndExtract)
        {
            source = dataAron->clone();
        }
        else
        {
            source = dataAron;
        }
 
        // check special members for special converters
        for (auto& converter : processors->converters)
        {
            ARMARX_CHECK_NOT_NULL(converter);
            ARMARX_CHECK_NOT_NULL(converter->extractor);
            auto dataExt = converter->extractor->extract(source);
 
            for (const auto& [memberName, var] : dataExt.extraction)
            {
                ARMARX_CHECK_NOT_NULL(var);
 
                auto [memberDataVec, memberDataModeSuffix] = converter->convert(var);
 
                std::string filename = (memberName + memberDataModeSuffix + converter->suffix);
 
                persistenceStrategy_->storeItem(id(), filename, memberDataVec);
            }
        }
 
        // convert dict and metadata
        auto [dataVec, dataVecModeSuffix] = dictConverter.convert(dataAron);
        auto [metadataVec, metadataVecModeSuffix] = dictConverter.convert(metadataAron);
        ARMARX_CHECK_EMPTY(dataVecModeSuffix);
        ARMARX_CHECK_EMPTY(metadataVecModeSuffix);
 
        auto dataToReturn = nlohmann::json::parse(std::string(dataVec.begin(), dataVec.end()));
 
        {
            std::string dataFilename = (persistence::MemoryPersistenceStrategy::DATA_FILENAME + dictConverter.suffix);
            std::string metadataFilename = (persistence::MemoryPersistenceStrategy::METADATA_FILENAME + dictConverter.suffix);
 
            persistenceStrategy_->storeItem(id(), dataFilename, dataVec);
            persistenceStrategy_->storeItem(id(), metadataFilename, metadataVec);
        }
 
        statistics.recordedData++;
        statistics.recordedMetaData++;
 
        return dataToReturn;
    }
} // namespace armarx::armem::server::ltm