Implement DataTreeBuilder based on TreeWidgetBuilder

source/RobotAPI/libraries/armem_gui/CMakeLists.txt

@@ -27,6 +27,9 @@ set(SOURCES
     instance/TreeDataVisitor.cpp
     instance/TreeTypedDataVisitor.cpp
 
+    instance/DataTreeBuilder.cpp
+    instance/DataTreeBuilderBase.cpp
+
     memory/GroupBox.cpp
     memory/TreeWidget.cpp
 
@@ -49,6 +52,10 @@ set(HEADERS
     instance/TreeDataVisitor.h
     instance/TreeTypedDataVisitor.h
 
+    instance/DataTreeBuilder.h
+    instance/DataTreeBuilderBase.h
+    instance/ValueDisplayVisitor.h
+
     memory/GroupBox.h
     memory/TreeWidget.h
 

source/RobotAPI/libraries/armem_gui/instance/DataTreeBuilder.cpp

+#include "DataTreeBuilder.h"
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+#include <RobotAPI/libraries/armem_gui/TreeWidgetBuilder.h>
+
+
+namespace armarx::armem::gui
+{
+
+    DataTreeBuilder::DataTreeBuilder()
+    {
+    }
+
+    void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, aron::datanavigator::DictNavigator& data)
+    {
+        using ContainerT = std::vector<std::string>;
+        const ContainerT keys = data.getAllKeys();
+
+        armarx::TreeWidgetBuilder<ContainerT> builder;
+        builder.setCompareFn([](const std::string & key, QTreeWidgetItem * item)
+        {
+            return armarx::detail::compare(key, item->text(0).toStdString());
+        });
+        builder.setMakeItemFn([this](const std::string & key)
+        {
+            return this->makeItem(key);
+        });
+        builder.setUpdateItemFn([this, &data](const std::string & key, QTreeWidgetItem * item)
+        {
+            auto child = data.getElement(key);
+            this->update(item, key, *child);
+            return true;
+        });
+
+        builder.updateTree(parent, keys);
+    }
+
+    void DataTreeBuilder::updateTree(QTreeWidgetItem* parent, aron::datanavigator::ListNavigator& data)
+    {
+        auto children = data.getChildren();
+
+        using ContainerT = std::vector<size_t>;
+        ContainerT index;
+        index.reserve(children.size());
+        for (size_t i = 0; i < children.size(); ++i)
+        {
+            index.push_back(i);
+        }
+
+        armarx::TreeWidgetBuilder<ContainerT> builder;
+        builder.setCompareFn([](size_t key, QTreeWidgetItem * item)
+        {
+            return armarx::detail::compare(static_cast<int>(key), item->data(0, Qt::UserRole).toInt());
+        });
+        builder.setMakeItemFn([this](size_t key)
+        {
+            return this->makeItem(key);
+        });
+        builder.setUpdateItemFn([this, &children](size_t key, QTreeWidgetItem * item)
+        {
+            this->update(item, std::to_string(key), *children.at(key));
+            return true;
+        });
+
+        builder.updateTree(parent, index);
+    }
+
+
+    void DataTreeBuilder::update(QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data)
+    {
+        this->setRowTexts(item, key, data);
+
+        if (auto cast = dynamic_cast<aron::datanavigator::DictNavigator*>(&data))
+        {
+            updateTree(item, *cast);
+        }
+        else if (auto cast = dynamic_cast<aron::datanavigator::ListNavigator*>(&data))
+        {
+            updateTree(item, *cast);
+        }
+    }
+
+
+}

source/RobotAPI/libraries/armem_gui/instance/DataTreeBuilder.h

+#pragma once
+
+#include <sstream>
+#include <stack>
+
+#include <QTreeWidget>
+#include <QLabel>
+
+#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+#include <RobotAPI/libraries/armem_gui/TreeWidgetBuilder.h>
+
+#include "DataTreeBuilderBase.h"
+
+
+namespace armarx::armem::gui
+{
+
+    class DataTreeBuilder : public DataTreeBuilderBase
+    {
+    public:
+
+        DataTreeBuilder();
+
+        void updateTree(QTreeWidgetItem* parent, aron::datanavigator::DictNavigator& data);
+        void updateTree(QTreeWidgetItem* parent, aron::datanavigator::ListNavigator& data);
+
+
+    protected:
+
+        void update(QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data);
+
+    };
+
+
+}

source/RobotAPI/libraries/armem_gui/instance/DataTreeBuilderBase.cpp

+#include "DataTreeBuilderBase.h"
+
+#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
+
+#include "ValueDisplayVisitor.h"
+
+
+namespace armarx::armem::gui
+{
+
+    DataTreeBuilderBase::DataTreeBuilderBase()
+    {
+    }
+
+    DataTreeBuilderBase::~DataTreeBuilderBase()
+    {}
+
+    void DataTreeBuilderBase::setColumns(int key, int value, int type)
+    {
+        this->columnKey = key;
+        this->columnType = type;
+        this->columnValue = value;
+    }
+
+
+    QTreeWidgetItem* DataTreeBuilderBase::makeItem(const std::string& key) const
+    {
+        return new QTreeWidgetItem(QStringList{QString::fromStdString(key)});
+    }
+
+    QTreeWidgetItem* DataTreeBuilderBase::makeItem(size_t key) const
+    {
+        QTreeWidgetItem* item = new QTreeWidgetItem();
+        item->setData(0, Qt::UserRole, static_cast<int>(key));
+        return item;
+    }
+
+    void DataTreeBuilderBase::setRowTexts(QTreeWidgetItem* item, const std::string& key, const std::string& value, const std::string& typeName) const
+    {
+        item->setText(columnKey, QString::fromStdString(key));
+        item->setText(columnValue, QString::fromStdString(value));
+        item->setText(columnType, QString::fromStdString(typeName));
+    }
+
+
+    void DataTreeBuilderBase::setRowTexts(
+        QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data)
+    {
+        armarx::aron::ValueDisplayVisitor visitor;
+        visitor.applyTo(data);
+        setRowTexts(item, key, visitor.ss.str(), data.getName());
+    }
+
+}

source/RobotAPI/libraries/armem_gui/instance/DataTreeBuilderBase.h

+#pragma once
+
+#include <QTreeWidgetItem>
+
+#include <RobotAPI/libraries/aron/core/navigator/data/Navigator.h>
+
+
+namespace armarx::armem::gui
+{
+
+    class DataTreeBuilderBase
+    {
+    public:
+
+        DataTreeBuilderBase();
+        virtual ~DataTreeBuilderBase();
+
+        void setColumns(int key, int value, int type);
+
+
+    protected:
+
+        QTreeWidgetItem* makeItem(const std::string& key) const;
+        QTreeWidgetItem* makeItem(size_t key) const;
+
+        void setRowTexts(QTreeWidgetItem* item, const std::string& key, const std::string& value, const std::string& typeName = "") const;
+        void setRowTexts(QTreeWidgetItem* item, const std::string& key, aron::datanavigator::Navigator& data);
+
+
+    public:
+
+        int columnKey = 0;
+        int columnValue = 1;
+        int columnType = 2;
+
+    };
+
+}

source/RobotAPI/libraries/armem_gui/instance/InstanceView.cpp

@@ -19,6 +19,7 @@
 #include <RobotAPI/libraries/aron/core/navigator/type/container/Object.h>
 
 #include <RobotAPI/libraries/armem_gui/gui_utils.h>
+#include <RobotAPI/libraries/armem_gui/instance/DataTreeBuilder.h>
 #include <RobotAPI/libraries/armem_gui/instance/TreeDataVisitor.h>
 #include <RobotAPI/libraries/armem_gui/instance/TreeTypedDataVisitor.h>
 #include <RobotAPI/libraries/armem_gui/instance/ImageView.h>
@@ -147,23 +148,24 @@ namespace armarx::armem::gui::instance
 
     void InstanceView::updateData(const aron::datanavigator::DictNavigatorPtr& data, aron::typenavigator::ObjectNavigatorPtr aronType)
     {
-        armarx::gui::clearItem(treeItemData);
         if (!data)
         {
+            armarx::gui::clearItem(treeItemData);
             QTreeWidgetItem* item = new QTreeWidgetItem({"(No data.)"});
             treeItemData->addChild(item);
         }
         else if (useTypeInfo && aronType)
         {
+            armarx::gui::clearItem(treeItemData);
             TreeTypedDataVisitor visitor(treeItemData);
             visitor.setColumns(int(Columns::KEY), int(Columns::VALUE), int(Columns::TYPE));
             visitor.applyTo(*aronType, *data);
         }
         else
         {
-            TreeDataVisitor visitor(treeItemData);
-            visitor.setColumns(int(Columns::KEY), int(Columns::VALUE), int(Columns::TYPE));
-            visitor.applyTo(*data);
+            DataTreeBuilder builder;
+            builder.setColumns(int(Columns::KEY), int(Columns::VALUE), int(Columns::TYPE));
+            builder.updateTree(treeItemData, *data);
         }
         treeItemData->setExpanded(true);
     }

source/RobotAPI/libraries/armem_gui/instance/ValueDisplayVisitor.h

+#pragma once
+
+#include <sstream>
+
+#include <RobotAPI/libraries/aron/core/navigator/visitors/DataVisitor.h>
+
+
+namespace armarx::aron
+{
+
+    struct ValueDisplayVisitor : public aron::visitor::DataVisitor
+    {
+        std::stringstream ss;
+
+
+        bool visitEnter(DictDataNavigator& n) override
+        {
+            ss << n.getChildren().size() << " items";
+            return false;
+        }
+        bool visitEnter(ListDataNavigator& n) override
+        {
+            ss << n.getChildren().size() << " items";
+            return false;
+        }
+
+        bool visit(BoolDataNavigator& b) override
+        {
+            if (b.getValue())
+            {
+                ss << "true";
+            }
+            else
+            {
+                ss << "false";
+            }
+            return false;
+        }
+        bool visit(DoubleDataNavigator& n) override
+        {
+            ss << n.getValue();
+            return false;
+        }
+        bool visit(FloatDataNavigator& n) override
+        {
+            ss << n.getValue();
+            return false;
+        }
+        bool visit(IntDataNavigator& n) override
+        {
+            ss << n.getValue();
+            return false;
+        }
+        bool visit(LongDataNavigator& n) override
+        {
+            ss << n.getValue();
+            return false;
+        }
+        bool visit(StringDataNavigator& n) override
+        {
+            ss << "'" << n.getValue() << "'";
+            return false;
+        }
+
+        bool visit(NDArrayDataNavigator& n) override
+        {
+            ss << "shape " << aron::datanavigator::NDArrayNavigator::DimensionsToString(n.getDimensions());
+            return false;
+        }
+
+    };
+
+}