EntityInstance.cpp

Go to the documentation of this file.

// Header
#include "EntityInstance.h"
 
// STD / STL
#include <fstream>
#include <iostream>
 
// ArmarX
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/TimeUtil.h>
 
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
 
namespace armarx::armem::server::ltm
{
    EntityInstance::EntityInstance(const detail::mixin::Path& p,
                                   const detail::mixin::MongoDBSettings& s,
 
                                   const std::string& exportName,
                                   const armem::MemoryID& id /* UNESCAPED */,
                                   const std::shared_ptr<Processors>& filters) :
        EntityInstanceBase(exportName, id, filters),
        DiskMemoryItemMixin(p, exportName, id),
        MongoDBStorageMixin(s, exportName, id)
    {
        //start();
    }
 
    void
    EntityInstance::_loadAllReferences(armem::wm::EntitySnapshot& e) const
    {
        std::lock_guard l(ltm_mutex);
        // assure that we put the right index to the snapshot
        //ARMARX_CHECK(e.size() == (size_t)id().instanceIndex);
        //int index = e.getInstanceIndices().size();
 
        //ARMARX_INFO << VAROUT(getFullPath());
        //ARMARX_INFO << VAROUT(getMemoryID().getEntityInstanceID().getLeafItem());
        int index = std::stoi(getMemoryID().getEntityInstanceID().getLeafItem());
 
        armem::wm::EntityInstance i = armem::wm::EntityInstance(index, e.id());
 
        // add instance. Do not set data, since we only return references
        e.addInstance(i);
    }
 
    void
    EntityInstance::_resolve(armem::wm::EntityInstance& e) const
    {
        std::lock_guard l(ltm_mutex);
        //ARMARX_INFO << "resolve for entity instance " << e.id().str();
        auto& dictConverter = processors->defaultObjectConverter;
 
        aron::data::DictPtr datadict = nullptr;
        aron::data::DictPtr metadatadict = nullptr;
 
        if (fullPathExists())
        {
 
            std::string dataFilename = (DATA_FILENAME + dictConverter.suffix);
            std::string metadataFilename = (METADATA_FILENAME + dictConverter.suffix);
            std::filesystem::path dataPath = getFullPath() / dataFilename;
            std::filesystem::path metadataPath = getFullPath() / metadataFilename;
 
            if (util::fs::fileExists(dataPath))
            {
                //ARMARX_INFO << "Convert data for entity " << id();
                auto datafilecontent = readDataFromFile(dataFilename);
                auto dataaron = dictConverter.convert({datafilecontent, ""}, {});
                datadict = aron::data::Dict::DynamicCastAndCheck(dataaron);
            }
            else
            {
                ARMARX_ERROR << "Could not find the data file '" << dataPath.string()
                             << "'. Continuing without data.";
            }
 
            //ARMARX_INFO << "Convert metadata for entity " << id();
            if (util::fs::fileExists(metadataPath))
            {
                auto metadatafilecontent = readDataFromFile(metadataFilename);
                auto metadataaron = dictConverter.convert({metadatafilecontent, ""}, {});
                metadatadict = aron::data::Dict::DynamicCastAndCheck(metadataaron);
            }
            else
            {
                ARMARX_ERROR << "Could not find the metadata file '" << metadataPath.string()
                             << "'. Continuing without metadata.";
            }
        }
 
        // check for special members TODO: only allowed for direct children?
        auto allFilesInIndexFolder = getAllFiles();
        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& filepath : allFilesInIndexFolder)
                {
                    if (simox::alg::starts_with(filepath.filename(), key) and
                        simox::alg::ends_with(filepath, f->suffix))
                    {
                        std::string mode = simox::alg::remove_suffix(
                            simox::alg::remove_prefix(filepath.filename(), key), f->suffix);
 
                        auto memberfilecontent = readDataFromFile(filepath.filename());
                        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, e);
    }
 
    nlohmann::json
    EntityInstance::_store(const armem::wm::EntityInstance& e)
    {
        std::lock_guard l(ltm_mutex);
        if (id().instanceIndex < 0)
        {
            ARMARX_WARNING
                << "During storage of segment '" << e.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 = e.id().timestamp;
        }
 
        auto& dictConverter = processors->defaultObjectConverter;
 
        /*if (!connected())
        {
            ARMARX_WARNING << "LTM ENTITY INSTANCE NOT CONNECTED ALTHOUGH ENABLED " << id().str();
            return {};
        }*/
 
        ensureFullPathExists(true);
 
        // data
        auto dataAron = std::make_shared<aron::data::Dict>();
        auto metadataAron = std::make_shared<aron::data::Dict>();
        to_aron(metadataAron, dataAron, e);
 
        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;
        }
 
        //ARMARX_INFO << "save and extract is " << saveAndExtract;
 
 
        // check special members for special converters
        for (auto& c : processors->converters)
        {
            ARMARX_CHECK_NOT_NULL(c);
            ARMARX_CHECK_NOT_NULL(c->extractor);
            auto dataExt = c->extractor->extract(source);
 
            for (const auto& [memberName, var] : dataExt.extraction)
            {
                ARMARX_CHECK_NOT_NULL(var);
 
                auto [memberDataVec, memberDataModeSuffix] = c->convert(var);
 
                std::string filename = (memberName + memberDataModeSuffix + c->suffix);
 
                ensureFileExists(filename, true);
                writeDataToFile(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 = (DATA_FILENAME + dictConverter.suffix);
            std::string metadataFilename = (METADATA_FILENAME + dictConverter.suffix);
            std::filesystem::path dataPath = getFullPath() / dataFilename;
            std::filesystem::path metadataPath = getFullPath() / metadataFilename;
 
            writeDataToFile(dataFilename, dataVec);
            writeDataToFile(metadataFilename, metadataVec);
        }
 
        statistics.recordedData++;
        statistics.recordedMetaData++;
 
        return dataToReturn;
    }
} // namespace armarx::armem::server::ltm