source/RobotAPI/libraries/armem/core/ice_conversions.cpp

@@ -87,10 +87,10 @@ namespace armarx
         std::transform(ice.instancesData.begin(), ice.instancesData.end(), std::back_inserter(update.instancesData),
                        aron::data::Dict::FromAronDictDTO);
 
-        fromIce(ice.timeCreated, update.timeCreated);
+        fromIce(ice.referencedTime, update.referencedTime);
 
         update.confidence = ice.confidence;
-        fromIce(ice.timeSent, update.timeSent);
+        fromIce(ice.timeSent, update.sentTime);
     }
 
     void armem::toIce(data::EntityUpdate& ice, const EntityUpdate& update)
@@ -102,17 +102,17 @@ namespace armarx
         std::transform(update.instancesData.begin(), update.instancesData.end(), std::back_inserter(ice.instancesData),
                        aron::data::Dict::ToAronDictDTO);
 
-        toIce(ice.timeCreated, update.timeCreated);
+        toIce(ice.referencedTime, update.referencedTime);
 
         ice.confidence = update.confidence;
-        toIce(ice.timeSent, update.timeSent);
+        toIce(ice.timeSent, update.sentTime);
     }
 
     void armem::fromIce(const data::EntityUpdateResult& ice, EntityUpdateResult& result)
     {
         result.success = ice.success;
         fromIce(ice.snapshotID, result.snapshotID);
-        fromIce(ice.timeArrived, result.timeArrived);
+        fromIce(ice.timeArrived, result.arrivedTime);
         result.errorMessage = ice.errorMessage;
     }
 
@@ -120,7 +120,7 @@ namespace armarx
     {
         ice.success = result.success;
         toIce(ice.snapshotID, result.snapshotID);
-        toIce(ice.timeArrived, result.timeArrived);
+        toIce(ice.timeArrived, result.arrivedTime);
         ice.errorMessage = result.errorMessage;
     }
 
@@ -137,7 +137,7 @@ namespace armarx
     void armem::fromIce(const data::EntityUpdate& ice, EntityUpdate& update, Time timeArrived)
     {
         fromIce(ice, update);
-        update.timeArrived = timeArrived;
+        update.arrivedTime = timeArrived;
     }
 
     void armem::fromIce(const actions::data::MenuPtr& ice, actions::Menu& menu)

source/RobotAPI/libraries/armem/core/operations.cpp

@@ -25,7 +25,7 @@ namespace armarx
     {
         EntityUpdate up;
         up.entityID = snapshot.id().getEntityID();
-        up.timeCreated = snapshot.time();
+        up.referencedTime = snapshot.time();
         up.instancesData = getAronData(snapshot);
         return up;
     }

source/RobotAPI/libraries/armem/core/wm/aron_conversions.cpp

@@ -6,7 +6,7 @@
 namespace armarx::armem
 {
     constexpr const char* DATA_WRAPPER_TIME_STORED_FIELD     = "__WRITER_METADATA__TIME_STORED";
-    constexpr const char* DATA_WRAPPER_TIME_CREATED_FIELD    = "__ENTITY_METADATA__TIME_CREATED";
+    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";
@@ -22,14 +22,14 @@ void armarx::armem::from_aron(const aron::data::DictPtr& metadata, const aron::d
 
     e.data() = data;
 
-    auto timeCreated = aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_CREATED_FIELD));
-    m.timeCreated = Time(Duration::MicroSeconds(timeCreated->toAronLongDTO()->value));
+    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.timeSent = Time(Duration::MicroSeconds(timeSent->toAronLongDTO()->value));
+    m.sentTime = Time(Duration::MicroSeconds(timeSent->toAronLongDTO()->value));
 
     auto timeArrived = aron::data::Long::DynamicCastAndCheck(metadata->getElement(DATA_WRAPPER_TIME_ARRIVED_FIELD));
-    m.timeArrived = Time(Duration::MicroSeconds(timeArrived->toAronLongDTO()->value));
+    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);
@@ -41,24 +41,24 @@ void armarx::armem::to_aron(aron::data::DictPtr& metadata, aron::data::DictPtr&
     data = e.data();
     metadata = std::make_shared<aron::data::Dict>();
 
-    auto timeWrapped = std::make_shared<aron::data::Long>();
+    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 timeCreated = std::make_shared<aron::data::Long>();
-    timeCreated->setValue(m.timeCreated.toMicroSecondsSinceEpoch());
-    metadata->addElement(DATA_WRAPPER_TIME_CREATED_FIELD, timeCreated);
+    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>();
-    timeSent->setValue(m.timeSent.toMicroSecondsSinceEpoch());
+    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>();
-    timeArrived->setValue(m.timeArrived.toMicroSecondsSinceEpoch());
+    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>();
+    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);
 }

source/RobotAPI/libraries/armem/core/wm/memory_definitions.cpp

@@ -37,9 +37,9 @@ namespace armarx::armem::wm
 
         this->_metadata.confidence = update.confidence;
 
-        this->_metadata.timeCreated = update.timeCreated;
-        this->_metadata.timeSent = update.timeSent;
-        this->_metadata.timeArrived = update.timeArrived;
+        this->_metadata.referencedTime = update.referencedTime;
+        this->_metadata.sentTime = update.sentTime;
+        this->_metadata.arrivedTime = update.arrivedTime;
     }
 
 }

source/RobotAPI/libraries/armem/server/MemoryToIceAdapter.cpp

@@ -187,7 +187,7 @@ namespace armarx::armem::server
 
                 result.success = true;
                 result.snapshotID = updateResult.id;
-                result.timeArrived = update.timeArrived;
+                result.arrivedTime = update.arrivedTime;
 
                 for (const auto& snapshot : updateResult.removedSnapshots)
                 {
@@ -286,10 +286,7 @@ namespace armarx::armem::server
 
             // append result to return memory and sanity check
             wmResult.append(ltmResult);
-            if (wmResult.empty())
-            {
-                ARMARX_ERROR << "A merged Memory has no data although at least the LTM result contains data. This indicates that something is wrong.";
-            }
+            ARMARX_CHECK(not wmResult.empty());
 
             // Ist das wirklich notwendig?
             // query again to limit output size (TODO: Skip if querytype is all)

source/RobotAPI/libraries/armem/server/ltm/base/converter/Converter.h

@@ -26,7 +26,7 @@ namespace armarx::armem::server::ltm
         virtual ~Converter() = default;
 
         virtual std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) = 0;
-        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
 
     public:
         const ConverterType type;

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.cpp

@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::VariantPtr ImageConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
-        auto d = _convert(data, m);
+        auto d = _convert(data, p, m);
         return d;
     }
 

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/Converter.h

@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ImageConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) = 0;
-        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.cpp

@@ -25,9 +25,9 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::NDArrayPtr ExrConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYDEPTH);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/exr/ExrConverter.h

@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.cpp

@@ -39,23 +39,23 @@ namespace armarx::armem::server::ltm::converter::image
         return std::make_pair(buffer, "");
     }
 
-    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::NDArrayPtr PngConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         if (m == ".rgb")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_COLOR);
             cv::cvtColor(img, img, CV_BGR2RGB);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
         }
 
         if (m == ".gs")
         {
             cv::Mat img = cv::imdecode(data, cv::IMREAD_GRAYSCALE);
-            return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+            return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
         }
 
         // try to load without conversion
         cv::Mat img = cv::imdecode(data, cv::IMREAD_ANYCOLOR);
-        return aron::converter::AronOpenCVConverter::ConvertFromMat(img);
+        return aron::converter::AronOpenCVConverter::ConvertFromMat(img, p);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/image/png/PngConverter.h

@@ -16,6 +16,6 @@ namespace armarx::armem::server::ltm::converter::image
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::NDArrayPtr& data) final;
-        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::NDArrayPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.cpp

@@ -9,9 +9,9 @@ namespace armarx::armem::server::ltm
         return _convert(d);
     }
 
-    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::VariantPtr ObjectConverter::convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
-        auto d = _convert(data, m);
+        auto d = _convert(data, p, m);
         return d;
     }
 

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/Converter.h

@@ -21,10 +21,10 @@ namespace armarx::armem::server::ltm
         virtual ~ObjectConverter() = default;
 
         std::pair<std::vector<unsigned char>, std::string> convert(const aron::data::VariantPtr& data) final;
-        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::VariantPtr convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     protected:
         virtual std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) = 0;
-        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) = 0;
+        virtual aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) = 0;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.cpp

@@ -24,13 +24,13 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(bson, str);
     }
 
-    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const std::string& m)
+    aron::data::DictPtr BsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string& m)
     {
         bsoncxx::document::view view(data.data(), data.size());
         nlohmann::json json = bsoncxx::to_json(view);
         std::string str = json.dump(2);
         std::vector<unsigned char> jsonVec(str.begin(), str.end());
-        auto v = jsonConverter.convert(jsonVec, m);
+        auto v = jsonConverter.convert(jsonVec, p, m);
         return aron::data::Dict::DynamicCast(v);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/bson/BsonConverter.h

@@ -20,7 +20,7 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
 
     private:
         JsonConverter jsonConverter;

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.cpp

@@ -12,10 +12,10 @@ namespace armarx::armem::server::ltm::converter::object
         return std::make_pair(std::vector<unsigned char>(str.begin(), str.end()), "");
     }
 
-    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const std::string&)
+    aron::data::DictPtr JsonConverter::_convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&)
     {
         std::string str(data.begin(), data.end());
         nlohmann::json j = nlohmann::json::parse(str);
-        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j);
+        return aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(j, p);
     }
 }

source/RobotAPI/libraries/armem/server/ltm/base/converter/object/json/JsonConverter.h

@@ -19,6 +19,6 @@ namespace armarx::armem::server::ltm::converter::object
 
     protected:
         std::pair<std::vector<unsigned char>, std::string> _convert(const aron::data::DictPtr& data) final;
-        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const std::string&) final;
+        aron::data::DictPtr _convert(const std::vector<unsigned char>& data, const armarx::aron::Path& p, const std::string&) final;
     };
 }

source/RobotAPI/libraries/armem/server/ltm/disk/CoreSegment.cpp

@@ -8,7 +8,7 @@
 
 namespace armarx::armem::server::ltm::disk
 {
-    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
+    CoreSegment::CoreSegment(const std::filesystem::path& p, const MemoryID& id /* UNESCAPED */, const std::shared_ptr<Processors>& filters, const DiskMemoryItem::MemoryEncodingMode mode, const unsigned long e) :
         CoreSegmentBase(id, filters),
         DiskMemoryItem(p, EscapeSegmentName(id.memoryName), std::filesystem::path(EscapeSegmentName(id.coreSegmentName))),
         currentMode(mode),
@@ -20,6 +20,7 @@ namespace armarx::armem::server::ltm::disk
     {
         auto mPath = getMemoryBasePathForMode(currentMode, currentExport);
         auto relPath = getRelativePathForMode(currentMode);
+
         if (!util::checkIfBasePathExists(mPath) || !util::checkIfFolderExists(mPath, relPath))
         {
             return false;

source/RobotAPI/libraries/armem/server/ltm/disk/Entity.cpp

@@ -67,6 +67,7 @@ namespace armarx::armem::server::ltm::disk
                         continue;
                     }
 
+
                     EntitySnapshot c(memoryParentPath, id().withTimestamp(timeFromStringMicroSeconds(usecName)), processors, currentMode, currentExport);
                     func(c);
                 }
@@ -77,7 +78,7 @@ namespace armarx::armem::server::ltm::disk
 
     bool Entity::forEachSnapshotInIndexRange(long first, long last, std::function<void(EntitySnapshot&)> func) const
     {
-        ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
+        //ARMARX_WARNING << "PLEASE NOTE THAT QUERYING THE LTM INDEX WISE MAY BE BUGGY BECAUSE THE FILESYSTEM ITERATOR IS UNSORTED!";
 
         if (first < 0 or last < 0)
         {
@@ -96,11 +97,11 @@ namespace armarx::armem::server::ltm::disk
         long checked = 0;
         auto f = [&](EntitySnapshot& e)
         {
-            checked++;
             if (checked >= first && checked <= last)
             {
                 func(e);
             }
+            checked++;
         };
 
         return forEachSnapshot(std::move(f));