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 <algorithm>
 
#include <SimoxUtility/color/Color.h>
#include <SimoxUtility/color/GlasbeyLUT.h>
 
namespace armarx
{
    LogMarkerRegistry::LogMarkerRegistry(QObject* parent) : QObject(parent)
    {
    }
 
    void
    LogMarkerRegistry::add(LogSeq seq)
    {
        {
            std::unique_lock lock(mutex);
 
            for (const LogMarker& marker : entries)
            {
                if (marker.seq == seq)
                {
                    // Already pinned: do not duplicate or recolor.
                    return;
                }
            }
 
            // 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.seq = seq;
            marker.color = QColor(color.r, color.g, color.b);
            entries.push_back(std::move(marker));
        }
 
        emit markersChanged();
    }
 
    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();
        }
    }
 
    bool
    LogMarkerRegistry::expireBefore(LogSeq firstSeq)
    {
        bool changed = false;
        {
            std::unique_lock lock(mutex);
            const auto newEnd = std::remove_if(entries.begin(),
                                               entries.end(),
                                               [firstSeq](const LogMarker& marker)
                                               { return marker.seq < firstSeq; });
            changed = newEnd != entries.end();
            entries.erase(newEnd, entries.end());
        }
        if (changed)
        {
            emit markersChanged();
        }
        return changed;
    }
 
    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();
        }
    }
 
    bool
    LogMarkerRegistry::empty() const
    {
        std::unique_lock lock(mutex);
        return entries.empty();
    }
 
    std::vector<LogMarker>
    LogMarkerRegistry::markers() const
    {
        std::unique_lock lock(mutex);
        return entries;
    }
 
    QColor
    LogMarkerRegistry::colorForSeq(LogSeq seq) const
    {
        std::unique_lock lock(mutex);
        for (const LogMarker& marker : entries)
        {
            if (marker.seq == seq)
            {
                return marker.color;
            }
        }
        return QColor();
    }
 
    LogMarkerId
    LogMarkerRegistry::markerIdForSeq(LogSeq seq) const
    {
        std::unique_lock lock(mutex);
        for (const LogMarker& marker : entries)
        {
            if (marker.seq == seq)
            {
                return marker.id;
            }
        }
        return 0;
    }
 
    bool
    LogMarkerRegistry::isMarked(LogSeq seq) const
    {
        return colorForSeq(seq).isValid();
    }
} // namespace armarx