InstanceGroupBoxController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2012-2025, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    RobotStateComponent::
 * @author     Samet Soenmez (uewtt at student dot kit dot edu)
 * @date       2025t
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "InstanceGroupBoxController.h"
 
#include <SimoxUtility/algorithm/get_map_keys_values.h>
#include <SimoxUtility/algorithm/string/string_tools.h>
 
#include <QLayout>
#include <QGroupBox>
#include <QLabel>
 
#include <RobotAPI/libraries/armem_gui/view/instance_group/instance/AronDataView.h>
#include <RobotAPI/libraries/armem_gui/util/gui_utils.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
namespace armarx::armem::gui::controller
{
    InstanceGroupBoxController::InstanceGroupBoxController(
        MemoryViewerUIContext& uiContext,
        std::shared_ptr<armem::gui::model::MemoryViewerModel> model)
    {
        _model = std::move(model);
        _instanceGroupBoxView = new armem::gui::view::InstanceGroupBoxView();
        armarx::gui::replaceWidget(uiContext.instanceGroupBox, _instanceGroupBoxView, uiContext.instanceGroupBoxParentLayout);
        _instanceGroupBoxView->instanceView()->setStatusLabel(uiContext.statusLabel);
        ARMARX_CHECK_NULL(uiContext.instanceGroupBox);
 
        connect(_instanceGroupBoxView->instanceView(),
                &armem::gui::InstanceView::memoryIdResolutionRequested,
                this,
                &This::resolveMemoryID);
    }
 
    void
    InstanceGroupBoxController::updateInstanceTree(const armem::MemoryID& selectedID)
    {
        const armem::wm::Memory* data = _model->getSingleMemoryData(selectedID.memoryName);
        if (data)
        {
            if (not selectedID.hasEntityName())
            {
                return;
            }
            armem::MemoryID id = selectedID;
            const armem::wm::EntitySnapshot* snapshot = nullptr;
            if (not id.hasTimestamp())
            {
                const armem::wm::Entity& entity = data->getEntity(id);
                if (entity.empty())
                {
                    return;
                }
                snapshot = &entity.getLatestSnapshot();
                id.timestamp = snapshot->time();
            }
            if (not id.hasInstanceIndex())
            {
                if (not snapshot)
                {
                    try
                    {
                        snapshot = &data->getSnapshot(id);
                    }
                    catch (const armem::error::ArMemError& e)
                    {
                        _statusLabel->setText(e.what());
                    }
                }
                if (snapshot && snapshot->size() > 0)
                {
                    id.instanceIndex = 0;
                }
            }
            if (id.hasInstanceIndex())
            {
                _instanceGroupBoxView->instanceView()->update(id, *data);
            }
        }
        else
        {
            std::stringstream ss;
            ss << "Memory name '" << selectedID.memoryName << "' is unknown. Known are: "
               << simox::alg::join(simox::alg::get_keys(_model->memoryDataCopy()), ", ");
            _statusLabel->setText(QString::fromStdString(ss.str()));
        }
    }
 
    void
    InstanceGroupBoxController::resolveMemoryID(const MemoryID& id)
    {
        // ARMARX_IMPORTANT << "Resolving memory ID: " << id;
 
        auto handleError = [this](const std::string& msg)
        {
            _statusLabel->setText(QString::fromStdString(msg));
            ARMARX_WARNING << msg;
        };
 
        if (id.memoryName.empty())
        {
            handleError("Memory name is empty.");
        }
 
        aron::type::ObjectPtr segmentType;
        std::optional<wm::EntityInstance> instance;
        try
        {
            if (const wm::Memory* data = _model->getSingleMemoryData(id.memoryName))
            {
                segmentType = data->getProviderSegment(id).aronType();
 
                if (id.hasInstanceIndex())
                {
                    instance = data->getInstance(id);
                }
                else if (id.hasTimestamp())
                {
                    instance = data->getSnapshot(id).getInstance(0);
                }
                else
                {
                    instance = data->getEntity(id).getLatestSnapshot().getInstance(0);
                }
            }
            else
            {
                std::stringstream ss;
                ss << "Memory name '" << id.memoryName << "' is unknown. Known are: "
                   << simox::alg::join(simox::alg::get_keys(_model->memoryDataCopy()), ", ");
                _statusLabel->setText(QString::fromStdString(ss.str()));
            }
        }
        catch (const armem::error::ArMemError&)
        {
            // May be handled by remote lookup
        }
 
        if (not instance)
        {
            try
            {
                // Resolve remotely (may still fail, returns an optional).
                instance = _model->mns().resolveEntityInstance(id);
            }
            catch (const armem::error::ArMemError& e)
            {
                ARMARX_WARNING << e.what();
                _statusLabel->setText(e.what());
            }
        }
 
        if (instance)
        {
            auto* view = new InstanceView();
            _instanceGroupBoxView->instanceView()->addDataView(view);
            view->update(*instance, segmentType);
            //instanceGroup->view->addInstanceView(*instance, segmentType);
        }
        else
        {
            // ToDo: Propagate error back to highlight selected entry in red
        }
    }
 
    armem::gui::view::InstanceGroupBoxView*
    InstanceGroupBoxController::instanceGroupBoxView() const
    {
        return _instanceGroupBoxView;
    }
    
}