LogStore.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::
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <cstddef>
#include <deque>
 
#include <QString>
#include <QtGlobal>
 
#include <ArmarXCore/interface/core/Log.h>
 
namespace armarx
{
    //! Identifies a stored log entry for as long as it is retained. Monotonically
    //! increasing and never reused, so it stays a valid reference even though the store
    //! drops old entries from the front (which shifts every index, but no sequence
    //! number).
    using LogSeq = quint64;
 
    //! A retained log line: the message plus the display data derived from it. The
    //! derived fields are built once, here, instead of once per filter that accepts the
    //! message and again on every repaint.
    struct StoredLogEntry
    {
        LogMessage message;
        QString timeString;     //!< formatted time column (0)
        QString displayMessage; //!< truncated message column (4)
        int lineCount = 1;      //!< number of display lines in displayMessage
    };
 
    /*!
     * \brief The single bounded buffer holding every log line the viewer retains.
     *
     * Filters do not own their messages: each LogTableModel keeps a vector of LogSeq into
     * this store. A message accepted by "All Messages", by its logging group filter and by
     * its component filter is therefore stored -- and has its display data derived --
     * once instead of three times.
     *
     * GUI thread only, like the rest of the viewer's model state. LogViewer::writeLog runs
     * on an Ice dispatch thread but only appends to its own staging queue; everything
     * reaching the store goes through insertPendingEntries on the GUI thread.
     */
    class LogStore
    {
    public:
        explicit LogStore(std::size_t maxEntries);
 
        //! Append \p message, deriving its display data, and return its sequence number.
        LogSeq append(const LogMessage& message);
 
        //! Drop the oldest entries until the bound is met. Returns true if anything was
        //! dropped, in which case firstSeq() has advanced and every model has to discard
        //! the rows below it (see LogTableModel::dropRowsBefore).
        bool trim();
 
        //! Sequence number of the oldest retained entry.
        LogSeq firstSeq() const;
        //! One past the sequence number of the newest retained entry.
        LogSeq endSeq() const;
        bool contains(LogSeq seq) const;
        //! Only valid if contains(seq).
        const StoredLogEntry& at(LogSeq seq) const;
 
        std::size_t size() const;
 
        //! Drop everything. Sequence numbers keep counting up, so references to the
        //! discarded entries stay invalid rather than aliasing new ones.
        void clear();
 
    private:
        std::deque<StoredLogEntry> entries;
        LogSeq first = 0;
        std::size_t maxEntries;
    };
} // namespace armarx