Update & fix RemoteGuiAronDataVisitor

source/RobotAPI/libraries/armem/component/RemoteGuiAronDataVisitor.cpp

 #include "RemoteGuiAronDataVisitor.h"
 
+#include <SimoxUtility/algorithm/string.h>
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
 
 namespace armarx::armem
 {
 
+    RemoteGuiAronDataVisitor::Group::Group(const std::string& label)
+    {
+        groupBox.setLabel(label);
+        groupBox.addChild(layout);
+    }
+
     RemoteGuiAronDataVisitor::~RemoteGuiAronDataVisitor()
     {}
 
-    bool RemoteGuiAronDataVisitor::visitEnter()
+    bool RemoteGuiAronDataVisitor::visitEnter(const std::string& key, const std::string& type, size_t size)
     {
-        groups.push(GroupBox());
+        std::stringstream label;
+        label << key << " (" << type << " of size " << size << ")";
+        Group& group = groups.emplace(label.str());
+        (void) group;
         return true;
     }
 
     bool RemoteGuiAronDataVisitor::visitExit()
     {
-        GroupBox group = groups.top();
+        Group group = groups.top();
         groups.pop();
         if (groups.size() > 0)
         {
-            groups.top().addChild(group);
+            groups.top().groupBox.addChild(group.groupBox);
         }
         else
         {
-            result = group;
+            result = group.groupBox;
         }
         return true;
     }
@@ -35,9 +48,16 @@ namespace armarx::armem
 
     void RemoteGuiAronDataVisitor::streamValueText(AronNDArrayDataNavigator& n, std::stringstream& ss)
     {
-        // No useful data in n
-        (void) n;
-        ss << "<NdArray>";
+        ss << "shape (" << simox::alg::join(simox::alg::multi_to_string(n.getDimensions()), ", ") << ")";
+    }
+
+    void RemoteGuiAronDataVisitor::checkGroupsNotEmpty() const
+    {
+        ARMARX_CHECK_POSITIVE(groups.size()) << "Groups must not be empty.";
     }
 
+
+
+
+
 }

source/RobotAPI/libraries/armem/component/RemoteGuiAronDataVisitor.h

@@ -16,77 +16,87 @@ namespace armarx::armem
     struct RemoteGuiAronDataVisitor : public aron::visitor::AronDataVisitor
     {
         using GroupBox = armarx::RemoteGui::Client::GroupBox;
+        using GridLayout = armarx::RemoteGui::Client::GridLayout;
         using Label = armarx::RemoteGui::Client::Label;
 
-        std::stack<GroupBox> groups;
+
+        struct Group
+        {
+            Group(const std::string& label = {});
+
+            GroupBox groupBox;
+            GridLayout layout;
+            int nextRow = 0;
+        };
+
+        std::stack<Group> groups;
         GroupBox result;
 
 
         virtual ~RemoteGuiAronDataVisitor() override;
 
 
-        bool visitEnter(AronDictDataNavigator&) override
+        bool visitEnter(const std::string& key, AronDictDataNavigator& n) override
         {
-            return visitEnter();
+            return visitEnter(key, "dict", n.childrenSize());
         }
         bool visitExit(AronDictDataNavigator&) override
         {
             return visitExit();
         }
 
-        bool visitEnter(AronListDataNavigator& list) override
+        bool visitEnter(const std::string& key, AronListDataNavigator& n) override
         {
-            (void) list;
-            // ARMARX_INFO << "- List Enter (path: '" << list.getPath().toString() << "')";
-            return visitEnter();
+            return visitEnter(key, "list", n.childrenSize());
         }
-        bool visitExit(AronListDataNavigator& list) override
+        bool visitExit(AronListDataNavigator&) override
         {
-            (void) list;
-            // ARMARX_INFO << "- List Exit (path: '" << list.getPath().toString() << "')";
             return visitExit();
         }
 
         // Same for Dict and List
-        bool visitEnter();
+        bool visitEnter(const std::string& key, const std::string& type, size_t size);
         bool visitExit();
 
+        // Do not hide base overloads.
+        using AronDataVisitor::visitEnter;
+        using AronDataVisitor::visitExit;
 
-        bool visit(AronBoolDataNavigator& b) override
+
+        bool visit(const std::string& key, AronBoolDataNavigator& b) override
         {
-            this->addValueLabel(b, "bool");
+            this->addValueLabel(key, b, "bool");
             return true;
         }
-        bool visit(AronDoubleDataNavigator& d) override
+        bool visit(const std::string& key, AronDoubleDataNavigator& d) override
         {
-            this->addValueLabel(d, "double");
+            this->addValueLabel(key, d, "double");
             return true;
         }
-        bool visit(AronFloatDataNavigator& f) override
+        bool visit(const std::string& key, AronFloatDataNavigator& f) override
         {
-            this->addValueLabel(f, "float");
+            this->addValueLabel(key, f, "float");
             return true;
         }
-        bool visit(AronIntDataNavigator& i) override
+        bool visit(const std::string& key, AronIntDataNavigator& i) override
         {
-            this->addValueLabel(i, "int");
+            this->addValueLabel(key, i, "int");
             return true;
         }
-        bool visit(AronLongDataNavigator& l) override
+        bool visit(const std::string& key, AronLongDataNavigator& l) override
         {
-            this->addValueLabel(l, "long");
+            this->addValueLabel(key, l, "long");
             return true;
         }
-        bool visit(AronStringDataNavigator& string) override
+        bool visit(const std::string& key, AronStringDataNavigator& string) override
         {
-            this->addValueLabel(string, "string");
+            this->addValueLabel(key, string, "string");
             return true;
         }
 
-        bool visit(AronNDArrayDataNavigator& array) override
+        bool visit(const std::string& key, AronNDArrayDataNavigator& array) override
         {
-            (void) array;
-            // ARMARX_INFO << "- NdArray (path: '" << array.getPath().toString() << "')";
+            this->addValueLabel(key, array, "ND Array");
             return true;
         }
 
@@ -94,18 +104,22 @@ namespace armarx::armem
     private:
 
         template <class Navigator>
-        void addValueLabel(Navigator& n, const std::string& typeName)
+        void addValueLabel(const std::string& key, Navigator& n, const std::string& typeName)
         {
-            if (not groups.empty())
-            {
-                groups.top().addChild(Label(this->makeValueLabelText(n, typeName)));
-            }
+            checkGroupsNotEmpty();
+            Group& g = groups.top();
+            g.layout
+            .add(Label(key), {g.nextRow, 0})
+            .add(Label("(" + typeName + ")"), {g.nextRow, 1})
+            .add(Label("= " + getValueText(n)), {g.nextRow, 2})
+            ;
+            ++g.nextRow;
         }
+
         template <class Navigator>
-        std::string makeValueLabelText(Navigator& n, const std::string& typeName)
+        std::string getValueText(Navigator& n)
         {
             std::stringstream ss;
-            ss << n.getPath().getLastElement() << ": " << typeName << " = ";
             streamValueText(n, ss);
             return ss.str();
         }
@@ -118,6 +132,8 @@ namespace armarx::armem
         void streamValueText(AronStringDataNavigator& n, std::stringstream& ss);
         void streamValueText(AronNDArrayDataNavigator& n, std::stringstream& ss);
 
+        void checkGroupsNotEmpty() const;
+
     };