Merge branch 'armem/dev' into armem/resolve-memory-link-in-gui

source/RobotAPI/libraries/armem/core/base/EntityBase.h

@@ -119,7 +119,7 @@ namespace armarx::armem::base
         /**
          * @brief Indicates whether a history entry for the given time exists.
          */
-        bool hasSnapshot(Time time) const
+        virtual bool hasSnapshot(Time time) const
         {
             return this->_container.count(time) > 0;
         }
@@ -136,7 +136,7 @@ namespace armarx::armem::base
         /**
          * @brief Get all timestamps in the history.
          */
-        std::vector<Time> getTimestamps() const
+        virtual std::vector<Time> getTimestamps() const
         {
             return simox::alg::get_keys(this->_container);
         }
@@ -155,7 +155,7 @@ namespace armarx::armem::base
             return const_cast<EntitySnapshotT&>(const_cast<const EntityBase*>(this)->getSnapshot(time));
         }
 
-        const EntitySnapshotT& getSnapshot(Time time) const
+        virtual const EntitySnapshotT& getSnapshot(Time time) const
         {
             auto it = this->_container.find(time);
             if (it != this->_container.end())
@@ -269,7 +269,7 @@ namespace armarx::armem::base
         }
 
 
-    private:
+    protected:
 
         /// If maximum size is set, ensure `history`'s is not higher.
         void truncateHistoryToSize()
@@ -297,7 +297,7 @@ namespace armarx::armem::base
          * @return The latest snapshot.
          * @throw `armem::error::EntityHistoryEmpty` If the history is empty.
          */
-        const typename std::map<Time, EntitySnapshotT>::value_type& getLatestItem() const
+        virtual const typename std::map<Time, EntitySnapshotT>::value_type& getLatestItem() const
         {
             if (this->_container.empty())
             {

source/RobotAPI/libraries/armem/core/longtermmemory/Entity.h

@@ -38,6 +38,11 @@ namespace armarx::armem::ltm
         using Base::EntityBase;
         using Base::operator=;
 
+        Entity()
+        {
+            // the history of snapshots is just a cache of frequently used elements
+            setMaxHistorySize(20);
+        }
 
         // Conversion
         wm::Entity convert(const MongoDBConnectionManager::MongoDBSettings&) const;
@@ -46,6 +51,50 @@ namespace armarx::armem::ltm
         void reload(const MongoDBConnectionManager::MongoDBSettings&);
         void append(const wm::Entity&, const MongoDBConnectionManager::MongoDBSettings&);
 
+        // virtual overrides for LTM storage
+        /*virtual bool hasSnapshot(Time time) const override
+        {
+            // check cache
+            if (Base::hasSnapshot(time))
+            {
+                return true;
+            }
+            // check mongodb
+            return false;
+            // TODO
+        }
+        virtual std::vector<Time> getTimestamps() const override
+        {
+            // get from cache
+            std::vector<Time> ret = Base::getTimestamps();
+            // get missing from mongodb
+            // TODO
+            return ret;
+        }
+        virtual const EntitySnapshotT& getSnapshot(Time time) const override
+        {
+            try
+            {
+                return Base::getSnapshot(time);
+            }
+            catch (const error::MissingEntry& _)
+            {
+                // if not in cache then get from mongo db
+                // TODO
+                return Base::getSnapshot(time);
+            }
+        }
+
+        protected:
+        // virtual overrides for LTM storage
+        virtual const typename std::map<Time, EntitySnapshotT>::value_type& getLatestItem() const override
+        {
+            // Directly query mongodb (cache cant know whether it is the latest or not)
+            // TODO
+            return Base::getLatestItem();
+        }*/
+
+
     private:
         static const constexpr char* MONGO_DB_COLLECTION_PREFIX = "Entity__";
     };

source/RobotAPI/libraries/armem/test/ArMemLTMTest.cpp

@@ -114,7 +114,7 @@ namespace ArMemLTMTest
 
                 for (unsigned int j = 0; j < numInstances; ++j)
                 {
-                    aron::datanavigator::DictNavigatorPtr m = aron::datanavigator::DictNavigator::DynamicCastAndCheck(r.generateAronDataFromType(t));
+                    aron::datanavigator::DictNavigatorPtr m = aron::datanavigator::DictNavigator::DynamicCastAndCheck(r.generateEmptyAronDataFromType(t));
                     r.initializeRandomly(m, t);
                     q.push_back(m);
                 }

source/RobotAPI/libraries/armem_robot_state/server/localization/Segment.cpp

@@ -157,7 +157,7 @@ namespace armarx::armem::server::robot_state::localization
             coreSegment->id().withProviderSegmentName(transform.header.agent);
         if (not coreSegment->hasProviderSegment(providerID.providerSegmentName))
         {
-            coreSegment->addProviderSegment(providerID.providerSegmentName, arondto::Transform::toInitialAronType());
+            coreSegment->addProviderSegment(providerID.providerSegmentName, arondto::Transform::toAronType());
         }
 
         Commit commit;

source/RobotAPI/libraries/aron/core/CMakeLists.txt

@@ -3,16 +3,9 @@ set(LIB_NAME aron)
 armarx_component_set_name("${LIB_NAME}")
 armarx_set_target("Library: ${LIB_NAME}")
 
-find_package(Eigen3 QUIET)
-armarx_build_if(Eigen3_FOUND "Eigen3 not available")
-
 find_package(Simox QUIET)
 armarx_build_if(Simox_FOUND "Simox not available")
 
-find_package(PCL QUIET COMPONENTS io common)
-armarx_build_if(PCL_FOUND "PCL not available")
-
-
 set(LIBS
     ArmarXCoreInterfaces
     ArmarXCore
@@ -277,16 +270,18 @@ set(LIB_HEADERS
 )
 
 
-armarx_add_library("${LIB_NAME}" "${LIB_FILES}" "${LIB_HEADERS}" "${LIBS}")
-
-
-if(PCL_FOUND)
-target_include_directories("${LIB_NAME}"
-    SYSTEM PUBLIC
-        "${PCL_INCLUDE_DIRS}"
+armarx_add_library(
+    LIB_NAME
+        "${LIB_NAME}"
+    SOURCES
+        "${LIB_FILES}"
+    HEADERS
+        "${LIB_HEADERS}"
+    LIBS
+        "${LIBS}"
 )
-endif()
 
+add_library(RobotAPI::aron ALIAS "${LIB_NAME}")
 
 # add unit tests
 add_subdirectory(test)

source/RobotAPI/libraries/aron/core/Descriptor.h

@@ -36,6 +36,15 @@
 
 namespace armarx::aron::type
 {
+    const std::vector<type::Maybe> ALL_MAYBE_TYPES =
+    {
+        type::Maybe::eNone,
+        type::Maybe::eOptional,
+        type::Maybe::eRawPointer,
+        type::Maybe::eSharedPointer,
+        type::Maybe::eUniquePointer
+    };
+
     enum class Descriptor
     {
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
@@ -46,6 +55,16 @@ namespace armarx::aron::type
         eUnknown = -1
     };
 
+    const std::vector<type::Descriptor> ALL_ARON_TYPES =
+    {
+#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
+    type::Descriptor::e##upperType,
+
+        HANDLE_ALL_ARON_TYPES
+#undef RUN_ARON_MACRO
+        Descriptor::eUnknown
+    };
+
     const std::map<type::Descriptor, std::string> _descriptor2string =
     {
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
@@ -95,6 +114,11 @@ namespace armarx::aron::type
     {
         return type::_string2descriptor.at(s);
     }
+
+    inline type::Descriptor DESCRIPTOR_FROM_STRING(const std::string& s)
+    {
+        return STRING_TO_DESCRIPTOR(s);
+    }
 }
 
 namespace armarx::aron::data
@@ -109,6 +133,16 @@ namespace armarx::aron::data
         eUnknown = -1
     };
 
+    const std::vector<data::Descriptor> ALL_ARON_DATA =
+    {
+#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
+    data::Descriptor::e##upperType,
+
+        HANDLE_ALL_ARON_DATA
+#undef RUN_ARON_MACRO
+        Descriptor::eUnknown
+    };
+
     const std::map<data::Descriptor, std::string> _descriptor2string =
     {
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
@@ -144,4 +178,9 @@ namespace armarx::aron::data
     {
         return data::_string2descriptor.at(s);
     }
+
+    inline data::Descriptor DESCRIPTOR_FROM_STRING(const std::string& s)
+    {
+        return STRING_TO_DESCRIPTOR(s);
+    }
 }

source/RobotAPI/libraries/aron/core/Randomizer.h

@@ -39,38 +39,33 @@ namespace armarx::aron
     public:
         Randomizer()
         {
-            initialize_random();
+            initializeSelf();
         };
 
-        typenavigator::NavigatorPtr generateRandomType(bool mustBeObject = false) const
+        typenavigator::NavigatorPtr generateRandomType(bool allowMaybeType = false, bool firstObject = false) const
         {
             type::Descriptor nextType = type::Descriptor::eObject;
-            if (!mustBeObject)
+            if (!firstObject)
             {
-                std::vector<type::Descriptor> descriptors =
-                {
-#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-    type::Descriptor::e##upperType,
-
-                    HANDLE_ALL_ARON_TYPES
-#undef RUN_ARON_MACRO
-                };
+                nextType = getRandomElement(type::ALL_ARON_TYPES);
+            }
 
-                int randomType = generateRandom(descriptors.size(), 0);
-                nextType = descriptors[randomType];
+            type::Maybe nextMaybeType = type::Maybe::eNone;
+            if (allowMaybeType && !firstObject)
+            {
+                nextMaybeType = getRandomElement(type::ALL_MAYBE_TYPES);
             }
 
             switch (nextType)
             {
                 case type::Descriptor::eObject:
                 {
-                    typenavigator::ObjectNavigatorPtr t = typenavigator::ObjectNavigatorPtr(new typenavigator::ObjectNavigator(Path()));
+                    auto t = std::make_shared<typenavigator::ObjectNavigator>();
                     std::string objectName = generateRandomWord();
                     t->setObjectName(objectName);
 
-                    std::vector<std::string> usedNames({objectName});
                     int members = generateRandom(4, 2);
-                    std::set<std::string> usedKeys;
+                    std::set<std::string> usedKeys = {objectName};
                     for (int i = 0; i < members; ++i)
                     {
                         std::string key = generateRandomWord(usedKeys);
@@ -81,9 +76,25 @@ namespace armarx::aron
                     }
                     return t;
                 }
+                case type::Descriptor::eIntEnum:
+                {
+                    auto t = std::make_shared<typenavigator::IntEnumNavigator>();
+                    std::string intEnumName = generateRandomWord();
+                    t->setEnumName(intEnumName);
+
+                    std::set<std::string> usedKeys = {intEnumName};
+                    for (int i = 0; i < generateRandom(5, 2); ++i)
+                    {
+                        std::string key = generateRandomWord(usedKeys);
+                        usedKeys.insert(key);
+
+                        t->addAcceptedValue(key, i);
+                    }
+                    return t;
+                }
                 case type::Descriptor::eDict:
                 {
-                    typenavigator::DictNavigatorPtr t = typenavigator::DictNavigatorPtr(new typenavigator::DictNavigator());
+                    auto t = std::make_shared<typenavigator::DictNavigator>();
                     typenavigator::NavigatorPtr a = generateRandomType(false);
 
                     t->setAcceptedType(a);
@@ -91,7 +102,7 @@ namespace armarx::aron
                 }
                 case type::Descriptor::eTuple:
                 {
-                    typenavigator::TupleNavigatorPtr t = typenavigator::TupleNavigatorPtr(new typenavigator::TupleNavigator());
+                    auto t = std::make_shared<typenavigator::TupleNavigator>();
 
                     int members = generateRandom(4, 2);
                     for (int i = 0; i < members; ++i)
@@ -103,7 +114,7 @@ namespace armarx::aron
                 }
                 case type::Descriptor::eList:
                 {
-                    typenavigator::ListNavigatorPtr t = typenavigator::ListNavigatorPtr(new typenavigator::ListNavigator());
+                    auto t = std::make_shared<typenavigator::ListNavigator>();
                     typenavigator::NavigatorPtr a = generateRandomType(false);
 
                     t->setAcceptedType(a);
@@ -111,7 +122,7 @@ namespace armarx::aron
                 }
                 case type::Descriptor::ePair:
                 {
-                    typenavigator::PairNavigatorPtr t = typenavigator::PairNavigatorPtr(new typenavigator::PairNavigator());
+                    auto t = std::make_shared<typenavigator::PairNavigator>();
                     typenavigator::NavigatorPtr a = generateRandomType(false);
                     typenavigator::NavigatorPtr b = generateRandomType(false);
 
@@ -119,15 +130,61 @@ namespace armarx::aron
                     t->setSecondAcceptedType(b);
                     return t;
                 }
-                case type::Descriptor::eEigenMatrix: // TODO (fabian.peller)
+                case type::Descriptor::eNDArray:
+                {
+                    // TODO (fabian.peller)
+                    // fall through EigenMatrix
+                }
+                case type::Descriptor::eEigenMatrix:
+                {
+                    auto t = std::make_shared<typenavigator::EigenMatrixNavigator>();
+                    auto type = getRandomKey(t->ACCEPTED_TYPES);
+                    t->setTypename(type);
+                    t->setRows(generateRandom(10, 1));
+                    t->setRows(generateRandom(10, 1));
+                    return t;
+                }
                 case type::Descriptor::eEigenQuaternion:
+                {
+                    auto t = std::make_shared<typenavigator::EigenQuaternionNavigator>();
+                    auto type = getRandomKey(t->ACCEPTED_TYPES);
+                    t->setTypename(type);
+                    return t;
+                }
                 case type::Descriptor::eIVTCByteImage:
+                {
+                    auto t = std::make_shared<typenavigator::IVTCByteImageNavigator>();
+                    auto type = getRandomKey(t->ACCEPTED_TYPES);
+                    return t;
+                }
                 case type::Descriptor::eOpenCVMat:
+                {
+                    auto t = std::make_shared<typenavigator::OpenCVMatNavigator>();
+                    auto type = getRandomKey(t->ACCEPTED_TYPES);
+                    return t;
+                }
                 case type::Descriptor::ePCLPointCloud:
+                {
+                    auto t = std::make_shared<typenavigator::PCLPointCloudNavigator>();
+                    auto type = getRandomKey(t->ACCEPTED_TYPES);
+                    t->setTypename(type);
+                    return t;
+                }
                 case type::Descriptor::ePosition:
+                {
+                    auto t = std::make_shared<typenavigator::PositionNavigator>();
+                    return t;
+                }
                 case type::Descriptor::eOrientation:
+                {
+                    auto t = std::make_shared<typenavigator::PositionNavigator>();
+                    return t;
+                }
                 case type::Descriptor::ePose:
-
+                {
+                    auto t = std::make_shared<typenavigator::PositionNavigator>();
+                    return t;
+                }
                 case type::Descriptor::eInt:
                 {
                     auto t = std::make_shared<typenavigator::IntNavigator>();
@@ -163,14 +220,14 @@ namespace armarx::aron
                     auto t = std::make_shared<typenavigator::TimeNavigator>();
                     return t;
                 }
-                default:
+                case type::Descriptor::eUnknown:
                 {
                     throw error::DescriptorNotValidException("Randomizer", "generateRandomType", "No valid type found!", nextType);
                 }
             }
         }
 
-        datanavigator::NavigatorPtr generateAronDataFromType(const typenavigator::NavigatorPtr& type, bool ignore_maybe = false) const
+        datanavigator::NavigatorPtr generateEmptyAronDataFromType(const typenavigator::NavigatorPtr& type, bool ignore_maybe = false) const
         {
             if (type->getMaybe() != type::Maybe::eNone && !ignore_maybe)
             {
@@ -187,25 +244,32 @@ namespace armarx::aron
                 case type::Descriptor::eObject:
                 {
                     typenavigator::ObjectNavigatorPtr t = typenavigator::ObjectNavigator::DynamicCastAndCheck(type);
-                    datanavigator::DictNavigatorPtr d = datanavigator::DictNavigatorPtr(new datanavigator::DictNavigator());
+                    auto d = std::make_shared<datanavigator::DictNavigator>();
                     for (const auto& [k, tt] : t->getMemberTypes())
                     {
-                        d->addElement(k, generateAronDataFromType(tt));
+                        d->addElement(k, generateEmptyAronDataFromType(tt));
                     }
                     return d;
                 }
 
+                case type::Descriptor::eIntEnum:
+                {
+                    auto t = typenavigator::IntEnumNavigator::DynamicCastAndCheck(type);
+                    auto d = std::make_shared<datanavigator::IntNavigator>();
+                    return d;
+                }
+
                 // here all totally random
                 case type::Descriptor::eDict:
                 {
-                    typenavigator::DictNavigatorPtr t = typenavigator::DictNavigator::DynamicCastAndCheck(type);
+                    auto t = typenavigator::DictNavigator::DynamicCastAndCheck(type);
                     return datanavigator::NavigatorPtr(new datanavigator::DictNavigator());
                 }
 
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
 case type::Descriptor::e##upperType: \
 { \
-    typenavigator::upperType##NavigatorPtr t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
+    auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
     return datanavigator::NavigatorPtr(new datanavigator::ListNavigator()); \
 }
 
@@ -215,9 +279,8 @@ case type::Descriptor::e##upperType: \
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
 case type::Descriptor::e##upperType: \
 { \
-    typenavigator::upperType##NavigatorPtr t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
-    datanavigator::NDArrayNavigatorPtr ndarray = datanavigator::NDArrayNavigatorPtr(new datanavigator::NDArrayNavigator()); \
-    return ndarray; \
+    auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
+    return datanavigator::NDArrayNavigatorPtr(new datanavigator::NDArrayNavigator()); \
 }
 
                 HANDLE_NDARRAY_TYPES
@@ -226,36 +289,31 @@ case type::Descriptor::e##upperType: \
 #define RUN_ARON_MACRO(upperType, lowerType, capsType, upperData, lowerData, capsData) \
 case type::Descriptor::e##upperType: \
 { \
-    typenavigator::upperType##NavigatorPtr t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
+    auto t = typenavigator::upperType##Navigator::DynamicCastAndCheck(type); \
     return datanavigator::NavigatorPtr(new datanavigator::upperData##Navigator()); \
 }
 
                 HANDLE_PRIMITIVE_CORRESPONDING
 #undef RUN_ARON_MACRO
-                default:
+                case type::Descriptor::eUnknown:
                 {
                     throw error::DescriptorNotValidException("Randomizer", "generateAronDataFromType", "No valid type found!", desc);
                 }
             }
+            // end of non void....... dont know why
+            return nullptr;
         }
 
         void initializeRandomly(datanavigator::NavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
         {
+            data = generateEmptyAronDataFromType(type);
             if (!data)
             {
-                if (!type->getMaybe() != type::Maybe::eNone)
+                if (type->getMaybe() == type::Maybe::eNone)
                 {
                     throw error::AronException("Randomizer", "initializeRandomly", "The data is null but the type is not a maybe type. This is not valid.");
                 }
-
-                if (fiftyPercentChance()) // 50% chance
-                {
-                    data = generateAronDataFromType(type, true);
-                }
-                else
-                {
-                    return;
-                }
+                return;
             }
 
             // Containers
@@ -275,37 +333,62 @@ case type::Descriptor::e##upperType: \
                 HANDLE_ALL_CORRESPONDING
 #undef RUN_ARON_MACRO
 
-                default:
+                case type::Descriptor::eUnknown:
                 {
                     throw error::DescriptorNotValidException("Randomizer", "initializeRandomly", "No valid type found!", desc);
                 }
             }
         }
 
+        // generate i in [min, max)
         int generateRandom(int max, int min) const
         {
-            max += 1;
+            if (max < min)
+            {
+                throw error::IndexNotValidException("AronRandomizer", "generateRandom", "The max value is lower than the min value", max, min);
+            }
             int random = (std::rand() % (max - min)) + min;
             return random;
         }
 
+        template <class T>
+        T getRandomElement(const std::vector<T>& vec) const
+        {
+            int i = generateRandom(vec.size(), 0);
+            return vec.at(i);
+        }
+
+        template <class T>
+        std::string getRandomKey(const std::map<std::string, T>& m) const
+        {
+            std::vector<std::string> keys;
+            for (const auto [k, _] : m)
+            {
+                keys.push_back(k);
+            }
+            return getRandomElement(keys);
+        }
 
         bool fiftyPercentChance() const
         {
-            return generateRandom(2, 1) == 1;
+            return generateRandom(2, 0);
         }
 
         std::string generateRandomWord(const std::set<std::string>& usedKeys = {}) const
         {
+            // https://randomwordgenerator.com/
+            // script to convert random words into string:
+            // jQuery("#result li i").remove(); var str = ""; jQuery("#result li").each(function() {str += jQuery(this).html() + ", " }); console.log(str);
             std::vector<string> words =
             {
-                "Lorem", "ipsum", "dolor", "sit", "amet", "consetetur", "sadipscing", "elitr"
-                "sed", "diam", "nonumy", "eirmod", "tempor", "invidunt", "ut", "labore", "et"
-                "dolore", "magna", "aliquyam", "eratsed"
+                "jaw", "river", "bow", "profession", "heat", "interference", "slave", "population", "deport", "redeem", "digress", "penny", "cousin", "beef", "Bible", "fuss",
+                "urgency", "tasty", "innovation", "upset", "gold", "day", "remunerate", "strain", "district", "panel", "choke", "rack", "parameter", "despair", "extort", "country",
+                "hesitate", "record", "brand", "confusion", "discreet", "accept", "lifestyle", "option", "corn", "charity", "miss", "viable", "glance", "norm", "meet", "bird",
+                "ribbon", "guideline"
             };
 
-            int i = generateRandom(words.size() - 1, 0);
-            std::string key = words[i];
+            int i = generateRandom(words.size(), 0);
+            std::string key = words.at(i);
 
             while (usedKeys.count(key) > 0)
             {
@@ -320,18 +403,11 @@ case type::Descriptor::e##upperType: \
             std::vector<unsigned char> new_blob(size, 0);
             for (unsigned int i = 0; i < size; ++i)
             {
-                new_blob[i] = (generateRandom(127, 0));
+                new_blob[i] = (generateRandom(128, 0));
             }
             return new_blob;
         }
 
-    private:
-        void initialize_random() const
-        {
-            std::srand(std::time(nullptr));
-        }
-
-    public:
         void initializeRandomly(datanavigator::DictNavigatorPtr& data, const typenavigator::ObjectNavigatorPtr& type) const
         {
             for (auto& [key, nextData] : data->getElements())
@@ -349,7 +425,7 @@ case type::Descriptor::e##upperType: \
             {
                 std::string key = generateRandomWord(usedKeys);
                 usedKeys.insert(key);
-                datanavigator::NavigatorPtr newData = generateAronDataFromType(type->getAcceptedType());
+                datanavigator::NavigatorPtr newData = generateEmptyAronDataFromType(type->getAcceptedType());
                 initializeRandomly(newData, type->getAcceptedType());
                 data->addElement(key, newData);
             }
@@ -378,7 +454,7 @@ case type::Descriptor::e##upperType: \
             int numElements = generateRandom(5, 1);
             for (int i = 0; i < numElements; ++i)
             {
-                datanavigator::NavigatorPtr newData = generateAronDataFromType(type->getAcceptedType());
+                datanavigator::NavigatorPtr newData = generateEmptyAronDataFromType(type->getAcceptedType());
                 initializeRandomly(newData, type->getAcceptedType());
                 data->addElement(newData);
             }
@@ -414,12 +490,18 @@ case type::Descriptor::e##upperType: \
 
         void initializeRandomly(datanavigator::BoolNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
         {
-            data->setValue(generateRandom(1, 0));
+            data->setValue(fiftyPercentChance());
         }
 
         void initializeRandomly(datanavigator::StringNavigatorPtr& data, const typenavigator::NavigatorPtr& type) const
         {
             data->setValue(generateRandomWord());
         }
+
+    private:
+        void initializeSelf() const
+        {
+            std::srand(std::time(nullptr));
+        }
     };
 }

source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/toplevel/IntEnumClass.cpp

@@ -170,7 +170,7 @@ namespace armarx::aron::cppserializer::serializer
         CppMethodPtr m = CppMethodPtr(new CppMethod(getFullCppTypename() + "& operator=(const " + getFullCppTypename() + "& c)", doc.str()));
         CppBlockPtr b = std::make_shared<CppBlock>();
         b->addLine("value = c.value;");
-        b->addLine("return *this");
+        b->addLine("return *this;");
         m->setBlock(b);
         return m;
     }
@@ -184,7 +184,7 @@ namespace armarx::aron::cppserializer::serializer
         CppMethodPtr m = CppMethodPtr(new CppMethod(getFullCppTypename() + "& operator=(" + std::string(IMPL_ENUM) + " v)", doc.str()));
         CppBlockPtr b = std::make_shared<CppBlock>();
         b->addLine("value = v;");
-        b->addLine("return *this");
+        b->addLine("return *this;");
         m->setBlock(b);
         return m;
     }
@@ -205,7 +205,7 @@ namespace armarx::aron::cppserializer::serializer
         CppBlockPtr b3 = std::make_shared<CppBlock>();
         b3->addLine("value = it->second;");
         b->addBlock(b3);
-        b->addLine("return *this");
+        b->addLine("return *this;");
         m->setBlock(b);
         return m;
     }

source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp

@@ -78,6 +78,14 @@ namespace armarx::aron::datanavigator
         }
         return true;
     }
+    bool NDArrayNavigator::operator==(const NDArrayNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
     // static methods
     NDArrayNavigatorPtr NDArrayNavigator::FromAronNDArrayPtr(const data::AronNDArrayPtr& aron)

source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.h

@@ -63,6 +63,7 @@ namespace armarx::aron::datanavigator
 
         // operators
         virtual bool operator==(const NDArrayNavigator&) const override;
+        bool operator==(const NDArrayNavigatorPtr&) const override;
 
         // static methods
         static PointerType FromAronNDArrayPtr(const data::AronNDArrayPtr& aron);

source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp

@@ -67,21 +67,29 @@ namespace armarx::aron::datanavigator
     {
         for (const auto& [key, nav] : childrenNavigators)
         {
-            if (!nav)
-            {
-                return (bool) other.getElement(key);
-            }
             if (not(other.hasElement(key)))
             {
                 return false;
             }
-            if (not(*nav == other.getElement(key)))
+            if (!nav)
+            {
+                return !((bool) other.getElement(key));
+            }
+            if (not(*nav == *other.getElement(key)))
             {
                 return false;
             }
         }
         return true;
     }
+    bool DictNavigator::operator==(const DictNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
     // static methods
     DictNavigatorPtr DictNavigator::FromAronDictPtr(const data::AronDictPtr& aron)

source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.h

@@ -50,6 +50,7 @@ namespace armarx::aron::datanavigator
 
         // operators
         virtual bool operator==(const DictNavigator&) const override;
+        bool operator==(const DictNavigatorPtr&) const override;
 
         static PointerType FromAronDictPtr(const data::AronDictPtr& aron);
         static data::AronDictPtr ToAronDictPtr(const PointerType& navigator);

source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp

@@ -70,6 +70,10 @@ namespace armarx::aron::datanavigator
         unsigned int i = 0;
         for (const auto& nav : childrenNavigators)
         {
+            if (!other.hasElement(i))
+            {
+                return false;
+            }
             if (!nav)
             {
                 if (!other.getElement(i))
@@ -77,10 +81,6 @@ namespace armarx::aron::datanavigator
                     return false;
                 }
             }
-            if (!other.hasElement(i))
-            {
-                return false;
-            }
             if (!(*nav == other.getElement(i)))
             {
                 return false;
@@ -89,6 +89,14 @@ namespace armarx::aron::datanavigator
         }
         return true;
     }
+    bool ListNavigator::operator==(const ListNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
     // static methods
     ListNavigatorPtr ListNavigator::FromAronListPtr(const data::AronListPtr& aron)

source/RobotAPI/libraries/aron/core/navigator/data/container/List.h

@@ -50,6 +50,7 @@ namespace armarx::aron::datanavigator
 
         // operators
         virtual bool operator==(const ListNavigator&) const override;
+        bool operator==(const ListNavigatorPtr&) const override;
 
         // static methods
         static PointerType FromAronListPtr(const data::AronListPtr& aron);

source/RobotAPI/libraries/aron/core/navigator/data/detail/NavigatorBase.h

@@ -76,14 +76,7 @@ namespace armarx::aron::datanavigator::detail
         }
 
         virtual bool operator==(const DerivedT&) const = 0;
-        bool operator==(const PointerType& other) const
-        {
-            if (other)
-            {
-                return *this == *other;
-            }
-            return false;
-        }
+        virtual bool operator==(const PointerType& other) const = 0;
 
         // virtual implementations
         virtual data::AronDataPtr toAronPtr() const override

source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.cpp

@@ -46,10 +46,20 @@ namespace armarx::aron::datanavigator
     bool BoolNavigator::operator==(const BoolNavigator& other) const
     {
         const auto& otherAron = other.toAronBoolPtr();
-        if(aron->value != otherAron->value)
+        if (aron->value != otherAron->value)
+        {
             return false;
+        }
         return true;
     }
+    bool BoolNavigator::operator==(const BoolNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
 
     /* static methods */

source/RobotAPI/libraries/aron/core/navigator/data/primitive/Bool.h

@@ -42,8 +42,6 @@ namespace armarx::aron::datanavigator
         virtual public detail::PrimitiveNavigatorBase<data::AronBool, bool, BoolNavigator>
     {
     public:
-        using PointerType = BoolNavigatorPtr;
-
         /* constructors */
         BoolNavigator(const Path& = Path());
         BoolNavigator(const data::AronBoolPtr&, const Path& = Path());
@@ -51,6 +49,7 @@ namespace armarx::aron::datanavigator
 
         // operators
         bool operator==(const BoolNavigator& other) const override;
+        bool operator==(const BoolNavigatorPtr&) const override;
 
         // static methods
         static BoolNavigatorPtr FromAronBoolPtr(const data::AronBoolPtr& aron);

source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.cpp

@@ -50,11 +50,20 @@ namespace armarx::aron::datanavigator
     bool DoubleNavigator::operator==(const DoubleNavigator& other) const
     {
         const auto& otherAron = other.toAronDoublePtr();
-        if(this->aron->value != otherAron->value)
+        if (this->aron->value != otherAron->value)
+        {
             return false;
+        }
         return true;
     }
-
+    bool DoubleNavigator::operator==(const DoubleNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
     /* static methods */
     DoubleNavigatorPtr DoubleNavigator::FromAronDoublePtr(const data::AronDoublePtr& aron)

source/RobotAPI/libraries/aron/core/navigator/data/primitive/Double.h

@@ -42,8 +42,6 @@ namespace armarx::aron::datanavigator
         virtual public detail::PrimitiveNavigatorBase<data::AronDouble, double, DoubleNavigator>
     {
     public:
-        using PointerType = DoubleNavigatorPtr;
-
         /* constructors */
         DoubleNavigator(const Path& = Path());
         DoubleNavigator(const data::AronDoublePtr&, const Path& = Path());
@@ -51,6 +49,7 @@ namespace armarx::aron::datanavigator
 
         /* operators */
         bool operator==(const DoubleNavigator&) const override;
+        bool operator==(const DoubleNavigatorPtr&) const override;
 
         /* static methods */
         static DoubleNavigatorPtr FromAronDoublePtr(const data::AronDoublePtr& aron);

source/RobotAPI/libraries/aron/core/navigator/data/primitive/Float.cpp

@@ -46,10 +46,20 @@ namespace armarx::aron::datanavigator
     bool FloatNavigator::operator==(const FloatNavigator& other) const
     {
         const auto& otherAron = other.toAronFloatPtr();
-        if(this->aron->value != otherAron->value)
+        if (this->aron->value != otherAron->value)
+        {
             return false;
+        }
         return true;
     }
+    bool FloatNavigator::operator==(const FloatNavigatorPtr& other) const
+    {
+        if (!other)
+        {
+            return false;
+        }
+        return *this == *other;
+    }
 
 
     /* static methods */