diff --git a/source/RobotAPI/components/ArViz/Coin/VisualizationPointCloud.h b/source/RobotAPI/components/ArViz/Coin/VisualizationPointCloud.h
index 8db4dd4faa575eb8fedc084c10b3f88114d50ffa..14b2331cad2c96ff419dcd5441424f4dafb5d491 100644
--- a/source/RobotAPI/components/ArViz/Coin/VisualizationPointCloud.h
+++ b/source/RobotAPI/components/ArViz/Coin/VisualizationPointCloud.h
@@ -101,7 +101,7 @@ namespace armarx::viz::coin
             __m128 floatMax = _mm_set1_ps(FLT_MAX);
 
 
-//            std::uint64_t timerStart = __rdtsc();
+            //            std::uint64_t timerStart = __rdtsc();
             // Work on four points at a time
             for (int i = 0; i < pclSize; i += 4)
             {
@@ -186,10 +186,10 @@ namespace armarx::viz::coin
                 // Move the input offsets to the next 4 colored points
                 offsetBase = _mm_add_epi32(offsetBase, offsetIncrement);
             }
-//            std::uint64_t timerEnd = __rdtsc();
-//            int timerDiff = (int)(timerEnd - timerStart);
-//            float ticksPerPoint = (float)timerDiff / pclSize;
-//            printf("%c[2KUpdate Time %d\tT/Point %g\n", 27, timerDiff, ticksPerPoint);
+            //            std::uint64_t timerEnd = __rdtsc();
+            //            int timerDiff = (int)(timerEnd - timerStart);
+            //            float ticksPerPoint = (float)timerDiff / pclSize;
+            //            printf("%c[2KUpdate Time %d\tT/Point %g\n", 27, timerDiff, ticksPerPoint);
 
             pclMat->diffuseColor.setValuesPointer(pclSize, colorsData);
             pclMat->ambientColor.setValuesPointer(pclSize, colorsData);
diff --git a/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.cpp b/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.cpp
index 18c9dc655ed8af90cb5f557d0f2ac6fb09c12643..ac67b3a3b5ebfa719a6af1cca86032cd81238f25 100644
--- a/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.cpp
+++ b/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.cpp
@@ -68,7 +68,7 @@ namespace armarx
     void DebugRobotUnitDataStreamingWidgetController::timerEvent(QTimerEvent* event)
     {
         const std::size_t n = widget.spinBoxNumberOfStreams->value();
-        if(!getRobotUnit())
+        if (!getRobotUnit())
         {
             return;
         }
@@ -78,11 +78,11 @@ namespace armarx
         }
         std::lock_guard f{mutex};
         RobotUnitDataStreaming::Config cfg;
-        if(widget.checkBoxStreamSens->isChecked())
+        if (widget.checkBoxStreamSens->isChecked())
         {
             cfg.loggingNames.emplace_back("sens");
         }
-        if(widget.checkBoxStreamCtrl->isChecked())
+        if (widget.checkBoxStreamCtrl->isChecked())
         {
             cfg.loggingNames.emplace_back("ctrl");
         }
diff --git a/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.h b/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.h
index 436985349fdc03139f6ded9a0a0b6a5327c1fdab..430af82b3b31ed6c955cd3ab851152fafcf14890 100644
--- a/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.h
+++ b/source/RobotAPI/gui-plugins/DebugRobotUnitDataStreaming/DebugRobotUnitDataStreamingWidgetController.h
@@ -62,12 +62,12 @@ namespace armarx
     class ARMARXCOMPONENT_IMPORT_EXPORT
         DebugRobotUnitDataStreamingWidgetController:
         public armarx::ArmarXComponentWidgetControllerTemplate < DebugRobotUnitDataStreamingWidgetController >,
-            public virtual RobotUnitComponentPluginUser
+        public virtual RobotUnitComponentPluginUser
     {
         Q_OBJECT
     public:
         explicit DebugRobotUnitDataStreamingWidgetController();
-        
+
         void loadSettings(QSettings* settings) override;
         void saveSettings(QSettings* settings) override;
         QPointer<QDialog> getConfigDialog(QWidget* parent) override;
@@ -81,12 +81,12 @@ namespace armarx
         {
             return "Debugging.DebugRobotUnitDataStreaming";
         }
-        
+
         void onInitComponent()       override {}
         void onConnectComponent()    override {}
         void onDisconnectComponent() override;
         void onExitComponent()       override {}
-        
+
     protected:
         void timerEvent(QTimerEvent* event) override;
 
@@ -94,7 +94,8 @@ namespace armarx
         std::mutex                                     mutex;
         Ui::DebugRobotUnitDataStreamingWidget          widget;
         std::vector<RobotUnitDataStreamingReceiverPtr> rec;
-        QPointer<SimpleConfigDialog>                   dialog;};
+        QPointer<SimpleConfigDialog>                   dialog;
+    };
 }
 
 
diff --git a/source/RobotAPI/libraries/ArmarXObjects/ObjectFinder.cpp b/source/RobotAPI/libraries/ArmarXObjects/ObjectFinder.cpp
index e9a9fc4ebc70dbcf0a0761ccd75f7cc21d4609d1..ed8d14d913785406841f24602ffdb17496d4a2ef 100644
--- a/source/RobotAPI/libraries/ArmarXObjects/ObjectFinder.cpp
+++ b/source/RobotAPI/libraries/ArmarXObjects/ObjectFinder.cpp
@@ -232,10 +232,10 @@ namespace armarx
 
 
     static std::vector<std::string> _loadNames(
-            const ObjectFinder& finder,
-            const ObjectID& objectID,
-            const bool includeClassName,
-            const std::function<std::optional<std::vector<std::string>>(const ObjectInfo&)> loadNamesFn)
+        const ObjectFinder& finder,
+        const ObjectID& objectID,
+        const bool includeClassName,
+        const std::function<std::optional<std::vector<std::string>>(const ObjectInfo&)> loadNamesFn)
     {
         std::vector<std::string> names;
         if (includeClassName)
@@ -254,14 +254,14 @@ namespace armarx
     }
     std::vector<std::string> ObjectFinder::loadRecognizedNames(const ObjectID& objectID, bool includeClassName) const
     {
-        return _loadNames(*this, objectID, includeClassName, [](const ObjectInfo& info)
+        return _loadNames(*this, objectID, includeClassName, [](const ObjectInfo & info)
         {
             return info.loadRecognizedNames();
         });
     }
     std::vector<std::string> ObjectFinder::loadSpokenNames(const ObjectID& objectID, bool includeClassName) const
     {
-        return _loadNames(*this, objectID, includeClassName, [](const ObjectInfo& info)
+        return _loadNames(*this, objectID, includeClassName, [](const ObjectInfo & info)
         {
             return info.loadSpokenNames();
         });
diff --git a/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.cpp b/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.cpp
index 7ac7717c5e632d33873f6e4ff43fa97f9362c6a3..71398d59dc8d00018bcc0d4fb5c1c7cfb6010465 100644
--- a/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.cpp
+++ b/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.cpp
@@ -98,7 +98,7 @@ namespace armarx::objpose
         aronId.className = id.className();
         aronId.dataset = id.dataset();
         aronId.instanceName = id.instanceName();
-        
+
         return aronId;
     }
 
diff --git a/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.h b/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.h
index 04abe6667678e88f6a9fe3239a5695585dd100b4..50e7fc9412d1a30ac166386a29723547ef04cbda 100644
--- a/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.h
+++ b/source/RobotAPI/libraries/ArmarXObjects/aron_conversions.h
@@ -1,11 +1,12 @@
-#pragma once 
+#pragma once
 
 
 namespace armarx::objpose
 {
     struct ObjectPose;
 
-    namespace aron {
+    namespace aron
+    {
         struct ObjectPose;
     }
 
diff --git a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
index 90562a6db2b8d18a4c40714598b6046984d2a433..06a973559c24b42dd306b62f474e12a40f0badfa 100644
--- a/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/eigen/EigenConverter.h
@@ -57,7 +57,7 @@ namespace armarx::aron::converter
         {
             ARMARX_CHECK_NOT_NULL(nav);
 
-            if(nav->getDimensions() != std::vector<int>({1, 4, sizeof(T)}))
+            if (nav->getDimensions() != std::vector<int>({1, 4, sizeof(T)}))
             {
                 throw error::AronException("AronEigenConverter", "ConvertToQuaternion", "The size of an NDArray does not match.", nav->getPath());
             }
@@ -73,7 +73,7 @@ namespace armarx::aron::converter
         {
             ARMARX_CHECK_NOT_NULL(nav);
 
-            if(nav->getDimensions() != std::vector<int>({Size, 1, sizeof(T)}))
+            if (nav->getDimensions() != std::vector<int>({Size, 1, sizeof(T)}))
             {
                 throw error::AronException("AronEigenConverter", "ConvertToVector", "The size of an NDArray does not match.", nav->getPath());
             }
@@ -89,7 +89,7 @@ namespace armarx::aron::converter
         {
             ARMARX_CHECK_NOT_NULL(nav);
 
-            if(nav->getDimensions() != std::vector<int>({Rows, Cols, sizeof(T)}))
+            if (nav->getDimensions() != std::vector<int>({Rows, Cols, sizeof(T)}))
             {
                 throw error::AronException("AronEigenConverter", "ConvertToMatrix", "The size of an NDArray does not match.", nav->getPath());
             }
diff --git a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
index 160a0287137066ec9688dd5a372727a4d543c234..292b1a4c8a92af539e7a60361897bed73f2a1c6e 100644
--- a/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
+++ b/source/RobotAPI/libraries/aron/converter/opencv/OpenCVConverter.cpp
@@ -33,7 +33,7 @@ namespace armarx::aron::converter
     {
         ARMARX_CHECK_NOT_NULL(nav);
 
-        if(nav->getDimensions().size() < 3)
+        if (nav->getDimensions().size() < 3)
         {
             throw error::AronException("AronIVTConverter", "ConvertToCByteImage", "The size of an NDArray does not match.", nav->getPath());
         }
diff --git a/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h b/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
index a58bb7c989b7adb3f5b0b4bbc9f1e1f6cf12fa86..9500dfd0273090216477003795164bffe608cf3c 100644
--- a/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
+++ b/source/RobotAPI/libraries/aron/converter/pcl/PCLConverter.h
@@ -47,7 +47,7 @@ namespace armarx::aron::converter
         {
             ARMARX_CHECK_NOT_NULL(nav);
 
-            if(nav->getDimensions().size() != 3) // +1 for bytes per pixel
+            if (nav->getDimensions().size() != 3) // +1 for bytes per pixel
             {
                 throw error::AronException("AronIVTConverter", "ConvertToCByteImage", "The size of an NDArray does not match.", nav->getPath());
             }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h b/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h
index 855a00cf276c29c8e2aa512e597d22e1d674570d..f66bc8566c1dc16158e4bdc8aed3ec78d8222362 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/ReaderInfo.h
@@ -29,15 +29,15 @@
 
 namespace armarx::aron::codegeneratorhelper
 {
-            class ReaderInfo;
-            typedef std::shared_ptr<ReaderInfo> ReaderInfoPtr;
+    class ReaderInfo;
+    typedef std::shared_ptr<ReaderInfo> ReaderInfoPtr;
 
-            class ReaderInfo
-            {
-            public:
-                std::string methodName;
-                std::string argumentType;
-                std::string readerClassType;
-                std::string include;
-            };
+    class ReaderInfo
+    {
+    public:
+        std::string methodName;
+        std::string argumentType;
+        std::string readerClassType;
+        std::string include;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h b/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h
index e6c85f594ec6088454dbdec6555761b345d9dea4..375b3c0d51ff24ed0d671878be9feead7a59998c 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/WriterInfo.h
@@ -29,15 +29,15 @@
 
 namespace armarx::aron::codegeneratorhelper
 {
-            class WriterInfo;
-            typedef std::shared_ptr<WriterInfo> WriterInfoPtr;
+    class WriterInfo;
+    typedef std::shared_ptr<WriterInfo> WriterInfoPtr;
 
-            class WriterInfo
-            {
-            public:
-                std::string methodName;
-                std::string returnType;
-                std::string writerClassType;
-                std::string include;
-            };
+    class WriterInfo
+    {
+    public:
+        std::string methodName;
+        std::string returnType;
+        std::string writerClassType;
+        std::string include;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
index fc1bca391e4d79e19b03be4cefa0dd053613d42d..07af1e5fefcd375e2dea87a1d66d1798e6d40816 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/SerializerFactory.h
@@ -37,20 +37,20 @@
 
 namespace armarx::aron::cppcodegenerator
 {
-                    class SerializerFactory;
-                    typedef std::shared_ptr<SerializerFactory> SerializerFactoryPtr;
+    class SerializerFactory;
+    typedef std::shared_ptr<SerializerFactory> SerializerFactoryPtr;
 
-                    class SerializerFactory :
-                        virtual public codegenerator::SerializerFactory<typenavigator::NavigatorPtr, SerializerPtr>
-                    {
-                    public:
-                        SerializerFactory() = default;
-                        virtual SerializerPtr create(const typenavigator::NavigatorPtr&, const Path&) const override;
-                        virtual SerializerPtr createSpecific(const typenavigator::NavigatorPtr&, const Path&) const override;
+    class SerializerFactory :
+        virtual public codegenerator::SerializerFactory<typenavigator::NavigatorPtr, SerializerPtr>
+    {
+    public:
+        SerializerFactory() = default;
+        virtual SerializerPtr create(const typenavigator::NavigatorPtr&, const Path&) const override;
+        virtual SerializerPtr createSpecific(const typenavigator::NavigatorPtr&, const Path&) const override;
 
-                    };
+    };
 
-                    // Factories
+    // Factories
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
     class upperType##SerializerFactory : \
         virtual public SerializerFactory \
@@ -60,6 +60,6 @@ namespace armarx::aron::cppcodegenerator
         virtual SerializerPtr createSpecific(const typenavigator::NavigatorPtr&, const Path&) const override; \
     };
 
-                    HANDLE_ALL_ARON_TYPES
+    HANDLE_ALL_ARON_TYPES
 #undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Primitive.h b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Primitive.h
index c1ff77cebfe61356f501c48a6bfbad1e601e981b..4356f6757d20c4ba68b603d49e98d51f9aa2a3e8 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Primitive.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/codeWriter/cpp/serializer/primitive/Primitive.h
@@ -67,6 +67,6 @@ namespace armarx::aron::cppcodegenerator::serializer
         typenavigator::upperType##NavigatorPtr typenavigator; \
     };
 
-                    HANDLE_PRIMITIVE_TYPES
+    HANDLE_PRIMITIVE_TYPES
 #undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp
index 6bf00c8db81a9bd61b579d760b6b250f47544537..77485c5fdb3b8ce814366b0b73492d249235ab5c 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/Reader.cpp
@@ -34,155 +34,155 @@
 #include <RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h>
 
 namespace armarx::aron::xmltypereader
+{
+    void Reader::parseFile(const std::string& filename)
+    {
+        RapidXmlReaderPtr reader = RapidXmlReader::FromFile(filename);
+        parse(reader);
+    }
+
+    void Reader::parseFile(const std::filesystem::path& file)
+    {
+        RapidXmlReaderPtr reader = RapidXmlReader::FromFile(file.string());
+        parse(reader);
+    }
+
+    // private method reading nodes
+    void Reader::parse(const RapidXmlReaderPtr& reader)
+    {
+        RapidXmlReaderNode root = reader->getRoot();
+
+        // Check Header
+        Data::EnforceTagName(root, Data::TYPE_DEFINITION_TAG);
+
+        Data::CheckMaxChildSize(root, 4);
+        std::vector<RapidXmlReaderNode> children = root.nodes();
+
+        int cpp_includes_index = -1;
+        int include_aron_file_index = -1;
+        int generate_types_index = -1;
+
+        int index = 0;
+        for (const auto& child : children)
+        {
+            if (Data::HasTagName(child, Data::CODE_INCLUDES_TAG))
             {
-                void Reader::parseFile(const std::string& filename)
+                if (cpp_includes_index != -1)
                 {
-                    RapidXmlReaderPtr reader = RapidXmlReader::FromFile(filename);
-                    parse(reader);
+                    throw error::AronException("XMLReader", "parse", "Already found an include tag. Please check the xml file.");
                 }
-
-                void Reader::parseFile(const std::filesystem::path& file)
+                else
                 {
-                    RapidXmlReaderPtr reader = RapidXmlReader::FromFile(file.string());
-                    parse(reader);
+                    cpp_includes_index = index;
                 }
-
-                // private method reading nodes
-                void Reader::parse(const RapidXmlReaderPtr& reader)
+            }
+            else if (Data::HasTagName(child, Data::INCLUDES_TAG))
+            {
+                if (include_aron_file_index != -1)
                 {
-                    RapidXmlReaderNode root = reader->getRoot();
-
-                    // Check Header
-                    Data::EnforceTagName(root, Data::TYPE_DEFINITION_TAG);
-
-                    Data::CheckMaxChildSize(root, 4);
-                    std::vector<RapidXmlReaderNode> children = root.nodes();
-
-                    int cpp_includes_index = -1;
-                    int include_aron_file_index = -1;
-                    int generate_types_index = -1;
-
-                    int index = 0;
-                    for (const auto& child : children)
-                    {
-                        if (Data::HasTagName(child, Data::CODE_INCLUDES_TAG))
-                        {
-                            if (cpp_includes_index != -1)
-                            {
-                                throw error::AronException("XMLReader", "parse", "Already found an include tag. Please check the xml file.");
-                            }
-                            else
-                            {
-                                cpp_includes_index = index;
-                            }
-                        }
-                        else if (Data::HasTagName(child, Data::INCLUDES_TAG))
-                        {
-                            if (include_aron_file_index != -1)
-                            {
-                                throw error::AronException("XMLReader", "parse", "Already found an use type tag. Please check the xml file.");
-                            }
-                            else
-                            {
-                                include_aron_file_index = index;
-                            }
-                        }
-                        else if (Data::HasTagName(child, Data::GENERATE_TYPES_TAG))
-                        {
-                            if (generate_types_index != -1)
-                            {
-                                throw error::AronException("XMLReader", "parse", "Already found an generate type tag. Please check the xml file.");
-                            }
-                            else
-                            {
-                                generate_types_index = index;
-                            }
-                        }
-                        else
-                        {
-                            throw error::StringNotValidException("XMLReader", "parse", "Found an unexpected xml tag", child.name());
-                        }
-                        index++;
-                    }
-
-                    // 1. Check includes
-                    if (cpp_includes_index != -1)
-                    {
-                        std::vector<RapidXmlReaderNode> includes = children[cpp_includes_index].nodes();
-                        for (const auto& include : includes)
-                        {
-                            this->codeIncludes.push_back(readCppInclude(include));
-                        }
-                    }
-
-                    // 2. Check AronIncludes
-                    if (include_aron_file_index != -1)
-                    {
-                        for (const auto& aronInclude : children[include_aron_file_index].nodes())
-                        {
-                            // right now unused
-                            this->aronIncludes.push_back(readAronInclude(aronInclude));
-                        }
-                    }
-
-                    // 3. Check GenerateTypes
-                    if (generate_types_index != -1)
-                    {
-                        for (const auto& generateType : children[generate_types_index].nodes())
-                        {
-                            // ugly workaround
-                            if(Data::HasTagName(generateType, Data::GENERATE_OBJECT_TAG))
-                            {
-                                const auto nav = readGenerateObject(generateType);
-                                const auto infos = factory.AllPublicObjects;
-                                generateObjects.push_back(infos.at(simox::alg::to_lower(nav->getObjectName())));
-                                continue;
-                            }
-                            if(Data::HasTagName(generateType, Data::GENERATE_INT_ENUM_TAG))
-                            {
-                                const auto nav = readGenerateIntEnum(generateType);
-                                const auto infos = factory.AllPublicIntEnums;
-                                generateIntEnums.push_back(infos.at(simox::alg::to_lower(nav->getEnumName())));
-                                continue;
-                            }
-                            throw error::StringNotValidException("XMLReader", "parse", "Could not find a valid tag inside generatetypes", generateType.name());
-
-                        }
-                    }
+                    throw error::AronException("XMLReader", "parse", "Already found an use type tag. Please check the xml file.");
                 }
-
-                std::string Reader::readCppInclude(const RapidXmlReaderNode& node) const
+                else
                 {
-                    Data::EnforceTagName(node, Data::INCLUDE_TAG);
-                    Data::EnforceAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
-                    const std::string include = node.attribute_value(Data::INCLUDE_ATTRIBUTE_NAME);
-                    return include;
+                    include_aron_file_index = index;
                 }
-
-                std::string Reader::readAronInclude(const RapidXmlReaderNode& node) const
+            }
+            else if (Data::HasTagName(child, Data::GENERATE_TYPES_TAG))
+            {
+                if (generate_types_index != -1)
                 {
-                    Data::EnforceTagName(node, Data::INCLUDE_TAG);
+                    throw error::AronException("XMLReader", "parse", "Already found an generate type tag. Please check the xml file.");
+                }
+                else
+                {
+                    generate_types_index = index;
+                }
+            }
+            else
+            {
+                throw error::StringNotValidException("XMLReader", "parse", "Found an unexpected xml tag", child.name());
+            }
+            index++;
+        }
+
+        // 1. Check includes
+        if (cpp_includes_index != -1)
+        {
+            std::vector<RapidXmlReaderNode> includes = children[cpp_includes_index].nodes();
+            for (const auto& include : includes)
+            {
+                this->codeIncludes.push_back(readCppInclude(include));
+            }
+        }
+
+        // 2. Check AronIncludes
+        if (include_aron_file_index != -1)
+        {
+            for (const auto& aronInclude : children[include_aron_file_index].nodes())
+            {
+                // right now unused
+                this->aronIncludes.push_back(readAronInclude(aronInclude));
+            }
+        }
+
+        // 3. Check GenerateTypes
+        if (generate_types_index != -1)
+        {
+            for (const auto& generateType : children[generate_types_index].nodes())
+            {
+                // ugly workaround
+                if (Data::HasTagName(generateType, Data::GENERATE_OBJECT_TAG))
+                {
+                    const auto nav = readGenerateObject(generateType);
+                    const auto infos = factory.AllPublicObjects;
+                    generateObjects.push_back(infos.at(simox::alg::to_lower(nav->getObjectName())));
+                    continue;
+                }
+                if (Data::HasTagName(generateType, Data::GENERATE_INT_ENUM_TAG))
+                {
+                    const auto nav = readGenerateIntEnum(generateType);
+                    const auto infos = factory.AllPublicIntEnums;
+                    generateIntEnums.push_back(infos.at(simox::alg::to_lower(nav->getEnumName())));
+                    continue;
+                }
+                throw error::StringNotValidException("XMLReader", "parse", "Could not find a valid tag inside generatetypes", generateType.name());
 
-                    const std::string xmlinclude = Data::GetAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
+            }
+        }
+    }
 
-                    // parse parent xml file and add objects to alreday known
-                    Reader anotherReader;
-                    anotherReader.parseFile(xmlinclude);
+    std::string Reader::readCppInclude(const RapidXmlReaderNode& node) const
+    {
+        Data::EnforceTagName(node, Data::INCLUDE_TAG);
+        Data::EnforceAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
+        const std::string include = node.attribute_value(Data::INCLUDE_ATTRIBUTE_NAME);
+        return include;
+    }
 
-                    return xmlinclude;
-                }
+    std::string Reader::readAronInclude(const RapidXmlReaderNode& node) const
+    {
+        Data::EnforceTagName(node, Data::INCLUDE_TAG);
 
-                typenavigator::ObjectNavigatorPtr Reader::readGenerateObject(const RapidXmlReaderNode& node) const
-                {
-                    Data::EnforceTagName(node, Data::GENERATE_OBJECT_TAG);
-                    return typenavigator::ObjectNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+        const std::string xmlinclude = Data::GetAttribute(node, Data::INCLUDE_ATTRIBUTE_NAME);
 
-                }
+        // parse parent xml file and add objects to alreday known
+        Reader anotherReader;
+        anotherReader.parseFile(xmlinclude);
 
-                typenavigator::IntEnumNavigatorPtr Reader::readGenerateIntEnum(const RapidXmlReaderNode& node) const
-                {
-                    Data::EnforceTagName(node, Data::GENERATE_INT_ENUM_TAG);
-                    return typenavigator::IntEnumNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+        return xmlinclude;
+    }
 
-                }
+    typenavigator::ObjectNavigatorPtr Reader::readGenerateObject(const RapidXmlReaderNode& node) const
+    {
+        Data::EnforceTagName(node, Data::GENERATE_OBJECT_TAG);
+        return typenavigator::ObjectNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+
+    }
+
+    typenavigator::IntEnumNavigatorPtr Reader::readGenerateIntEnum(const RapidXmlReaderNode& node) const
+    {
+        Data::EnforceTagName(node, Data::GENERATE_INT_ENUM_TAG);
+        return typenavigator::IntEnumNavigator::DynamicCastAndCheck(factory.create(node, Path()));
+
+    }
 }
diff --git a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h
index dbed99c551c990aedc4ab7546894ad8049387485..88e7ad01df9ec261b7bdc6226c1974b5375ff043 100644
--- a/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h
+++ b/source/RobotAPI/libraries/aron/core/codegenerator/typeReader/xml/ReaderFactory.h
@@ -65,15 +65,15 @@ namespace armarx::aron::xmltypereader
 
     };
 
-    #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-        class upperType##ReaderFactory : \
+#define RUN_ARON_MACRO(upperType, lowerType, capsType) \
+    class upperType##ReaderFactory : \
         virtual public ReaderFactory \
-        { \
-        public: \
+    { \
+    public: \
         upperType##ReaderFactory() = default; \
         virtual typenavigator::NavigatorPtr createSpecific(const RapidXmlReaderNode&, const Path&) const override; \
-        };
+    };
 
-        HANDLE_ALL_ARON_TYPES
-    #undef RUN_ARON_MACRO
+    HANDLE_ALL_ARON_TYPES
+#undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp
index dc6ab4b8301687d2848591569591c23ecb7066a0..4372e4e63ae646ae1e6342c0d91add66c6a5a76d 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/Navigator.cpp
@@ -29,85 +29,85 @@
 #include <RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h>
 
 namespace armarx::aron::datanavigator
-        {
-            // static data members
-            const NavigatorFactoryPtr Navigator::FACTORY = NavigatorFactoryPtr(new NavigatorFactory());
+{
+    // static data members
+    const NavigatorFactoryPtr Navigator::FACTORY = NavigatorFactoryPtr(new NavigatorFactory());
 
-            // constructors
-            Navigator::Navigator(const data::Descriptor& descriptor, const Path& path) :
-                aron::Navigator<data::Descriptor, data::AronData>::Navigator(descriptor, path)
-            {
-            }
+    // constructors
+    Navigator::Navigator(const data::Descriptor& descriptor, const Path& path) :
+        aron::Navigator<data::Descriptor, data::AronData>::Navigator(descriptor, path)
+    {
+    }
 
-            // static methods
-            NavigatorPtr Navigator::FromAronData(const data::AronDataPtr& a, const Path& path)
-            {
-                return FACTORY->create(a, path);
-            }
+    // static methods
+    NavigatorPtr Navigator::FromAronData(const data::AronDataPtr& a, const Path& path)
+    {
+        return FACTORY->create(a, path);
+    }
 
-            std::vector<NavigatorPtr> Navigator::FromAronData(const std::vector<data::AronDataPtr>& a, const Path& path)
-            {
-                std::vector<NavigatorPtr> ret;
-                for (const auto& aron : a)
-                {
-                    ret.push_back(Navigator::FromAronData(aron, path));
-                }
-                return ret;
-            }
-            std::vector<data::AronDataPtr> Navigator::ToAronData(const std::vector<NavigatorPtr>& a)
-            {
-                std::vector<data::AronDataPtr> ret;
-                for (const auto& aron : a)
-                {
-                    ret.push_back(aron->getResult());
-                }
-                return ret;
-            }
+    std::vector<NavigatorPtr> Navigator::FromAronData(const std::vector<data::AronDataPtr>& a, const Path& path)
+    {
+        std::vector<NavigatorPtr> ret;
+        for (const auto& aron : a)
+        {
+            ret.push_back(Navigator::FromAronData(aron, path));
+        }
+        return ret;
+    }
+    std::vector<data::AronDataPtr> Navigator::ToAronData(const std::vector<NavigatorPtr>& a)
+    {
+        std::vector<data::AronDataPtr> ret;
+        for (const auto& aron : a)
+        {
+            ret.push_back(aron->getResult());
+        }
+        return ret;
+    }
 
-            void Navigator::CheckDataNavigatorPtrForNull(const std::string& c, const std::string& m, const NavigatorPtr& data)
-            {
-                if (data.get() == nullptr)
-                {
-                    throw error::AronException(c, m, "Could not make use of an NavigatorPtr. The Ptr was NULL");
-                }
-            }
+    void Navigator::CheckDataNavigatorPtrForNull(const std::string& c, const std::string& m, const NavigatorPtr& data)
+    {
+        if (data.get() == nullptr)
+        {
+            throw error::AronException(c, m, "Could not make use of an NavigatorPtr. The Ptr was NULL");
+        }
+    }
 
-            void Navigator::CheckDataNavigatorPtrForNull(const std::string& c, const std::string& m, const Path& p, const NavigatorPtr& data)
-            {
-                if (data.get() == nullptr)
-                {
-                    throw error::AronException(c, m, "Could not make use of an NavigatorPtr. The Ptr was NULL", p);
-                }
-            }
+    void Navigator::CheckDataNavigatorPtrForNull(const std::string& c, const std::string& m, const Path& p, const NavigatorPtr& data)
+    {
+        if (data.get() == nullptr)
+        {
+            throw error::AronException(c, m, "Could not make use of an NavigatorPtr. The Ptr was NULL", p);
+        }
+    }
 
-            NavigatorPtr Navigator::navigateAbsolute(const Path& path) const
-            {
-                throw error::AronException("Navigator", "navigateAbsolute", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
-            }
+    NavigatorPtr Navigator::navigateAbsolute(const Path& path) const
+    {
+        throw error::AronException("Navigator", "navigateAbsolute", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
+    }
 
-            NavigatorPtr Navigator::navigateRelative(const Path& path) const
-            {
-                throw error::AronException("Navigator", "navigateRelative", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
-            }
+    NavigatorPtr Navigator::navigateRelative(const Path& path) const
+    {
+        throw error::AronException("Navigator", "navigateRelative", "Could not navigate through a non container navigator. The input path was: " + path.toString(), getPath());
+    }
 
 
-            /*AronContainerDataNavigatorPtr AronContainerDataNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                AronContainerDataNavigatorPtr casted = std::dynamic_pointer_cast<AronContainerDataNavigator>(n);
-                return casted;
-            }
+    /*AronContainerDataNavigatorPtr AronContainerDataNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        AronContainerDataNavigatorPtr casted = std::dynamic_pointer_cast<AronContainerDataNavigator>(n);
+        return casted;
+    }
 
-            AronContainerDataNavigatorPtr AronContainerDataNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckDataNavigatorPtrForNull("AronContainerDataNavigator", "DynamicCastAndCheck[Before]", n);
-                AronContainerDataNavigatorPtr casted = AronContainerDataNavigator::DynamicCast(n);
-                CheckDataNavigatorPtrForNull("AronContainerDataNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
-                return casted;
-            }
+    AronContainerDataNavigatorPtr AronContainerDataNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckDataNavigatorPtrForNull("AronContainerDataNavigator", "DynamicCastAndCheck[Before]", n);
+        AronContainerDataNavigatorPtr casted = AronContainerDataNavigator::DynamicCast(n);
+        CheckDataNavigatorPtrForNull("AronContainerDataNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
+        return casted;
+    }
 
-            NavigatorPtr AronContainerDataNavigator::navigateRelative(const Path& path) const
-            {
-                Path absoluteFromHere = path.getWithoutPrefix(getPath());
-                return navigateAbsolute(absoluteFromHere);
-            }*/
+    NavigatorPtr AronContainerDataNavigator::navigateRelative(const Path& path) const
+    {
+        Path absoluteFromHere = path.getWithoutPrefix(getPath());
+        return navigateAbsolute(absoluteFromHere);
+    }*/
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp
index 7f96d2392235838ba2348642aefb5fe0ac35e51c..ee89003517219102eb5be1a276876434fb63630a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.cpp
@@ -36,7 +36,7 @@ namespace armarx::aron::datanavigator
     NavigatorPtr NavigatorFactory::create(const data::AronDataPtr& aron, const Path& path) const
     {
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-        {data::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
+    {data::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
 
         static const std::map<data::Descriptor, NavigatorFactoryPtr> Factories =
         {
@@ -60,11 +60,11 @@ namespace armarx::aron::datanavigator
 
     // Factories
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-NavigatorPtr upperType##NavigatorFactory::createSpecific(const data::AronDataPtr& aron, const Path& path) const \
-{ \
-data::Aron##upperType##Ptr aronCasted = data::Aron##upperType##Ptr::dynamicCast(aron); \
-return datanavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
-}
+    NavigatorPtr upperType##NavigatorFactory::createSpecific(const data::AronDataPtr& aron, const Path& path) const \
+    { \
+        data::Aron##upperType##Ptr aronCasted = data::Aron##upperType##Ptr::dynamicCast(aron); \
+        return datanavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
+    }
 
     HANDLE_ALL_ARON_DATA
 #undef RUN_ARON_MACRO
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h
index 0f83691b526565c18e7e3fe457230b06f51db451..63d08c14524f7861e58d7294758e7582eaa2b434 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/NavigatorFactory.h
@@ -36,19 +36,19 @@
 
 namespace armarx::aron::datanavigator
 {
-            class NavigatorFactory;
-            typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
+    class NavigatorFactory;
+    typedef std::shared_ptr<NavigatorFactory> NavigatorFactoryPtr;
 
-            class NavigatorFactory :
-                virtual public Factory<data::AronDataPtr, datanavigator::NavigatorPtr>
-            {
-            public:
-                NavigatorFactory() = default;
-                virtual NavigatorPtr create(const data::AronDataPtr&, const Path&) const override;
-                virtual NavigatorPtr createSpecific(const data::AronDataPtr&, const Path&) const override;
-            };
+    class NavigatorFactory :
+        virtual public Factory<data::AronDataPtr, datanavigator::NavigatorPtr>
+    {
+    public:
+        NavigatorFactory() = default;
+        virtual NavigatorPtr create(const data::AronDataPtr&, const Path&) const override;
+        virtual NavigatorPtr createSpecific(const data::AronDataPtr&, const Path&) const override;
+    };
 
-            // Factories
+    // Factories
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
     class upperType##NavigatorFactory : \
         virtual public NavigatorFactory \
@@ -58,7 +58,7 @@ namespace armarx::aron::datanavigator
         virtual NavigatorPtr createSpecific(const data::AronDataPtr&, const Path&) const override; \
     };
 
-            HANDLE_ALL_ARON_DATA
+    HANDLE_ALL_ARON_DATA
 #undef RUN_ARON_MACRO
 
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp
index a520f0140cec2013965a1f2517017033299ef05e..0ed94c664655cbb4668ef4611a843e94fb1e1420 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/complex/NDArray.cpp
@@ -207,12 +207,12 @@ namespace armarx::aron::datanavigator
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
 case type::e##upperType: \
 { \
-typenavigator::upperType##NavigatorPtr casted = typenavigator::upperType##Navigator::DynamicCast(type); \
-if (std::vector<int>(aron->dimensions.begin(), std::prev(aron->dimensions.end())) != casted->getDimensions() || aron->type != casted->getTypename()) \
-{ \
-return false; \
-} \
-break; \
+    typenavigator::upperType##NavigatorPtr casted = typenavigator::upperType##Navigator::DynamicCast(type); \
+    if (std::vector<int>(aron->dimensions.begin(), std::prev(aron->dimensions.end())) != casted->getDimensions() || aron->type != casted->getTypename()) \
+    { \
+        return false; \
+    } \
+    break; \
 }
 
             HANDLE_NDARRAY_TYPES
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp
index 47c94a46ed0c90f49ecaadca8e534aa0c71b6374..90653ddcd7e080510528673ceb24c4c14f70af09 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/container/Dict.cpp
@@ -30,267 +30,267 @@
 #include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
 
 namespace armarx::aron::datanavigator
+{
+
+    // constructors
+    DictNavigator::DictNavigator(const Path& path) :
+        aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path),
+        Navigator(data::Descriptor::eDict, path),
+        aron(new data::AronDict())
+    {
+    }
+
+    DictNavigator::DictNavigator(const data::AronDictPtr& o, const Path& path) :
+        aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path),
+        Navigator(data::Descriptor::eDict, path),
+        aron(o)
+    {
+        CheckAronPtrForNull("DictNavigator", "DictNavigator", getPath(), aron);
+
+        for (const auto& [key, dataPtr] : aron->elements)
         {
-
-            // constructors
-            DictNavigator::DictNavigator(const Path& path) :
-                aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path),
-                Navigator(data::Descriptor::eDict, path),
-                aron(new data::AronDict())
-            {
-            }
-
-            DictNavigator::DictNavigator(const data::AronDictPtr& o, const Path& path) :
-                aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eDict, path),
-                Navigator(data::Descriptor::eDict, path),
-                aron(o)
-            {
-                CheckAronPtrForNull("DictNavigator", "DictNavigator", getPath(), aron);
-
-                for (const auto& [key, dataPtr] : aron->elements)
-                {
-                    childrenNavigators[key] = Navigator::FromAronData(dataPtr, Path(path, key));
-                }
-            }
-
-            DictNavigator::DictNavigator(const data::AronDataDict& d, const Path& path) :
-                DictNavigator(data::AronDictPtr(new data::AronDict(d)), path)
-            {
-            }
-
-            DictNavigator::DictNavigator(const std::map<std::string, NavigatorPtr>& m, const Path& path) :
-                DictNavigator(path)
-            {
-                for (const auto& [key, dataPtr] : m)
-                {
-                    addElement(key, dataPtr);
-                }
-            }
-
-            // operators
-            bool DictNavigator::operator==(const DictNavigator& other) const
-            {
-                for (const auto& [key, nav] : childrenNavigators)
-                {
-                    if (not(other.hasElement(key)))
-                    {
-                        return false;
-                    }
-                    if (not(nav->equalsDataNavigator(other.getElement(key))))
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            }
-
-            bool DictNavigator::equalsDataNavigator(const NavigatorPtr& other) const
-            {
-                if (other == nullptr)
-                {
-                    return false;
-                }
-                DictNavigatorPtr casted = DynamicCast(other);
-                return equalsDeep(casted);
-            }
-
-            bool DictNavigator::equalsDeep(const DictNavigatorPtr& other) const
-            {
-                return *this == *other;
-            }
-
-            // static methods
-            DictNavigatorPtr DictNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                return std::dynamic_pointer_cast<DictNavigator>(n);
-            }
-
-            DictNavigator DictNavigator::DynamicCast(Navigator& n)
-            {
-                return dynamic_cast<DictNavigator&>(n);
-            }
-
-            DictNavigatorPtr DictNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckDataNavigatorPtrForNull("DictNavigator", "DynamicCastAndCheck[Before]", n);
-                DictNavigatorPtr casted = DictNavigator::DynamicCast(n);
-                CheckDataNavigatorPtrForNull("DictNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
-                return casted;
-            }
-
-            DictNavigatorPtr DictNavigator::FromAronDictPtr(const data::AronDictPtr& aron)
-            {
-                return std::make_shared<DictNavigator>(aron);
-            }
-
-            data::AronDictPtr DictNavigator::ToAronDictPtr(const DictNavigatorPtr& navigator)
-            {
-                return navigator ? navigator->toAronDictPtr() : nullptr;
-            }
-
-            data::AronDictPtr DictNavigator::toAronDictPtr() const
-            {
-                return aron;
-            }
-
-            // public member functions
-            std::vector<std::string> DictNavigator::getAllKeys() const
-            {
-                std::vector<std::string> ret;
-                for (const auto& [key, _] : childrenNavigators)
-                {
-                    ret.push_back(key);
-                }
-                return ret;
-            }
-
-            void DictNavigator::addElement(const std::string& key, const NavigatorPtr& data)
-            {
-                this->childrenNavigators[key] = data;
-                this->aron->elements[key] = data->getResult();
-            }
-
-            bool DictNavigator::hasElement(const std::string& key) const
+            childrenNavigators[key] = Navigator::FromAronData(dataPtr, Path(path, key));
+        }
+    }
+
+    DictNavigator::DictNavigator(const data::AronDataDict& d, const Path& path) :
+        DictNavigator(data::AronDictPtr(new data::AronDict(d)), path)
+    {
+    }
+
+    DictNavigator::DictNavigator(const std::map<std::string, NavigatorPtr>& m, const Path& path) :
+        DictNavigator(path)
+    {
+        for (const auto& [key, dataPtr] : m)
+        {
+            addElement(key, dataPtr);
+        }
+    }
+
+    // operators
+    bool DictNavigator::operator==(const DictNavigator& other) const
+    {
+        for (const auto& [key, nav] : childrenNavigators)
+        {
+            if (not(other.hasElement(key)))
             {
-                return childrenNavigators.count(key) > 0;
+                return false;
             }
-
-            NavigatorPtr DictNavigator::getElement(const std::string& key) const
+            if (not(nav->equalsDataNavigator(other.getElement(key))))
             {
-                auto it = childrenNavigators.find(key);
-                if (it == childrenNavigators.end())
-                {
-                    std::string all_keys = "";
-                    for (const auto& child : this->getAllKeys())
-                    {
-                        all_keys += child + ", ";
-                    }
-                    throw error::AronException("DictNavigator", "getElement", "Could not find key '" + key + "'. But I found the following keys: [" + all_keys + "]", getPath());
-                }
-                return it->second;
+                return false;
             }
+        }
+        return true;
+    }
 
-            std::map<std::string, NavigatorPtr> DictNavigator::getElements() const
+    bool DictNavigator::equalsDataNavigator(const NavigatorPtr& other) const
+    {
+        if (other == nullptr)
+        {
+            return false;
+        }
+        DictNavigatorPtr casted = DynamicCast(other);
+        return equalsDeep(casted);
+    }
+
+    bool DictNavigator::equalsDeep(const DictNavigatorPtr& other) const
+    {
+        return *this == *other;
+    }
+
+    // static methods
+    DictNavigatorPtr DictNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        return std::dynamic_pointer_cast<DictNavigator>(n);
+    }
+
+    DictNavigator DictNavigator::DynamicCast(Navigator& n)
+    {
+        return dynamic_cast<DictNavigator&>(n);
+    }
+
+    DictNavigatorPtr DictNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckDataNavigatorPtrForNull("DictNavigator", "DynamicCastAndCheck[Before]", n);
+        DictNavigatorPtr casted = DictNavigator::DynamicCast(n);
+        CheckDataNavigatorPtrForNull("DictNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
+        return casted;
+    }
+
+    DictNavigatorPtr DictNavigator::FromAronDictPtr(const data::AronDictPtr& aron)
+    {
+        return std::make_shared<DictNavigator>(aron);
+    }
+
+    data::AronDictPtr DictNavigator::ToAronDictPtr(const DictNavigatorPtr& navigator)
+    {
+        return navigator ? navigator->toAronDictPtr() : nullptr;
+    }
+
+    data::AronDictPtr DictNavigator::toAronDictPtr() const
+    {
+        return aron;
+    }
+
+    // public member functions
+    std::vector<std::string> DictNavigator::getAllKeys() const
+    {
+        std::vector<std::string> ret;
+        for (const auto& [key, _] : childrenNavigators)
+        {
+            ret.push_back(key);
+        }
+        return ret;
+    }
+
+    void DictNavigator::addElement(const std::string& key, const NavigatorPtr& data)
+    {
+        this->childrenNavigators[key] = data;
+        this->aron->elements[key] = data->getResult();
+    }
+
+    bool DictNavigator::hasElement(const std::string& key) const
+    {
+        return childrenNavigators.count(key) > 0;
+    }
+
+    NavigatorPtr DictNavigator::getElement(const std::string& key) const
+    {
+        auto it = childrenNavigators.find(key);
+        if (it == childrenNavigators.end())
+        {
+            std::string all_keys = "";
+            for (const auto& child : this->getAllKeys())
             {
-                return childrenNavigators;
+                all_keys += child + ", ";
             }
-
-            void DictNavigator::clear()
+            throw error::AronException("DictNavigator", "getElement", "Could not find key '" + key + "'. But I found the following keys: [" + all_keys + "]", getPath());
+        }
+        return it->second;
+    }
+
+    std::map<std::string, NavigatorPtr> DictNavigator::getElements() const
+    {
+        return childrenNavigators;
+    }
+
+    void DictNavigator::clear()
+    {
+        childrenNavigators.clear();
+        aron->elements.clear();
+    }
+
+    // virtual implementations
+    data::AronDataPtr DictNavigator::getResult() const
+    {
+        return toAronDictPtr();
+    }
+
+    std::string DictNavigator::getName() const
+    {
+        return "AronDict";
+    }
+
+    typenavigator::NavigatorPtr DictNavigator::recalculateType() const
+    {
+        typenavigator::DictNavigatorPtr typenav = typenavigator::DictNavigatorPtr(new typenavigator::DictNavigator(getPath()));
+        for (const auto& [key, nav] : childrenNavigators)
+        {
+            if (typenav->getAcceptedType() == nullptr)
             {
-                childrenNavigators.clear();
-                aron->elements.clear();
+                typenav->setAcceptedType(nav->recalculateType());
+                continue;
             }
 
-            // virtual implementations
-            data::AronDataPtr DictNavigator::getResult() const
+            if (!nav->fullfillsType(typenav->getAcceptedType()))
             {
-                return toAronDictPtr();
+                throw error::AronException("DictNavigator", "recalculateType", "Cannot recalculate the aronType. Inconsistency found for key: " + key, getPath());
             }
+        }
+        return typenav->getAcceptedType();
+    }
 
-            std::string DictNavigator::getName() const
-            {
-                return "AronDict";
-            }
+    bool DictNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+    {
+        if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
+        {
+            return false;
+        }
 
-            typenavigator::NavigatorPtr DictNavigator::recalculateType() const
+        type::Descriptor typeDesc = type->getDescriptor();
+        switch (typeDesc)
+        {
+            case type::eObject:
             {
-                typenavigator::DictNavigatorPtr typenav = typenavigator::DictNavigatorPtr(new typenavigator::DictNavigator(getPath()));
+                typenavigator::ObjectNavigatorPtr objectTypeNav = typenavigator::ObjectNavigator::DynamicCast(type);
                 for (const auto& [key, nav] : childrenNavigators)
                 {
-                    if (typenav->getAcceptedType() == nullptr)
-                    {
-                        typenav->setAcceptedType(nav->recalculateType());
-                        continue;
-                    }
-
-                    if (!nav->fullfillsType(typenav->getAcceptedType()))
+                    if (!nav->fullfillsType(objectTypeNav->getMemberType(key)))
                     {
-                        throw error::AronException("DictNavigator", "recalculateType", "Cannot recalculate the aronType. Inconsistency found for key: " + key, getPath());
+                        return false;
                     }
                 }
-                return typenav->getAcceptedType();
+                return true;
             }
-
-            bool DictNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+            case type::eDict:
             {
-                if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
-                {
-                    return false;
-                }
-
-                type::Descriptor typeDesc = type->getDescriptor();
-                switch(typeDesc)
-                {
-                case type::eObject:
-                {
-                    typenavigator::ObjectNavigatorPtr objectTypeNav = typenavigator::ObjectNavigator::DynamicCast(type);
-                    for (const auto& [key, nav] : childrenNavigators)
-                    {
-                        if (!nav->fullfillsType(objectTypeNav->getMemberType(key)))
-                        {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-                case type::eDict:
+                typenavigator::DictNavigatorPtr dictTypeNav = typenavigator::DictNavigator::DynamicCast(type);
+                for (const auto& [_, nav] : childrenNavigators)
                 {
-                    typenavigator::DictNavigatorPtr dictTypeNav = typenavigator::DictNavigator::DynamicCast(type);
-                    for (const auto& [_, nav] : childrenNavigators)
+                    if (!nav->fullfillsType(dictTypeNav->getAcceptedType()))
                     {
-                        if (!nav->fullfillsType(dictTypeNav->getAcceptedType()))
-                        {
-                            return false;
-                        }
+                        return false;
                     }
-                    return true;
-                }
-                default:
-                    return false;
-                }
-            }
-
-            std::vector<NavigatorPtr> DictNavigator::getChildren() const
-            {
-                std::vector<NavigatorPtr> ret(childrenNavigators.size());
-                for (const auto& [key, nav] : childrenNavigators)
-                {
-                    ret.push_back(nav);
-                }
-                return ret;
-            }
-
-            size_t DictNavigator::childrenSize() const
-            {
-                return childrenNavigators.size();
-            }
-
-            NavigatorPtr DictNavigator::navigateAbsolute(const Path& path) const
-            {
-                if (!path.hasElement())
-                {
-                    throw error::AronException("DictNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
-                }
-                std::string el = path.getFirstElement();
-                if (!hasElement(el))
-                {
-                    throw error::StringNotValidException("DictNavigator", "navigate", "Could not find an element of a path.", el);
-                }
-
-                if (path.size() == 1)
-                {
-                    return childrenNavigators.at(el);
-                }
-                else
-                {
-                    Path next = path.withDetachedFirstElement();
-                    return childrenNavigators.at(el)->navigateAbsolute(next);
                 }
+                return true;
             }
+            default:
+                return false;
+        }
+    }
+
+    std::vector<NavigatorPtr> DictNavigator::getChildren() const
+    {
+        std::vector<NavigatorPtr> ret(childrenNavigators.size());
+        for (const auto& [key, nav] : childrenNavigators)
+        {
+            ret.push_back(nav);
+        }
+        return ret;
+    }
+
+    size_t DictNavigator::childrenSize() const
+    {
+        return childrenNavigators.size();
+    }
+
+    NavigatorPtr DictNavigator::navigateAbsolute(const Path& path) const
+    {
+        if (!path.hasElement())
+        {
+            throw error::AronException("DictNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
+        }
+        std::string el = path.getFirstElement();
+        if (!hasElement(el))
+        {
+            throw error::StringNotValidException("DictNavigator", "navigate", "Could not find an element of a path.", el);
+        }
 
-            NavigatorPtr DictNavigator::navigateRelative(const Path& path) const
-            {
-                Path absoluteFromHere = path.getWithoutPrefix(getPath());
-                return navigateAbsolute(absoluteFromHere);
-            }
+        if (path.size() == 1)
+        {
+            return childrenNavigators.at(el);
+        }
+        else
+        {
+            Path next = path.withDetachedFirstElement();
+            return childrenNavigators.at(el)->navigateAbsolute(next);
+        }
+    }
+
+    NavigatorPtr DictNavigator::navigateRelative(const Path& path) const
+    {
+        Path absoluteFromHere = path.getWithoutPrefix(getPath());
+        return navigateAbsolute(absoluteFromHere);
+    }
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp
index e9c546a460d12248ecef198c2f25369e803fd0ec..3cce35ea38e9f72e4be92bd185893d7d400909a2 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/container/List.cpp
@@ -32,261 +32,261 @@
 #include <RobotAPI/libraries/aron/core/navigator/type/container/Pair.h>
 
 namespace armarx::aron::datanavigator
+{
+    // constructors
+    ListNavigator::ListNavigator(const Path& path) :
+        aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path),
+        Navigator(data::Descriptor::eList, path),
+        aron(new data::AronList())
+    {
+    }
+
+    ListNavigator::ListNavigator(const data::AronListPtr& l, const Path& path) :
+        aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path),
+        Navigator(data::Descriptor::eList, path),
+        aron(l)
+    {
+        CheckAronPtrForNull("ListNavigator", "ListNavigator", getPath(), aron);
+
+        unsigned int i = 0;
+        for (const auto& dataPtr : l->elements)
         {
-            // constructors
-            ListNavigator::ListNavigator(const Path& path) :
-                aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path),
-                Navigator(data::Descriptor::eList, path),
-                aron(new data::AronList())
+            childrenNavigators.push_back(FromAronData(dataPtr, Path(path, std::to_string(i++))));
+        }
+    }
+
+    ListNavigator::ListNavigator(const data::AronDataList& d, const Path& path) :
+        ListNavigator(data::AronListPtr(new data::AronList(d)), path)
+    {
+    }
+
+    ListNavigator::ListNavigator(const std::vector<NavigatorPtr>& n, const Path& path) :
+        ListNavigator(path)
+    {
+        for (const auto& dataPtr : n)
+        {
+            addElement(dataPtr);
+        }
+    }
+
+    // operators
+    bool ListNavigator::operator==(const ListNavigator& other) const
+    {
+        unsigned int i = 0;
+        for (const auto& nav : childrenNavigators)
+        {
+            if (not(other.hasElement(i)))
             {
+                return false;
             }
-
-            ListNavigator::ListNavigator(const data::AronListPtr& l, const Path& path) :
-                aron::Navigator<data::Descriptor, data::AronData>::Navigator(data::Descriptor::eList, path),
-                Navigator(data::Descriptor::eList, path),
-                aron(l)
+            if (not(nav->equalsDataNavigator(other.getElement(i))))
             {
-                CheckAronPtrForNull("ListNavigator", "ListNavigator", getPath(), aron);
-
-                unsigned int i = 0;
-                for (const auto& dataPtr : l->elements)
-                {
-                    childrenNavigators.push_back(FromAronData(dataPtr, Path(path, std::to_string(i++))));
-                }
+                return false;
             }
-
-            ListNavigator::ListNavigator(const data::AronDataList& d, const Path& path) :
-                ListNavigator(data::AronListPtr(new data::AronList(d)), path)
+            i++;
+        }
+        return true;
+    }
+
+    bool ListNavigator::equalsDataNavigator(const NavigatorPtr& other) const
+    {
+        if (other == nullptr)
+        {
+            return false;
+        }
+        ListNavigatorPtr casted = DynamicCast(other);
+        return equalsDeep(casted);
+    }
+
+    bool ListNavigator::equalsDeep(const ListNavigatorPtr& other) const
+    {
+        return *this == *other;
+    }
+
+    // static methods
+    ListNavigatorPtr ListNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        ListNavigatorPtr casted = std::dynamic_pointer_cast<ListNavigator>(n);
+        return casted;
+    }
+
+    ListNavigator ListNavigator::DynamicCast(Navigator& n)
+    {
+        return dynamic_cast<ListNavigator&>(n);
+    }
+
+    ListNavigatorPtr ListNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckDataNavigatorPtrForNull("ListNavigator", "DynamicCastAndCheck[Before]", n);
+        ListNavigatorPtr casted = ListNavigator::DynamicCast(n);
+        CheckDataNavigatorPtrForNull("ListNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
+        return casted;
+    }
+
+    ListNavigatorPtr ListNavigator::FromAronListPtr(const data::AronListPtr& aron)
+    {
+        return std::make_shared<ListNavigator>(aron);
+    }
+
+    data::AronListPtr ListNavigator::ToAronListPtr(const ListNavigatorPtr& navigator)
+    {
+        return navigator ? navigator->toAronListPtr() : nullptr;
+    }
+
+    // public member functions
+    void ListNavigator::addElement(const NavigatorPtr& n)
+    {
+        childrenNavigators.push_back(n);
+        aron->elements.push_back(n->getResult());
+    }
+
+    bool ListNavigator::hasElement(unsigned int i) const
+    {
+        return i < childrenNavigators.size();
+    }
+
+    NavigatorPtr ListNavigator::getElement(unsigned int i) const
+    {
+        if (i >= childrenNavigators.size())
+        {
+            throw error::AronException("ListNavigator", "getElement", "The index i = " + std::to_string(i) + " is out of bounds (size = " + std::to_string(childrenNavigators.size()) + ")", getPath());
+        }
+        return childrenNavigators[i];
+    }
+
+    std::vector<NavigatorPtr> ListNavigator::getElements() const
+    {
+        return childrenNavigators;
+    }
+
+    void ListNavigator::clear()
+    {
+        childrenNavigators.clear();
+        aron->elements.clear();
+    }
+
+    data::AronListPtr ListNavigator::toAronListPtr() const
+    {
+        return aron;
+    }
+
+    // virtual implementations
+    data::AronDataPtr ListNavigator::getResult() const
+    {
+        return toAronListPtr();
+    }
+
+    std::string ListNavigator::getName() const
+    {
+        return "AronList";
+    }
+
+    typenavigator::NavigatorPtr ListNavigator::recalculateType() const
+    {
+        typenavigator::ListNavigatorPtr typenav = typenavigator::ListNavigatorPtr(new typenavigator::ListNavigator(getPath()));
+        unsigned int i = 0;
+        for (const auto& nav : childrenNavigators)
+        {
+            if (typenav->getAcceptedType() == nullptr)
             {
+                typenav->setAcceptedType(nav->recalculateType());
+                continue;
             }
 
-            ListNavigator::ListNavigator(const std::vector<NavigatorPtr>& n, const Path& path) :
-                ListNavigator(path)
+            if (!nav->fullfillsType(typenav->getAcceptedType()))
             {
-                for (const auto& dataPtr : n)
-                {
-                    addElement(dataPtr);
-                }
+                throw error::AronException("ListNavigator", "recalculateType", "Cannot recalculate the aronType. Inconsistency found for index: " + std::to_string(i), getPath());
             }
+            ++i;
+        }
+        return typenav->getAcceptedType();
+    }
+
+    bool ListNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
+    {
+        if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
+        {
+            return false;
+        }
 
-            // operators
-            bool ListNavigator::operator==(const ListNavigator& other) const
+        type::Descriptor typeDesc = type->getDescriptor();
+        switch (typeDesc)
+        {
+            case type::eList:
             {
-                unsigned int i = 0;
+                typenavigator::ListNavigatorPtr listTypeNav = typenavigator::ListNavigator::DynamicCast(type);
                 for (const auto& nav : childrenNavigators)
                 {
-                    if (not(other.hasElement(i)))
-                    {
-                        return false;
-                    }
-                    if (not(nav->equalsDataNavigator(other.getElement(i))))
+                    if (!nav->fullfillsType(listTypeNav->getAcceptedType()))
                     {
                         return false;
                     }
-                    i++;
                 }
                 return true;
             }
-
-            bool ListNavigator::equalsDataNavigator(const NavigatorPtr& other) const
+            case type::eTuple:
             {
-                if (other == nullptr)
-                {
-                    return false;
-                }
-                ListNavigatorPtr casted = DynamicCast(other);
-                return equalsDeep(casted);
-            }
-
-            bool ListNavigator::equalsDeep(const ListNavigatorPtr& other) const
-            {
-                return *this == *other;
-            }
-
-            // static methods
-            ListNavigatorPtr ListNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                ListNavigatorPtr casted = std::dynamic_pointer_cast<ListNavigator>(n);
-                return casted;
-            }
-
-            ListNavigator ListNavigator::DynamicCast(Navigator& n)
-            {
-                return dynamic_cast<ListNavigator&>(n);
-            }
-
-            ListNavigatorPtr ListNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckDataNavigatorPtrForNull("ListNavigator", "DynamicCastAndCheck[Before]", n);
-                ListNavigatorPtr casted = ListNavigator::DynamicCast(n);
-                CheckDataNavigatorPtrForNull("ListNavigator", "DynamicCastAndCheck[After]", n->getPath(), casted);
-                return casted;
-            }
-
-            ListNavigatorPtr ListNavigator::FromAronListPtr(const data::AronListPtr& aron)
-            {
-                return std::make_shared<ListNavigator>(aron);
-            }
-
-            data::AronListPtr ListNavigator::ToAronListPtr(const ListNavigatorPtr& navigator)
-            {
-                return navigator ? navigator->toAronListPtr() : nullptr;
-            }
-
-            // public member functions
-            void ListNavigator::addElement(const NavigatorPtr& n)
-            {
-                childrenNavigators.push_back(n);
-                aron->elements.push_back(n->getResult());
-            }
-
-            bool ListNavigator::hasElement(unsigned int i) const
-            {
-                return i < childrenNavigators.size();
-            }
-
-            NavigatorPtr ListNavigator::getElement(unsigned int i) const
-            {
-                if (i >= childrenNavigators.size())
-                {
-                    throw error::AronException("ListNavigator", "getElement", "The index i = " + std::to_string(i) + " is out of bounds (size = " + std::to_string(childrenNavigators.size()) + ")", getPath());
-                }
-                return childrenNavigators[i];
-            }
-
-            std::vector<NavigatorPtr> ListNavigator::getElements() const
-            {
-                return childrenNavigators;
-            }
-
-            void ListNavigator::clear()
-            {
-                childrenNavigators.clear();
-                aron->elements.clear();
-            }
-
-            data::AronListPtr ListNavigator::toAronListPtr() const
-            {
-                return aron;
-            }
-
-            // virtual implementations
-            data::AronDataPtr ListNavigator::getResult() const
-            {
-                return toAronListPtr();
-            }
-
-            std::string ListNavigator::getName() const
-            {
-                return "AronList";
-            }
-
-            typenavigator::NavigatorPtr ListNavigator::recalculateType() const
-            {
-                typenavigator::ListNavigatorPtr typenav = typenavigator::ListNavigatorPtr(new typenavigator::ListNavigator(getPath()));
+                typenavigator::TupleNavigatorPtr tupleTypeNav = typenavigator::TupleNavigator::DynamicCast(type);
                 unsigned int i = 0;
                 for (const auto& nav : childrenNavigators)
                 {
-                    if (typenav->getAcceptedType() == nullptr)
-                    {
-                        typenav->setAcceptedType(nav->recalculateType());
-                        continue;
-                    }
-
-                    if (!nav->fullfillsType(typenav->getAcceptedType()))
-                    {
-                        throw error::AronException("ListNavigator", "recalculateType", "Cannot recalculate the aronType. Inconsistency found for index: " + std::to_string(i), getPath());
-                    }
-                    ++i;
-                }
-                return typenav->getAcceptedType();
-            }
-
-            bool ListNavigator::fullfillsType(const typenavigator::NavigatorPtr& type) const
-            {
-                if (!Resolver::Correspond(type->getDescriptor(), getDescriptor()))
-                {
-                    return false;
-                }
-
-                type::Descriptor typeDesc = type->getDescriptor();
-                switch(typeDesc)
-                {
-                case type::eList:
-                {
-                    typenavigator::ListNavigatorPtr listTypeNav = typenavigator::ListNavigator::DynamicCast(type);
-                    for (const auto& nav : childrenNavigators)
-                    {
-                        if (!nav->fullfillsType(listTypeNav->getAcceptedType()))
-                        {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-                case type::eTuple:
-                {
-                    typenavigator::TupleNavigatorPtr tupleTypeNav = typenavigator::TupleNavigator::DynamicCast(type);
-                    unsigned int i = 0;
-                    for (const auto& nav : childrenNavigators)
-                    {
-                        if (!nav->fullfillsType(tupleTypeNav->getAcceptedType(i)))
-                        {
-                            return false;
-                        }
-                    }
-                    return true;
-                }
-                case type::ePair:
-                {
-                    typenavigator::PairNavigatorPtr pairTypeNav = typenavigator::PairNavigator::DynamicCast(type);
-                    if(childrenSize() != 2)
+                    if (!nav->fullfillsType(tupleTypeNav->getAcceptedType(i)))
                     {
                         return false;
                     }
-                    return childrenNavigators[0]->fullfillsType(pairTypeNav->getFirstAcceptedType()) && childrenNavigators[1]->fullfillsType(pairTypeNav->getSecondAcceptedType());
-                }
-                default:
-                    return false;
                 }
+                return true;
             }
-
-            std::vector<NavigatorPtr> ListNavigator::getChildren() const
-            {
-                return childrenNavigators;
-            }
-
-            size_t ListNavigator::childrenSize() const
-            {
-                return childrenNavigators.size();
-            }
-
-            NavigatorPtr ListNavigator::navigateAbsolute(const Path& path) const
+            case type::ePair:
             {
-                if (!path.hasElement())
+                typenavigator::PairNavigatorPtr pairTypeNav = typenavigator::PairNavigator::DynamicCast(type);
+                if (childrenSize() != 2)
                 {
-                    throw error::AronException("ListNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
-                }
-                unsigned int i = std::stoi(path.getFirstElement());
-                if (!hasElement(i))
-                {
-                    throw error::IndexNotValidException("ListNavigator", "navigate", "Could not find an element of a path.", i, childrenSize());
-                }
-
-                if (path.size() == 1)
-                {
-                    return childrenNavigators.at(i);
-                }
-                else
-                {
-                    Path next = path.withDetachedFirstElement();
-                    return childrenNavigators.at(i)->navigateAbsolute(next);
+                    return false;
                 }
+                return childrenNavigators[0]->fullfillsType(pairTypeNav->getFirstAcceptedType()) && childrenNavigators[1]->fullfillsType(pairTypeNav->getSecondAcceptedType());
             }
+            default:
+                return false;
+        }
+    }
+
+    std::vector<NavigatorPtr> ListNavigator::getChildren() const
+    {
+        return childrenNavigators;
+    }
+
+    size_t ListNavigator::childrenSize() const
+    {
+        return childrenNavigators.size();
+    }
+
+    NavigatorPtr ListNavigator::navigateAbsolute(const Path& path) const
+    {
+        if (!path.hasElement())
+        {
+            throw error::AronException("ListNavigator", "navigate", "Could not navigate without a valid path. The path was empty.");
+        }
+        unsigned int i = std::stoi(path.getFirstElement());
+        if (!hasElement(i))
+        {
+            throw error::IndexNotValidException("ListNavigator", "navigate", "Could not find an element of a path.", i, childrenSize());
+        }
 
-            NavigatorPtr ListNavigator::navigateRelative(const Path& path) const
-            {
-                Path absoluteFromHere = path.getWithoutPrefix(getPath());
-                return navigateAbsolute(absoluteFromHere);
-            }
+        if (path.size() == 1)
+        {
+            return childrenNavigators.at(i);
+        }
+        else
+        {
+            Path next = path.withDetachedFirstElement();
+            return childrenNavigators.at(i)->navigateAbsolute(next);
+        }
+    }
+
+    NavigatorPtr ListNavigator::navigateRelative(const Path& path) const
+    {
+        Path absoluteFromHere = path.getWithoutPrefix(getPath());
+        return navigateAbsolute(absoluteFromHere);
+    }
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.cpp b/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.cpp
index c5b3ea636c67aee8261abedba5099ba3a8f927ea..860b760ce31c864efcdd498c5e2dfa3c2f571c90 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.cpp
@@ -27,7 +27,7 @@
 #include <RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.h>
 
 namespace armarx::aron::datanavigator
-        {
+{
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
     /* constructors */ \
     upperType##Navigator::upperType##Navigator(const data::Aron##upperType##Ptr& o, const Path& path) : \
@@ -151,6 +151,6 @@ namespace armarx::aron::datanavigator
         return 0; \
     } \
 
-            HANDLE_PRIMITIVE_DATA
+    HANDLE_PRIMITIVE_DATA
 #undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.h b/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.h
index 195887d017be92fdd3cbeb36729d9c507834ef94..195ba609dff8b0b4b352a5c0a68ee8db0167e69b 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/data/primitive/Primitive.h
@@ -37,7 +37,7 @@ namespace armarx::aron::datanavigator
     class upperType##Navigator; \
     typedef std::shared_ptr<upperType##Navigator> upperType##NavigatorPtr;
 
-            HANDLE_PRIMITIVE_DATA
+    HANDLE_PRIMITIVE_DATA
 #undef RUN_ARON_MACRO
 
 
@@ -86,6 +86,6 @@ namespace armarx::aron::datanavigator
         data::Aron##upperType##Ptr aron; \
     };
 
-            HANDLE_PRIMITIVE_DATA
+    HANDLE_PRIMITIVE_DATA
 #undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp
index 83b72bf347b46624161b4e2133a049e261d09965..48d135200d0590e175128d771706b5d19d3bfa3a 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.cpp
@@ -35,7 +35,7 @@ namespace armarx::aron::typenavigator
     NavigatorPtr NavigatorFactory::create(const type::AronTypePtr& aron, const Path& path) const
     {
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-        {type::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
+    {type::e##upperType, NavigatorFactoryPtr(new upperType##NavigatorFactory())},
 
         static const std::map<type::Descriptor, NavigatorFactoryPtr> Factories =
         {
@@ -59,11 +59,11 @@ namespace armarx::aron::typenavigator
 
     // Factories
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
-NavigatorPtr upperType##NavigatorFactory::createSpecific(const type::AronTypePtr& aron, const Path& path) const \
-{ \
-type::Aron##upperType##Ptr aronCasted = type::Aron##upperType##Ptr::dynamicCast(aron); \
-return typenavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
-}
+    NavigatorPtr upperType##NavigatorFactory::createSpecific(const type::AronTypePtr& aron, const Path& path) const \
+    { \
+        type::Aron##upperType##Ptr aronCasted = type::Aron##upperType##Ptr::dynamicCast(aron); \
+        return typenavigator::NavigatorPtr(new upperType##Navigator(aronCasted, path)); \
+    }
 
     HANDLE_ALL_ARON_TYPES
 #undef RUN_ARON_MACRO
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h
index b3fcc82e470a335687de636fee0b515996a0229c..7e443cc3c02e19c7237bf8dd4a0bfa59ae7a82b8 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/NavigatorFactory.h
@@ -48,7 +48,7 @@ namespace armarx::aron::typenavigator
         virtual typenavigator::NavigatorPtr createSpecific(const type::AronTypePtr&, const Path&) const override;
     };
 
-            // Factories
+    // Factories
 #define RUN_ARON_MACRO(upperType, lowerType, capsType) \
     class upperType##NavigatorFactory : \
         virtual public NavigatorFactory \
@@ -58,7 +58,7 @@ namespace armarx::aron::typenavigator
         virtual typenavigator::NavigatorPtr createSpecific(const type::AronTypePtr&, const Path&) const override; \
     };
 
-            HANDLE_ALL_ARON_TYPES
+    HANDLE_ALL_ARON_TYPES
 #undef RUN_ARON_MACRO
 
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h b/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h
index c92d79874276b00cb9369556065dd7d010902981..08ba52beda2b7070032647ba035b69db75e26f84 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/container/Dict.h
@@ -32,39 +32,39 @@
 
 namespace armarx::aron::typenavigator
 {
-            class DictNavigator;
-            typedef std::shared_ptr<DictNavigator> DictNavigatorPtr;
+    class DictNavigator;
+    typedef std::shared_ptr<DictNavigator> DictNavigatorPtr;
 
-            class DictNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = DictNavigatorPtr;
+    class DictNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = DictNavigatorPtr;
 
-            public:
-                // constructors
-                DictNavigator(const Path& path = Path());
-                DictNavigator(const type::AronDictPtr&, const Path& path = Path());
+    public:
+        // constructors
+        DictNavigator(const Path& path = Path());
+        DictNavigator(const type::AronDictPtr&, const Path& path = Path());
 
-                NavigatorPtr getAcceptedType() const;
-                void setAcceptedType(const NavigatorPtr&);
+        NavigatorPtr getAcceptedType() const;
+        void setAcceptedType(const NavigatorPtr&);
 
-                type::AronDictPtr toAronDictPtr() const;
+        type::AronDictPtr toAronDictPtr() const;
 
-                // static methods
-                static DictNavigatorPtr DynamicCast(const NavigatorPtr& n);
-                static DictNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
+        // static methods
+        static DictNavigatorPtr DynamicCast(const NavigatorPtr& n);
+        static DictNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                virtual type::AronTypePtr getResult() const override;
-                virtual std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        virtual type::AronTypePtr getResult() const override;
+        virtual std::string getName() const override;
 
-            private:
-                // members
-                NavigatorPtr acceptedType;
-                type::AronDictPtr type;
+    private:
+        // members
+        NavigatorPtr acceptedType;
+        type::AronDictPtr type;
 
-            };
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h b/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h
index dfb38b2952867c358a4549970c2a883f5fcf5cf3..2dac8bebb527e77f3a9e6d039a08c72fa2486b53 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/container/List.h
@@ -32,38 +32,38 @@
 
 namespace armarx::aron::typenavigator
 {
-            class ListNavigator;
-            typedef std::shared_ptr<ListNavigator> ListNavigatorPtr;
+    class ListNavigator;
+    typedef std::shared_ptr<ListNavigator> ListNavigatorPtr;
 
-            class ListNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = ListNavigatorPtr;
+    class ListNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = ListNavigatorPtr;
 
-            public:
-                // constructors
-                ListNavigator(const Path& path = Path());
-                ListNavigator(const type::AronListPtr&, const Path& path = Path());
+    public:
+        // constructors
+        ListNavigator(const Path& path = Path());
+        ListNavigator(const type::AronListPtr&, const Path& path = Path());
 
-                NavigatorPtr getAcceptedType() const;
-                void setAcceptedType(const NavigatorPtr&);
+        NavigatorPtr getAcceptedType() const;
+        void setAcceptedType(const NavigatorPtr&);
 
-                type::AronListPtr toAronListPtr() const;
+        type::AronListPtr toAronListPtr() const;
 
-                // static methods
-                static ListNavigatorPtr DynamicCast(const NavigatorPtr& n);
-                static ListNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
+        // static methods
+        static ListNavigatorPtr DynamicCast(const NavigatorPtr& n);
+        static ListNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                virtual type::AronTypePtr getResult() const override;
-                virtual std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        virtual type::AronTypePtr getResult() const override;
+        virtual std::string getName() const override;
 
-            private:
-                // members
-                NavigatorPtr acceptedType;
-                type::AronListPtr type;
-            };
+    private:
+        // members
+        NavigatorPtr acceptedType;
+        type::AronListPtr type;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp
index d1699d1e737aa72600e23009e84567a60172ed33..14a94b890106d5daa688b4e120eff978b32199cc 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/container/Tuple.cpp
@@ -26,93 +26,93 @@
 
 
 namespace armarx::aron::typenavigator
+{
+    // constructors
+    TupleNavigator::TupleNavigator(const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path),
+        Navigator(type::Descriptor::eTuple, path),
+        type(new type::AronTuple())
+    {
+    }
+
+    TupleNavigator::TupleNavigator(const type::AronTuplePtr& o, const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path),
+        Navigator(type::Descriptor::eTuple, path),
+        type(o)
+    {
+        CheckAronPtrForNull("TupleNavigator", "TupleNavigator", getPath(), o);
+
+        for (const auto& t : type->elementTypes)
         {
-            // constructors
-            TupleNavigator::TupleNavigator(const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path),
-                Navigator(type::Descriptor::eTuple, path),
-                type(new type::AronTuple())
-            {
-            }
-
-            TupleNavigator::TupleNavigator(const type::AronTuplePtr& o, const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eTuple, path),
-                Navigator(type::Descriptor::eTuple, path),
-                type(o)
-            {
-                CheckAronPtrForNull("TupleNavigator", "TupleNavigator", getPath(), o);
-
-                for (const auto& t : type->elementTypes)
-                {
-                    acceptedTypes.push_back(FromAronType(t));
-                }
-            }
-
-            type::AronTuplePtr TupleNavigator::toAronTuplePtr() const
-            {
-                if (acceptedTypes.empty())
-                {
-                    throw error::AronException("TupleNavigator", "getCastedResult", "No accepted types set", getPath());
-                }
-                return type;
-            }
-
-            // static methods
-            TupleNavigatorPtr TupleNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                return std::dynamic_pointer_cast<TupleNavigator>(n);
-            }
-
-            TupleNavigatorPtr TupleNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckTypeNavigatorPtrForNull("TupleNavigator", "DynamicCast[Before]", n);
-                TupleNavigatorPtr casted = TupleNavigator::DynamicCast(n);
-                CheckTypeNavigatorPtrForNull("TupleNavigator", "DynamicCast[After]", n->getPath(), casted);
-                return casted;
-            }
-
-            // public member functions
-            std::vector<NavigatorPtr> TupleNavigator::getAcceptedTypes() const
-            {
-                return acceptedTypes;
-            }
-
-            NavigatorPtr TupleNavigator::getAcceptedType(unsigned int i) const
-            {
-                return acceptedTypes[i];
-            }
-
-            void TupleNavigator::addAcceptedType(const NavigatorPtr& v)
-            {
-                CheckTypeNavigatorPtrForNull("TupleNavigator", "addAcceptedType", getPath(), v);
-                type->elementTypes.push_back(v->getResult());
-                acceptedTypes.push_back(v);
-            }
-
-            // virtual implementations
-            std::vector<NavigatorPtr> TupleNavigator::getChildren() const
-            {
-                return acceptedTypes;
-            }
-
-            size_t TupleNavigator::childrenSize() const
-            {
-                return acceptedTypes.size();
-            }
-
-            type::AronTypePtr TupleNavigator::getResult() const
-            {
-                return toAronTuplePtr();
-            }
-
-            std::string TupleNavigator::getName() const
-            {
-                std::vector<std::string> names;
-                for (const auto& n : acceptedTypes)
-                {
-                    names.push_back(n->getName());
-                }
-                return "AronTupleType<" + simox::alg::to_string(names, ", ") + ">";
-            }
+            acceptedTypes.push_back(FromAronType(t));
+        }
+    }
+
+    type::AronTuplePtr TupleNavigator::toAronTuplePtr() const
+    {
+        if (acceptedTypes.empty())
+        {
+            throw error::AronException("TupleNavigator", "getCastedResult", "No accepted types set", getPath());
+        }
+        return type;
+    }
+
+    // static methods
+    TupleNavigatorPtr TupleNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        return std::dynamic_pointer_cast<TupleNavigator>(n);
+    }
+
+    TupleNavigatorPtr TupleNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckTypeNavigatorPtrForNull("TupleNavigator", "DynamicCast[Before]", n);
+        TupleNavigatorPtr casted = TupleNavigator::DynamicCast(n);
+        CheckTypeNavigatorPtrForNull("TupleNavigator", "DynamicCast[After]", n->getPath(), casted);
+        return casted;
+    }
+
+    // public member functions
+    std::vector<NavigatorPtr> TupleNavigator::getAcceptedTypes() const
+    {
+        return acceptedTypes;
+    }
+
+    NavigatorPtr TupleNavigator::getAcceptedType(unsigned int i) const
+    {
+        return acceptedTypes[i];
+    }
+
+    void TupleNavigator::addAcceptedType(const NavigatorPtr& v)
+    {
+        CheckTypeNavigatorPtrForNull("TupleNavigator", "addAcceptedType", getPath(), v);
+        type->elementTypes.push_back(v->getResult());
+        acceptedTypes.push_back(v);
+    }
+
+    // virtual implementations
+    std::vector<NavigatorPtr> TupleNavigator::getChildren() const
+    {
+        return acceptedTypes;
+    }
+
+    size_t TupleNavigator::childrenSize() const
+    {
+        return acceptedTypes.size();
+    }
+
+    type::AronTypePtr TupleNavigator::getResult() const
+    {
+        return toAronTuplePtr();
+    }
+
+    std::string TupleNavigator::getName() const
+    {
+        std::vector<std::string> names;
+        for (const auto& n : acceptedTypes)
+        {
+            names.push_back(n->getName());
+        }
+        return "AronTupleType<" + simox::alg::to_string(names, ", ") + ">";
+    }
 }
 
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp
index b2e4e740c82d21389806eff5ba6cc109823a5d96..682a177ea6ab823e7a1ee7b0a2372eb95054d837 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/enum/IntEnum.cpp
@@ -51,7 +51,7 @@ namespace armarx::aron::typenavigator
     {
         for (const auto& [k, v] : type->acceptedValues)
         {
-            if(v == i)
+            if (v == i)
             {
                 return k;
             }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h
index d4bd2af6668045e81a601cd98aa8c40ac21e63ef..0fb7d9a71bd21a96b024ee3eb5cec9f231216fd6 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenMatrix.h
@@ -32,61 +32,61 @@
 
 namespace armarx::aron::typenavigator
 {
-            class EigenMatrixNavigator;
-            typedef std::shared_ptr<EigenMatrixNavigator> EigenMatrixNavigatorPtr;
+    class EigenMatrixNavigator;
+    typedef std::shared_ptr<EigenMatrixNavigator> EigenMatrixNavigatorPtr;
 
-            class EigenMatrixNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = EigenMatrixNavigatorPtr;
+    class EigenMatrixNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = EigenMatrixNavigatorPtr;
 
-            public:
-                // constructors
-                EigenMatrixNavigator() = delete;
-                EigenMatrixNavigator(const Path& path);
-                EigenMatrixNavigator(const type::AronEigenMatrixPtr&, const Path& path);
+    public:
+        // constructors
+        EigenMatrixNavigator() = delete;
+        EigenMatrixNavigator(const Path& path);
+        EigenMatrixNavigator(const type::AronEigenMatrixPtr&, const Path& path);
 
-                bool checkDimensions(const std::vector<int>&) const;
-                bool checkTypename(const std::string&) const;
+        bool checkDimensions(const std::vector<int>&) const;
+        bool checkTypename(const std::string&) const;
 
-                unsigned int getRows() const;
-                unsigned int getCols() const;
-                std::string getTypename() const;
-                std::vector<int> getDimensions() const;
+        unsigned int getRows() const;
+        unsigned int getCols() const;
+        std::string getTypename() const;
+        std::vector<int> getDimensions() const;
 
-                void setRows(const unsigned int&);
-                void setCols(const unsigned int&);
-                void setTypename(const std::string&);
-                void setDimensions(const std::vector<int>&);
+        void setRows(const unsigned int&);
+        void setCols(const unsigned int&);
+        void setTypename(const std::string&);
+        void setDimensions(const std::vector<int>&);
 
-                type::AronEigenMatrixPtr toAronEigenMatrixPtr() const;
+        type::AronEigenMatrixPtr toAronEigenMatrixPtr() const;
 
-                // static methods
-                static EigenMatrixNavigatorPtr DynamicCast(const NavigatorPtr& n);
-                static EigenMatrixNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
+        // static methods
+        static EigenMatrixNavigatorPtr DynamicCast(const NavigatorPtr& n);
+        static EigenMatrixNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                virtual type::AronTypePtr getResult() const override;
-                virtual std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        virtual type::AronTypePtr getResult() const override;
+        virtual std::string getName() const override;
 
-            public:
-                const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
-                {
-                    {"short", {}},
-                    {"int", {}},
-                    {"long", {}},
-                    {"float", {}},
-                    {"double", {}},
-                    //{"complex float", {"std::complex<float>"}},
-                    //{"complex double", {"std::complex<double>"}},
-                };
-                const unsigned int ACCEPTED_DIMENSION_MIN_SIZE = 2;
+    public:
+        const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
+        {
+            {"short", {}},
+            {"int", {}},
+            {"long", {}},
+            {"float", {}},
+            {"double", {}},
+            //{"complex float", {"std::complex<float>"}},
+            //{"complex double", {"std::complex<double>"}},
+        };
+        const unsigned int ACCEPTED_DIMENSION_MIN_SIZE = 2;
 
-            private:
-                // members
-                type::AronEigenMatrixPtr type;
-            };
+    private:
+        // members
+        type::AronEigenMatrixPtr type;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h
index d450e19bd8a741e6f973fe9ca0ebb0b2a384523f..1f388fdf5e75b3e58a962025e55cd038ad2b9394 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/EigenQuaternion.h
@@ -32,50 +32,50 @@
 
 namespace armarx::aron::typenavigator
 {
-            class EigenQuaternionNavigator;
-            typedef std::shared_ptr<EigenQuaternionNavigator> EigenQuaternionNavigatorPtr;
+    class EigenQuaternionNavigator;
+    typedef std::shared_ptr<EigenQuaternionNavigator> EigenQuaternionNavigatorPtr;
 
-            class EigenQuaternionNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = EigenQuaternionNavigatorPtr;
+    class EigenQuaternionNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = EigenQuaternionNavigatorPtr;
 
-            public:
-                // constructors
-                EigenQuaternionNavigator() = delete;
-                EigenQuaternionNavigator(const Path& path);
-                EigenQuaternionNavigator(const type::AronEigenQuaternionPtr&, const Path& path);
+    public:
+        // constructors
+        EigenQuaternionNavigator() = delete;
+        EigenQuaternionNavigator(const Path& path);
+        EigenQuaternionNavigator(const type::AronEigenQuaternionPtr&, const Path& path);
 
-                bool checkTypename(const std::string&) const;
+        bool checkTypename(const std::string&) const;
 
-                std::string getTypename() const;
-                std::vector<int> getDimensions() const;
+        std::string getTypename() const;
+        std::vector<int> getDimensions() const;
 
-                void setTypename(const std::string&);
+        void setTypename(const std::string&);
 
-                type::AronEigenQuaternionPtr toAronEigenQuaternionPtr() const;
+        type::AronEigenQuaternionPtr toAronEigenQuaternionPtr() const;
 
-                // static methods
-                static EigenQuaternionNavigatorPtr DynamicCast(const NavigatorPtr& n);
-                static EigenQuaternionNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
+        // static methods
+        static EigenQuaternionNavigatorPtr DynamicCast(const NavigatorPtr& n);
+        static EigenQuaternionNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                virtual type::AronTypePtr getResult() const override;
-                virtual std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        virtual type::AronTypePtr getResult() const override;
+        virtual std::string getName() const override;
 
-            public:
-                const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
-                {
-                    {"float", {}},
-                    {"double", {}}
-                };
-                const std::vector<int> ACCEPTED_DIMENSION = {1, 4};
+    public:
+        const std::map<std::string, std::vector<std::string>> ACCEPTED_TYPES =
+        {
+            {"float", {}},
+            {"double", {}}
+        };
+        const std::vector<int> ACCEPTED_DIMENSION = {1, 4};
 
-            private:
-                // members
-                type::AronEigenQuaternionPtr type;
-            };
+    private:
+        // members
+        type::AronEigenQuaternionPtr type;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp
index d37436d764cd3bce392a47053e29dc652a002ea7..13be796db0958e73425151df684488dbcc49d86e 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Orientation.cpp
@@ -25,71 +25,71 @@
 #include "Orientation.h"
 
 namespace armarx::aron::typenavigator
-        {
-            // constructors
-            OrientationNavigator::OrientationNavigator(const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path),
-                Navigator(type::Descriptor::eOrientation, path),
-                type(new type::AronOrientation())
-            {
-            }
+{
+    // constructors
+    OrientationNavigator::OrientationNavigator(const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path),
+        Navigator(type::Descriptor::eOrientation, path),
+        type(new type::AronOrientation())
+    {
+    }
 
-            OrientationNavigator::OrientationNavigator(const type::AronOrientationPtr& o, const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path),
-                Navigator(type::Descriptor::eOrientation, path),
-                type(o)
-            {
-                CheckAronPtrForNull("AronOrientationTypeNavigator", "AronOrientationTypeNavigator", getPath(), o);
-            }
+    OrientationNavigator::OrientationNavigator(const type::AronOrientationPtr& o, const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::eOrientation, path),
+        Navigator(type::Descriptor::eOrientation, path),
+        type(o)
+    {
+        CheckAronPtrForNull("AronOrientationTypeNavigator", "AronOrientationTypeNavigator", getPath(), o);
+    }
 
-            type::AronOrientationPtr OrientationNavigator::toAronOrientationPtr() const
-            {
-                return type;
-            }
+    type::AronOrientationPtr OrientationNavigator::toAronOrientationPtr() const
+    {
+        return type;
+    }
 
-            std::vector<int> OrientationNavigator::getDimensions() const
-            {
-                return ACCEPTED_DIMENSION;
-            }
+    std::vector<int> OrientationNavigator::getDimensions() const
+    {
+        return ACCEPTED_DIMENSION;
+    }
 
-            std::string OrientationNavigator::getTypename() const
-            {
-                return ACCEPTED_TYPE;
-            }
+    std::string OrientationNavigator::getTypename() const
+    {
+        return ACCEPTED_TYPE;
+    }
 
-            // static methods
-            OrientationNavigatorPtr OrientationNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                return std::dynamic_pointer_cast<OrientationNavigator>(n);
-            }
+    // static methods
+    OrientationNavigatorPtr OrientationNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        return std::dynamic_pointer_cast<OrientationNavigator>(n);
+    }
 
-            OrientationNavigatorPtr OrientationNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckTypeNavigatorPtrForNull("AronOrientationTypeNavigator", "DynamicCast[Before]", n);
-                OrientationNavigatorPtr casted = OrientationNavigator::DynamicCast(n);
-                CheckTypeNavigatorPtrForNull("AronOrientationTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
-                return casted;
-            }
+    OrientationNavigatorPtr OrientationNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckTypeNavigatorPtrForNull("AronOrientationTypeNavigator", "DynamicCast[Before]", n);
+        OrientationNavigatorPtr casted = OrientationNavigator::DynamicCast(n);
+        CheckTypeNavigatorPtrForNull("AronOrientationTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
+        return casted;
+    }
 
-            // virtual implementations
-            std::vector<NavigatorPtr> OrientationNavigator::getChildren() const
-            {
-                return {};
-            }
+    // virtual implementations
+    std::vector<NavigatorPtr> OrientationNavigator::getChildren() const
+    {
+        return {};
+    }
 
-            size_t OrientationNavigator::childrenSize() const
-            {
-                return 0;
-            }
+    size_t OrientationNavigator::childrenSize() const
+    {
+        return 0;
+    }
 
-            type::AronTypePtr OrientationNavigator::getResult() const
-            {
-                return toAronOrientationPtr();
-            }
+    type::AronTypePtr OrientationNavigator::getResult() const
+    {
+        return toAronOrientationPtr();
+    }
 
-            std::string OrientationNavigator::getName() const
-            {
-                return "AronOrientationType";
-            }
+    std::string OrientationNavigator::getName() const
+    {
+        return "AronOrientationType";
+    }
 }
 
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp
index 830c3550ec5560ca212e2a01a3538a6371cb1b9a..8713907ec36228dced593baf15dcef2f35d30cd8 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.cpp
@@ -25,71 +25,71 @@
 #include "Pose.h"
 
 namespace armarx::aron::typenavigator
-        {
-            // constructors
-            PoseNavigator::PoseNavigator(const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path),
-                Navigator(type::Descriptor::ePose, path),
-                type(new type::AronPose())
-            {
-            }
+{
+    // constructors
+    PoseNavigator::PoseNavigator(const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path),
+        Navigator(type::Descriptor::ePose, path),
+        type(new type::AronPose())
+    {
+    }
 
-            PoseNavigator::PoseNavigator(const type::AronPosePtr& o, const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path),
-                Navigator(type::Descriptor::ePose, path),
-                type(o)
-            {
-                CheckAronPtrForNull("AronPoseTypeNavigator", "AronPoseTypeNavigator", getPath(), o);
-            }
+    PoseNavigator::PoseNavigator(const type::AronPosePtr& o, const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePose, path),
+        Navigator(type::Descriptor::ePose, path),
+        type(o)
+    {
+        CheckAronPtrForNull("AronPoseTypeNavigator", "AronPoseTypeNavigator", getPath(), o);
+    }
 
-            type::AronPosePtr PoseNavigator::toAronPosePtr() const
-            {
-                return type;
-            }
+    type::AronPosePtr PoseNavigator::toAronPosePtr() const
+    {
+        return type;
+    }
 
-            std::vector<int> PoseNavigator::getDimensions() const
-            {
-                return ACCEPTED_DIMENSION;
-            }
+    std::vector<int> PoseNavigator::getDimensions() const
+    {
+        return ACCEPTED_DIMENSION;
+    }
 
-            std::string PoseNavigator::getTypename() const
-            {
-                return ACCEPTED_TYPE;
-            }
+    std::string PoseNavigator::getTypename() const
+    {
+        return ACCEPTED_TYPE;
+    }
 
-            // static methods
-            PoseNavigatorPtr PoseNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                return std::dynamic_pointer_cast<PoseNavigator>(n);
-            }
+    // static methods
+    PoseNavigatorPtr PoseNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        return std::dynamic_pointer_cast<PoseNavigator>(n);
+    }
 
-            PoseNavigatorPtr PoseNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckTypeNavigatorPtrForNull("AronPoseTypeNavigator", "DynamicCast[Before]", n);
-                PoseNavigatorPtr casted = PoseNavigator::DynamicCast(n);
-                CheckTypeNavigatorPtrForNull("AronPoseTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
-                return casted;
-            }
+    PoseNavigatorPtr PoseNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckTypeNavigatorPtrForNull("AronPoseTypeNavigator", "DynamicCast[Before]", n);
+        PoseNavigatorPtr casted = PoseNavigator::DynamicCast(n);
+        CheckTypeNavigatorPtrForNull("AronPoseTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
+        return casted;
+    }
 
-            // virtual implementations
-            std::vector<NavigatorPtr> PoseNavigator::getChildren() const
-            {
-                return {};
-            }
+    // virtual implementations
+    std::vector<NavigatorPtr> PoseNavigator::getChildren() const
+    {
+        return {};
+    }
 
-            size_t PoseNavigator::childrenSize() const
-            {
-                return 0;
-            }
+    size_t PoseNavigator::childrenSize() const
+    {
+        return 0;
+    }
 
-            type::AronTypePtr PoseNavigator::getResult() const
-            {
-                return toAronPosePtr();
-            }
+    type::AronTypePtr PoseNavigator::getResult() const
+    {
+        return toAronPosePtr();
+    }
 
-            std::string PoseNavigator::getName() const
-            {
-                return "AronPoseType";
-            }
+    std::string PoseNavigator::getName() const
+    {
+        return "AronPoseType";
+    }
 }
 
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h
index c109c2a89b9738bc5c07c5f47d5f66dbdccfea6d..e99d0ea3bd3ac35bbbbfe1b8e493d5ae8eafb1bf 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Pose.h
@@ -32,41 +32,41 @@
 
 namespace armarx::aron::typenavigator
 {
-            class PoseNavigator;
-            typedef std::shared_ptr<PoseNavigator> PoseNavigatorPtr;
+    class PoseNavigator;
+    typedef std::shared_ptr<PoseNavigator> PoseNavigatorPtr;
 
-            class PoseNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = PoseNavigatorPtr;
+    class PoseNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = PoseNavigatorPtr;
 
-            public:
-                // constructors
-                PoseNavigator(const Path& path = Path());
-                PoseNavigator(const type::AronPosePtr&, const Path& path = Path());
+    public:
+        // constructors
+        PoseNavigator(const Path& path = Path());
+        PoseNavigator(const type::AronPosePtr&, const Path& path = Path());
 
-                std::string getTypename() const;
-                std::vector<int> getDimensions() const;
+        std::string getTypename() const;
+        std::vector<int> getDimensions() const;
 
-                type::AronPosePtr toAronPosePtr() const;
+        type::AronPosePtr toAronPosePtr() const;
 
-                // static methods
-                static PoseNavigatorPtr DynamicCast(const NavigatorPtr& n);
-                static PoseNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
+        // static methods
+        static PoseNavigatorPtr DynamicCast(const NavigatorPtr& n);
+        static PoseNavigatorPtr DynamicCastAndCheck(const NavigatorPtr& n);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                virtual type::AronTypePtr getResult() const override;
-                virtual std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        virtual type::AronTypePtr getResult() const override;
+        virtual std::string getName() const override;
 
-            public:
-                const std::string ACCEPTED_TYPE = "float";
-                const std::vector<int> ACCEPTED_DIMENSION = {4, 4};
+    public:
+        const std::string ACCEPTED_TYPE = "float";
+        const std::vector<int> ACCEPTED_DIMENSION = {4, 4};
 
-            private:
-                // members
-                type::AronPosePtr type;
-            };
+    private:
+        // members
+        type::AronPosePtr type;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp
index d81efd888bbc1081fa5f3c484c3229514183862e..2172f431b17cbcad41704c1933e78f31758b4ca8 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.cpp
@@ -25,71 +25,71 @@
 #include "Position.h"
 
 namespace armarx::aron::typenavigator
-        {
-            // constructors
-            PositionNavigator::PositionNavigator(const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path),
-                Navigator(type::Descriptor::ePosition, path),
-                type(new type::AronPosition())
-            {
-            }
+{
+    // constructors
+    PositionNavigator::PositionNavigator(const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path),
+        Navigator(type::Descriptor::ePosition, path),
+        type(new type::AronPosition())
+    {
+    }
 
-            PositionNavigator::PositionNavigator(const type::AronPositionPtr& o, const Path& path) :
-                aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path),
-                Navigator(type::Descriptor::ePosition, path),
-                type(o)
-            {
-                CheckAronPtrForNull("AronPositionTypeNavigator", "AronPositionTypeNavigator", getPath(), o);
-            }
+    PositionNavigator::PositionNavigator(const type::AronPositionPtr& o, const Path& path) :
+        aron::Navigator<type::Descriptor, type::AronType>::Navigator(type::Descriptor::ePosition, path),
+        Navigator(type::Descriptor::ePosition, path),
+        type(o)
+    {
+        CheckAronPtrForNull("AronPositionTypeNavigator", "AronPositionTypeNavigator", getPath(), o);
+    }
 
-            type::AronPositionPtr PositionNavigator::toAronPositionPtr() const
-            {
-                return type;
-            }
+    type::AronPositionPtr PositionNavigator::toAronPositionPtr() const
+    {
+        return type;
+    }
 
-            std::vector<int> PositionNavigator::getDimensions() const
-            {
-                return ACCEPTED_DIMENSION;
-            }
+    std::vector<int> PositionNavigator::getDimensions() const
+    {
+        return ACCEPTED_DIMENSION;
+    }
 
-            std::string PositionNavigator::getTypename() const
-            {
-                return ACCEPTED_TYPE;
-            }
+    std::string PositionNavigator::getTypename() const
+    {
+        return ACCEPTED_TYPE;
+    }
 
-            // static methods
-            PositionNavigatorPtr PositionNavigator::DynamicCast(const NavigatorPtr& n)
-            {
-                return std::dynamic_pointer_cast<PositionNavigator>(n);
-            }
+    // static methods
+    PositionNavigatorPtr PositionNavigator::DynamicCast(const NavigatorPtr& n)
+    {
+        return std::dynamic_pointer_cast<PositionNavigator>(n);
+    }
 
-            PositionNavigatorPtr PositionNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
-            {
-                CheckTypeNavigatorPtrForNull("AronPositionTypeNavigator", "DynamicCast[Before]", n);
-                PositionNavigatorPtr casted = PositionNavigator::DynamicCast(n);
-                CheckTypeNavigatorPtrForNull("AronPositionTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
-                return casted;
-            }
+    PositionNavigatorPtr PositionNavigator::DynamicCastAndCheck(const NavigatorPtr& n)
+    {
+        CheckTypeNavigatorPtrForNull("AronPositionTypeNavigator", "DynamicCast[Before]", n);
+        PositionNavigatorPtr casted = PositionNavigator::DynamicCast(n);
+        CheckTypeNavigatorPtrForNull("AronPositionTypeNavigator", "DynamicCast[After]", n->getPath(), casted);
+        return casted;
+    }
 
-            // virtual implementations
-            std::vector<NavigatorPtr> PositionNavigator::getChildren() const
-            {
-                return {};
-            }
+    // virtual implementations
+    std::vector<NavigatorPtr> PositionNavigator::getChildren() const
+    {
+        return {};
+    }
 
-            size_t PositionNavigator::childrenSize() const
-            {
-                return 0;
-            }
+    size_t PositionNavigator::childrenSize() const
+    {
+        return 0;
+    }
 
-            type::AronTypePtr PositionNavigator::getResult() const
-            {
-                return toAronPositionPtr();
-            }
+    type::AronTypePtr PositionNavigator::getResult() const
+    {
+        return toAronPositionPtr();
+    }
 
-            std::string PositionNavigator::getName() const
-            {
-                return "AronPositionType";
-            }
+    std::string PositionNavigator::getName() const
+    {
+        return "AronPositionType";
+    }
 }
 
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h
index 16361d61de4122ba8f40be5c941061df5737e30f..c6a1d0f731a4d068be041efebc79907d6a1f4a87 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/ndarray/Position.h
@@ -32,41 +32,41 @@
 
 namespace armarx::aron::typenavigator
 {
-            class PositionNavigator;
-            typedef std::shared_ptr<PositionNavigator> PositionNavigatorPtr;
+    class PositionNavigator;
+    typedef std::shared_ptr<PositionNavigator> PositionNavigatorPtr;
 
-            class PositionNavigator :
-                virtual public Navigator
-            {
-            public:
-                using PointerType = PositionNavigatorPtr;
+    class PositionNavigator :
+        virtual public Navigator
+    {
+    public:
+        using PointerType = PositionNavigatorPtr;
 
-            public:
-                // constructors
-                PositionNavigator(const Path& path = Path());
-                PositionNavigator(const type::AronPositionPtr&, const Path& path = Path());
+    public:
+        // constructors
+        PositionNavigator(const Path& path = Path());
+        PositionNavigator(const type::AronPositionPtr&, const Path& path = Path());
 
-                std::string getTypename() const;
-                std::vector<int> getDimensions() const;
+        std::string getTypename() const;
+        std::vector<int> getDimensions() const;
 
-                type::AronPositionPtr toAronPositionPtr() const;
+        type::AronPositionPtr toAronPositionPtr() const;
 
-                // static methods
-                static PositionNavigatorPtr DynamicCast(const NavigatorPtr&);
-                static PositionNavigatorPtr DynamicCastAndCheck(const NavigatorPtr&);
+        // static methods
+        static PositionNavigatorPtr DynamicCast(const NavigatorPtr&);
+        static PositionNavigatorPtr DynamicCastAndCheck(const NavigatorPtr&);
 
-                // virtual implementations
-                virtual std::vector<NavigatorPtr> getChildren() const override;
-                virtual size_t childrenSize() const override;
-                type::AronTypePtr getResult() const override;
-                std::string getName() const override;
+        // virtual implementations
+        virtual std::vector<NavigatorPtr> getChildren() const override;
+        virtual size_t childrenSize() const override;
+        type::AronTypePtr getResult() const override;
+        std::string getName() const override;
 
-            public:
-                const std::string ACCEPTED_TYPE = "float";
-                const std::vector<int> ACCEPTED_DIMENSION = {3, 1};
+    public:
+        const std::string ACCEPTED_TYPE = "float";
+        const std::vector<int> ACCEPTED_DIMENSION = {3, 1};
 
-            private:
-                // members
-                type::AronPositionPtr type;
-            };
+    private:
+        // members
+        type::AronPositionPtr type;
+    };
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.cpp b/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.cpp
index 94ecf88a70c86df542590009baed8b0d9b1d5e13..bebe319697f9809815cdaa7fad247c247604499b 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.cpp
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.cpp
@@ -91,6 +91,6 @@ namespace armarx::aron::typenavigator
         return "type::Aron" + std::string(#upperType); \
     }
 
-            HANDLE_PRIMITIVE_TYPES
+    HANDLE_PRIMITIVE_TYPES
 #undef RUN_ARON_MACRO
 }
diff --git a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.h b/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.h
index 5b2fbee827d6046c50f17b8803e6456ee01395a5..9fe2fadf5f510f89be02ac3505351f61a63a8f23 100644
--- a/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.h
+++ b/source/RobotAPI/libraries/aron/core/navigator/type/primitive/Primitive.h
@@ -65,6 +65,6 @@ namespace armarx::aron::typenavigator
         type::Aron##upperType##Ptr type; \
     };
 
-            HANDLE_PRIMITIVE_TYPES
+    HANDLE_PRIMITIVE_TYPES
 #undef RUN_ARON_MACRO
 }