MemoryViewerModel.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 "MemoryViewerModel.h"
 
namespace armarx::armem::gui::model
{
    MemoryViewerModel::MemoryViewerModel()
    {
 
    }
 
    const armem::wm::Memory*
    MemoryViewerModel::getSingleMemoryData(const std::string& memoryName)
    {
        auto it = _memoryData.find(memoryName);
        if (it == _memoryData.end())
        {
            return nullptr;
        }
        else
        {
            return &it->second;
        }
    }
 
    std::vector<std::string> MemoryViewerModel::getEnabledMemories() const
    {
        std::vector<std::string> enabled;
 
        for(const auto& [name, state] : _activeMemoryStates) {
            if (state == armem::gui::ActiveMemoryState::FoundAndChecked) {
                enabled.push_back(name);
            }
        }
        return enabled;
    }
 
    armem::client::QueryInput MemoryViewerModel::queryInput() const
    {
        armem::client::query::Builder queryBuilder(_dataMode);
        queryBuilder.coreSegments().all().providerSegments().all().entities().all().snapshots(
            _selector);
 
        return queryBuilder.buildQueryInput();
    }
 
 
    std::map<std::string, armem::gui::ActiveMemoryState> MemoryViewerModel::activeMemoryStates()
    {
        return _activeMemoryStates;
    }
 
    armem::client::MemoryNameSystem& MemoryViewerModel::mns()
    {
        ARMARX_CHECK(_mns);
        return *_mns;
    }
 
    DebugObserverInterfacePrx& MemoryViewerModel::debugObserver()
    {
        return _debugObserver;
    }
 
    bool MemoryViewerModel::initialized() const
    {
        return _initialized.load();
    }
 
    bool MemoryViewerModel::connected() const
    {
        return _connected.load();
    }
 
    std::map<std::string, armem::client::Reader>& MemoryViewerModel::memoryReaders()
    {
        return _memoryReaders;
    }
 
    std::map<std::string, armem::client::Writer>& MemoryViewerModel::memoryWriters()
    {
        return _memoryWriters;
    }
 
    std::map<std::string, armem::client::Reader> MemoryViewerModel::memoryReadersCopy() const
    {
        return _memoryReaders;
    }
    std::map<std::string, armem::client::Writer> MemoryViewerModel::memoryWritersCopy() const
    {
        return _memoryWriters;
    }
 
    std::map<std::string, armem::wm::Memory>& MemoryViewerModel::memoryData()
    {
        std::scoped_lock l(_memoryDataMutex);
        return _memoryData;
    }
 
    std::map<std::string, armem::wm::Memory> MemoryViewerModel::memoryDataCopy() const
    {
        std::scoped_lock l(_memoryDataMutex);
        return _memoryData;
    }
 
    int MemoryViewerModel::recursionDepth() const
    {
        return _recursionDepth;
    }
 
    armem::query::DataMode MemoryViewerModel::dataMode() const
    {
        return _dataMode;
    }
 
    bool MemoryViewerModel::dropRemovedMemories() const
    {
        return _dropRemovedMemories;
    }
 
    bool MemoryViewerModel::dropDisabledMemories() const
    {
        return _dropDisabledMemories;
    }
 
    client::query::SnapshotSelector MemoryViewerModel::selector() const
    {
        return _selector;
    }
 
    void MemoryViewerModel::setMns(std::unique_ptr<armem::client::MemoryNameSystem> mns)
    {
        _mns = std::move(mns);
    }
 
    void MemoryViewerModel::setDebugObserver(const DebugObserverInterfacePrx& observer)
    {
        _debugObserver = observer;
    }
 
    void MemoryViewerModel::setInitialized(bool val)
    {
        _initialized.store(val);
    }
 
    void MemoryViewerModel::setConnected(bool val)
    {
        _connected.store(val);
    }
 
    void MemoryViewerModel::setMemoryReaders(std::map<std::string, armem::client::Reader> readers)
    {
        _memoryReaders = std::move(readers);
    }
 
    void MemoryViewerModel::setMemoryWriters(std::map<std::string, armem::client::Writer> writers)
    {
        _memoryWriters = std::move(writers);
    }
 
    void MemoryViewerModel::setMemoryData(std::map<std::string, armem::wm::Memory> data)
    {
        std::scoped_lock l(_memoryDataMutex);
        _memoryData = std::move(data);
    }
 
    void MemoryViewerModel::setActiveMemoryStates(std::map<std::string, armem::gui::ActiveMemoryState> states)
    {
        _activeMemoryStates = std::move(states);
    }
 
    void MemoryViewerModel::setRecursionDepth(int value)
    {
        _recursionDepth = value;
    }
 
    void MemoryViewerModel::setDataMode(armem::query::DataMode dataMode)
    {
        _dataMode = dataMode;
    }
 
    void MemoryViewerModel::setDropRemovedMemories(bool val)
    {
        _dropRemovedMemories = val;
    }
 
    void MemoryViewerModel::setDropDisabledMemories(bool val)
    {
        _dropDisabledMemories = val;
    }
 
    void MemoryViewerModel::setSelector(client::query::SnapshotSelector selector)
    {
        _selector = selector;
    }
 
    
}