EntitySnapshot.cpp

Go to the documentation of this file.

// Header
#include "EntitySnapshot.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
{
    EntitySnapshot::EntitySnapshot(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) :
        EntitySnapshotBase(exportName, id, filters),
        DiskMemoryItemMixin(p, exportName, id),
        MongoDBStorageMixin(s, exportName, id)
    {
        //start();
    }
 
    bool
    EntitySnapshot::forEachInstance(std::function<void(EntityInstance&)> func) const
    {
        std::lock_guard l(ltm_mutex);
 
        /*if (connected() && collectionExists())
        {
            if (auto d = documentExists(); d)
            {
                nlohmann::json doc = *d;
                std::vector<nlohmann::json> instances = doc[DATA];
                for (unsigned int i = 0; i < instances.size(); ++i)
                {
                    EntityInstance c(getMemoryBasePath(),
                                     getSettings(),
                                     getExportName(),
                                     id().withInstanceIndex(i),
                                     processors);
                    func(c);
                }
            }
        } else */
 
        if (fullPathExists())
        {
            for (const auto& i : getAllDirectories())
            {
                EntityInstance c(getMemoryBasePath(),
                                 getSettings(),
                                 getExportName(),
                                 id().withInstanceIndex(std::stoi(i.filename())).cleanID(),
                                 processors);
                func(c);
            }
        }
        return true;
    }
 
    bool
    EntitySnapshot::hasInstance(const int index) const
    {
        std::lock_guard l(ltm_mutex);
 
        /*if (connected() && collectionExists())
        {
            if (auto d = documentExists(); d)
            {
                nlohmann::json doc = *d;
                std::vector<nlohmann::json> instances = doc[DATA];
                return (size_t)index < instances.size();
            }
        }*/
 
        if (fullPathExists())
        {
            auto c = EntityInstance(getMemoryBasePath(),
                                    getSettings(),
                                    getExportName(),
                                    id().withInstanceIndex(index),
                                    processors);
            return c.fullPathExists();
        }
 
        return false;
    }
 
    std::shared_ptr<EntityInstance>
    EntitySnapshot::findInstance(const int index) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (!hasInstance(index))
        {
            return nullptr;
        }
        return std::make_shared<EntityInstance>(getMemoryBasePath(),
                                                getSettings(),
                                                getExportName(),
                                                id().withInstanceIndex(index),
                                                processors);
    }
 
    void
    EntitySnapshot::_loadAllReferences(armem::wm::EntitySnapshot& e) const
    {
        std::lock_guard l(ltm_mutex);
 
        e.id() = id().getEntitySnapshotID().cleanID();
 
        forEachInstance([&e](armem::server::ltm::EntityInstance& x) {
            x.loadAllReferences(e);
        });
    }
 
    void
    EntitySnapshot::_resolve(armem::wm::EntitySnapshot& p) const
    {
        std::lock_guard l(ltm_mutex);
 
        if (/*(connected() && collectionExists() && documentExists()) ||*/ fullPathExists())
        {
            p.forEachInstance(
                [&](auto& e)
                {
                    EntityInstance c(getMemoryBasePath(),
                                     getSettings(),
                                     getExportName(),
                                     id().withInstanceIndex(e.id().instanceIndex),
                                     processors);
                    c.resolve(e);
                });
        }
    }
 
    void
    EntitySnapshot::_store(const armem::wm::EntitySnapshot& p)
    {
 
        std::lock_guard l(ltm_mutex);
 
        if (id().timestamp.isInvalid())
        {
            ARMARX_WARNING
                << "During storage of segment '" << p.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 = p.id().timestamp;
        }
 
        /*if (!connected())
        {
            ARMARX_WARNING << "LTM ENTITY SNAPSHOT NOT CONNECTED ALTHOUGH ENABLED " << id().str();
            return;
        }*/
 
        //nlohmann::json data;
        //data[DATA] = std::vector<nlohmann::json>();
 
        p.forEachInstance(
            [&](const auto& e)
            {
                EntityInstance c(getMemoryBasePath(),
                                 getSettings(),
                                 getExportName(),
                                 id().withInstanceIndex(e.id().instanceIndex),
                                 processors);
                c.store(e);
 
                //data[DATA].push_back(c.store(e));
                statistics.recordedInstances++;
            });
 
        //writeDataToDocument(data);
    }
} // namespace armarx::armem::server::ltm