LogMarkerRegistry.h

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
*/
 
#pragma once
 
// ArmarX
#include <ArmarXCore/interface/core/Log.h>
 
// Qt
#include <QColor>
#include <QObject>
 
// C++
#include <cstdint>
#include <mutex>
#include <vector>
 
#include "LogStore.h"
 
namespace armarx
{
    using LogMarkerId = std::uint64_t;
 
    //! A single pinned log line: the store entry it refers to plus the color assigned to
    //! it.
    struct LogMarker
    {
        LogMarkerId id = 0;
        //! The pinned line, as a sequence number into the shared LogStore. A pin lives
        //! exactly as long as its entry is retained there.
        LogSeq seq = 0;
        QColor color;
    };
 
    /*!
     * \brief Shared, session-only store of pinned ("labeled") log lines.
     *
     * Owned by the LogViewer and shared by (non-owning) pointer with every LogTableModel, so
     * a line pinned in one filter becomes visible (injected) in all of them. Colors are drawn
     * from the Glasbey lookup table (maximally distinct) by an increasing color index.
     *
     * Pins identify their line by LogStore sequence number. That is exact (no same-timestamp
     * ambiguity), makes lookups O(1) instead of a message-text comparison against every
     * retained row, and makes expiry a single range check against the store's oldest
     * sequence number.
     *
     * All mutating methods emit markersChanged() so the Labels panel and every model can
     * refresh. Access is GUI-thread only in practice, but a mutex guards the container.
     */
    class LogMarkerRegistry : public QObject
    {
        Q_OBJECT
    public:
        explicit LogMarkerRegistry(QObject* parent = nullptr);
 
        //! Pin the store entry \p seq, assigning it the next Glasbey color. No-op if it is
        //! already pinned.
        void add(LogSeq seq);
 
        //! Remove the marker with the given id (no-op if unknown).
        void remove(LogMarkerId id);
 
        //! Remove every marker whose line has been dropped from the store, i.e. whose
        //! sequence number is below \p firstSeq. Returns true if anything was removed.
        bool expireBefore(LogSeq firstSeq);
 
        //! Reassign a marker's color (no-op if unknown).
        void recolor(LogMarkerId id, const QColor& color);
 
        //! Drop all markers.
        void clear();
 
        bool empty() const;
 
        //! Ordered (insertion-order) view of all markers.
        std::vector<LogMarker> markers() const;
 
        //! Color of the marker pinning \p seq, or an invalid QColor if it is not pinned.
        QColor colorForSeq(LogSeq seq) const;
 
        //! Id of the marker pinning \p seq, or 0 if it is not pinned.
        LogMarkerId markerIdForSeq(LogSeq seq) const;
 
        //! Whether \p seq is pinned.
        bool isMarked(LogSeq seq) const;
 
    signals:
        void markersChanged();
 
    private:
        mutable std::mutex mutex;
        std::vector<LogMarker> entries;
        LogMarkerId nextId = 1;
        std::size_t colorIndex = 0;
    };
} // namespace armarx