LogMarkerRegistry.cpp

Go to the documentation of this file.

/*
* This file is part of ArmarX.
*
* 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    ArmarX::
* @author     Fabian Reister ( fabian dot reister at kit dot edu )
* @date       2026
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "LogMarkerRegistry.h"
 
#include <SimoxUtility/color/Color.h>
#include <SimoxUtility/color/GlasbeyLUT.h>
 
namespace armarx
{
    LogMarkerRegistry::LogMarkerRegistry(QObject* parent) : QObject(parent)
    {
    }
 
    bool
    LogMarkerRegistry::sameLine(const LogMessage& a, const LogMessage& b)
    {
        return a.time == b.time && a.who == b.who && a.what == b.what;
    }
 
    const LogMarker*
    LogMarkerRegistry::add(const LogMessage& snapshot)
    {
        {
            std::unique_lock lock(mutex);
 
            for (const LogMarker& marker : entries)
            {
                if (sameLine(marker.snapshot, snapshot))
                {
                    // Already pinned: return the existing marker, do not duplicate or recolor.
                    return &marker;
                }
            }
 
            // Draw the next maximally-distinct color from the Glasbey LUT.
            const simox::color::Color color = simox::color::GlasbeyLUT::at(colorIndex++);
 
            LogMarker marker;
            marker.id = nextId++;
            marker.snapshot = snapshot;
            marker.color = QColor(color.r, color.g, color.b);
            entries.push_back(std::move(marker));
        }
 
        emit markersChanged();
 
        // add() is GUI-thread only, so the just-inserted marker is still present here.
        return markerForMessage(snapshot);
    }
 
    void
    LogMarkerRegistry::remove(LogMarkerId id)
    {
        bool changed = false;
        {
            std::unique_lock lock(mutex);
            for (auto it = entries.begin(); it != entries.end(); ++it)
            {
                if (it->id == id)
                {
                    entries.erase(it);
                    changed = true;
                    break;
                }
            }
        }
        if (changed)
        {
            emit markersChanged();
        }
    }
 
    void
    LogMarkerRegistry::recolor(LogMarkerId id, const QColor& color)
    {
        bool changed = false;
        {
            std::unique_lock lock(mutex);
            for (LogMarker& marker : entries)
            {
                if (marker.id == id)
                {
                    marker.color = color;
                    changed = true;
                    break;
                }
            }
        }
        if (changed)
        {
            emit markersChanged();
        }
    }
 
    void
    LogMarkerRegistry::clear()
    {
        bool changed = false;
        {
            std::unique_lock lock(mutex);
            changed = !entries.empty();
            entries.clear();
        }
        if (changed)
        {
            emit markersChanged();
        }
    }
 
    std::vector<LogMarker>
    LogMarkerRegistry::markers() const
    {
        std::unique_lock lock(mutex);
        return entries;
    }
 
    const LogMarker*
    LogMarkerRegistry::markerForMessage(const LogMessage& message) const
    {
        std::unique_lock lock(mutex);
        for (const LogMarker& marker : entries)
        {
            if (sameLine(marker.snapshot, message))
            {
                return &marker;
            }
        }
        return nullptr;
    }
 
    bool
    LogMarkerRegistry::isMarked(const LogMessage& message) const
    {
        return markerForMessage(message) != nullptr;
    }
} // namespace armarx