TreeTypedDataVisitor.h

Go to the documentation of this file.

#pragma once
 
#include <sstream>
#include <stack>
 
#include <QLabel>
#include <QTreeWidget>
 
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <RobotAPI/libraries/armem_gui/instance/sanitize_typename.h>
#include <RobotAPI/libraries/armem_gui/instance/serialize_path.h>
#include <RobotAPI/libraries/armem_gui/instance/tree_visitors/TreeDataVisitorBase.h>
#include <RobotAPI/libraries/aron/core/data/variant/All.h>
#include <RobotAPI/libraries/aron/core/data/visitor/variant/VariantVisitor.h>
 
namespace armarx::armem::gui::instance
{
 
    class TreeTypedDataVisitor :
        public aron::data::RecursiveConstTypedVariantVisitor,
        public TreeDataVisitorBase
    {
    public:
        using TreeDataVisitorBase::TreeDataVisitorBase;
 
        void
        visitDictOnEnter(const aron::data::VariantPtr& data,
                         const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
            _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
        }
 
        void
        visitDictOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
        {
            _visitExit();
        }
 
        void
        visitObjectOnEnter(const aron::data::VariantPtr& data,
                           const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
            _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
        }
 
        void
        visitObjectOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
        {
            _visitExit();
        }
 
        void
        visitListOnEnter(const aron::data::VariantPtr& data,
                         const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
            _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
        }
 
        void
        visitListOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
        {
            _visitExit();
        }
 
        void
        visitTupleOnEnter(const aron::data::VariantPtr& data,
                          const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
            _visitEnter(key, sanitizeTypeName(type->getFullName()), data->childrenSize());
        }
 
        void
        visitTupleOnExit(const aron::data::VariantPtr&, const aron::type::VariantPtr&) override
        {
            _visitExit();
        }
 
        // What about Pair??
 
 
        void
        visitBool(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Bool::DynamicCastAndCheck(data);
            auto t = *aron::type::Bool::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitDouble(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Double::DynamicCastAndCheck(data);
            auto t = *aron::type::Double::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitFloat(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Float::DynamicCastAndCheck(data);
            auto t = *aron::type::Float::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitInt(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Int::DynamicCastAndCheck(data);
            auto t = *aron::type::Int::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitLong(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Long::DynamicCastAndCheck(data);
            auto t = *aron::type::Long::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitString(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::String::DynamicCastAndCheck(data);
            auto t = *aron::type::String::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        /*void visitDateTime(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::Long::DynamicCastAndCheck(data);
            auto t = *aron::type::DateTime::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }*/
 
 
        void
        visitMatrix(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
            auto t = *aron::type::Matrix::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitQuaternion(const aron::data::VariantPtr& data,
                        const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
            auto t = *aron::type::Quaternion::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitPointCloud(const aron::data::VariantPtr& data,
                        const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
            auto t = *aron::type::PointCloud::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        void
        visitImage(const aron::data::VariantPtr& data, const aron::type::VariantPtr& type) override
        {
            ARMARX_CHECK_NOT_NULL(data);
            ARMARX_CHECK_NOT_NULL(type);
            const std::string key = data->getPath().getLastElement();
 
            auto d = *aron::data::NDArray::DynamicCastAndCheck(data);
            auto t = *aron::type::Image::DynamicCastAndCheck(type);
            this->addValueRow(key, d, t);
        }
 
        // What aboud NDArray
 
 
    protected:
        template <class DataNavigatorT, class TypeNavigatorT>
        bool
        addValueRow(const std::string& key, const DataNavigatorT& data, const TypeNavigatorT& type)
        {
            if (items.size() > 0)
            {
                QTreeWidgetItem* item = makeItem(key, data, type);
                items.top()->addChild(item);
 
                item->setData(columnKey, Qt::UserRole, serializePath(data.getPath()));
                item->setData(columnType, Qt::UserRole, int(type.getDescriptor()));
 
                if (false) // remove?
                {
                    QFont font;
                    font.setFamily("Consolas");
                    font.setStyleHint(QFont::Monospace);
                    font.setFixedPitch(true);
                    font.setPointSize(10);
                    item->setFont(columnValue, font);
                }
            }
            return true;
        }
 
        template <class DataNavigatorT, class TypeNavigatorT>
        QTreeWidgetItem*
        makeItem(const std::string& key,
                 const DataNavigatorT& data,
                 const TypeNavigatorT& type) const
        {
            std::stringstream ss;
            try
            {
                this->streamValueText(data, type, ss);
            }
            catch (const aron::error::AronException& e)
            {
                ss << "x ";
                TreeDataVisitorBase::streamValueText(data, ss);
                std::stringstream es;
                es << e.what();
                ss << simox::alg::replace_all(es.str(), "\n", " | ");
            }
            return new QTreeWidgetItem(
                this->makeValueRowStrings(key, ss.str(), sanitizeTypeName(type.getFullName())));
        }
 
        template <class DataNavigatorT, class TypeNavigatorT>
        void
        streamValueText(const DataNavigatorT& data,
                        const TypeNavigatorT& type,
                        std::stringstream& ss) const
        {
            // Fallback to type-agnostic (but data-aware).
            (void)type;
            TreeDataVisitorBase::streamValueText(data, ss);
        }
 
        using TreeDataVisitorBase::streamValueText;
        //void streamValueText(const aron::data::Long& data, const aron::type::DateTime& type, std::stringstream& ss) const;
        void streamValueText(const aron::data::NDArray& data,
                             const aron::type::Matrix& type,
                             std::stringstream& ss) const;
 
        void streamPoseText(const aron::data::NDArray& data,
                            const aron::type::Matrix& type,
                            std::stringstream& ss) const;
        void streamPositionText(const aron::data::NDArray& data,
                                const aron::type::Matrix& type,
                                std::stringstream& ss) const;
        void streamOrientationText(const aron::data::NDArray& data,
                                   const aron::type::Matrix& type,
                                   std::stringstream& ss) const;
 
 
        std::string coeffSep = "  ";
    };
 
} // namespace armarx::armem::gui::instance