LogTableModel.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     Mirko Waechter ( mirko.waechter at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#pragma once
 
#include <QAbstractTableModel>
#include <QColor>
#include <QString>
 
// ArmarX
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/services/tasks/RunningTask.h>
#include <ArmarXCore/interface/core/Log.h>
 
#include "LogMarkerRegistry.h"
#include "LogStore.h"
 
// C++
#include <mutex>
#include <vector>
 
namespace armarx
{
    // Identifies a filterable log column. The integer values match the model's column
    // indices (see data() / headerData()).
    enum class LogColumn : int
    {
        Time = 0,
        Component = 1,
        Tag = 2,
        Verbosity = 3,
        Message = 4,
        File = 5,
        Function = 6,
        Group = 7,
        Unknown = -1
    };
 
    // How a filter value is compared against a column: as a substring (for manual,
    // user-typed filters) or as a whole-value match (for auto-generated per-component /
    // per-group filters, which must isolate exactly one component/group).
    enum class MatchMode
    {
        Contains,
        Exact
    };
 
    // A single active filter criterion: which column, the value to match against, and how.
    // The QString / int forms of the value are derived once when the filter is created,
    // because applyFilter() runs per message per filter and used to rebuild them on every
    // single call.
    struct LogFilter
    {
        LogColumn column = LogColumn::Unknown;
        std::string value;
        QString qValue;   //!< value as QString, for substring (Contains) matching
        int intValue = 0; //!< value as int, for the verbosity / file-line comparisons
        MatchMode mode = MatchMode::Contains;
    };
 
    /*!
     * \brief A filtered view onto the shared LogStore.
     *
     * The model does not own any log message. It keeps a vector of LogSeq -- one per
     * displayed row -- into the store owned by the LogViewer, plus the little per-filter
     * state that genuinely differs between filters (search match, pin color, and whether
     * the row is an injected pin rather than a row this filter accepted).
     *
     * A model is *materialised* only while its table is visible. A hidden filter keeps
     * counting the messages it accepts (for the new-message badge) but builds no rows at
     * all, which is what keeps ingestion independent of how many filters exist. Rows are
     * rebuilt from the store when the table is shown again.
     */
    class LogTableModel : public QAbstractTableModel
    {
        Q_OBJECT
    public:
        enum class UserRoles : int
        {
            FullMsgRole = Qt::UserRole + 1
        };
 
        explicit LogTableModel(QObject* parent = 0);
        int rowCount(const QModelIndex& parent = QModelIndex()) const override;
        int columnCount(const QModelIndex& parent = QModelIndex()) const override;
        QVariant data(const QModelIndex& index, int role) const override;
        QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
        bool setData(const QModelIndex& index, const QVariant& value, int role) override;
        Qt::ItemFlags flags(const QModelIndex& index) const override;
 
        //! Attach the shared backing store. Must be called before any ingestion.
        void setStore(const LogStore* store);
 
        void addFilter(const std::string& columnName,
                       const std::string& filter,
                       MatchMode mode = MatchMode::Contains);
        void reapplyAllFilters();
        void resetFilters();
        bool rowContainsString(int row, const QString& searchStr) const;
        bool msgContainsString(const LogMessage& logMsg, QString searchStr) const;
 
        void search(const QString& searchStr);
 
        QString
        getCurrentSearchStr()
        {
            return activeSearchStr;
        }
 
        MessageType
        getMaxNewLogLevelType()
        {
            return maxNewLogLevelType;
        }
 
        int getColumn(const std::string& columnName) const;
        int clearData();
 
        //! Upper bound on displayed rows. 0 disables the bound. The store keeps more
        //! history than this so that a quiet filter can still fill its window; this bounds
        //! what any single table has to lay out and paint.
        void setMaxEntries(std::size_t maxEntries);
 
        const std::vector<LogFilter>&
        getFilters() const
        {
            return activeFilters;
        }
 
        //! Append those of \p seqs that pass this model's filters, in one insertion. The
        //! messages themselves are read from the shared store. Returns how many were
        //! accepted -- which is counted even while the model is not materialised, so the
        //! new-message badge of a hidden filter stays correct. \p batchMaxLevelOut, if
        //! given, receives the highest severity among the accepted messages.
        int addEntries(const std::vector<LogSeq>& seqs, MessageType* batchMaxLevelOut = nullptr);
 
        //! Build rows (materialised) or drop them and only keep counting (not).
        void setMaterialised(bool materialised);
 
        bool
        isMaterialised() const
        {
            return materialised;
        }
 
        //! Discard rows whose store entry has been dropped. Called after the store trims.
        void dropRowsBefore(LogSeq firstSeq);
 
        //! Store sequence number of the given display row, or 0 if the row is invalid.
        LogSeq seqAt(int row) const;
 
        //! Display row showing \p seq, or -1 if it is not shown.
        int rowForSeq(LogSeq seq) const;
 
        //! Number of display lines of the message column for the given row.
        int lineCountAt(int row) const;
 
        //! Attach the shared pin registry. The model then shows registry markers that are
        //! not already present as rows of its own (injected, in time position), colors
        //! pinned rows, and refreshes whenever the registry changes.
        void setMarkerRegistry(LogMarkerRegistry* registry);
 
        //! Whether the given display row is currently pinned (has a label color).
        bool isRowMarked(int row) const;
 
        //! The message shown in the given row. Only valid while the row exists.
        const LogMessage& getLogEntry(size_t row) const;
 
    public slots:
        //! Rebuild the set of injected pin rows and re-color rows (full reset).
        void refreshMarkers();
 
    protected:
        bool applyFilter(const LogFilter& filter, const LogMessage& logMsg);
        bool applyFilters(const LogMessage& logMsg);
        //! Trim the oldest rows once the display window is exceeded.
        void enforceMaxEntries();
 
    private:
        //! One displayed row: a reference into the shared store plus the per-filter state.
        struct Row
        {
            LogSeq seq = 0;
            bool matchesSearch = false; //!< whether the entry matches the active search
            bool injected = false;      //!< true if this is an injected pin, not a match
            QColor markerColor;         //!< valid iff pinned; the pin's row background
        };
 
        //! Rebuild rows from the store, newest first up to maxEntries, honouring the
        //! clear watermark. Caller must bracket this with begin/endResetModel.
        void rebuildRowsFromStore();
 
        //! Re-derive markerColor / injected rows from the registry. Caller must bracket
        //! this with begin/endResetModel.
        void applyMarkersLocked();
 
        //! The store entry behind a row, or nullptr if it is no longer retained.
        const StoredLogEntry* entryAt(int row) const;
 
        QString activeSearchStr;
        MessageType maxNewLogLevelType;
        std::vector<LogFilter> activeFilters;
 
        //! Display-window bound; 0 disables it.
        std::size_t maxEntries = 10000;
 
        const LogStore* store = nullptr;
 
        //! Rows are only built while the table is visible. A freshly constructed table is
        //! not visible yet, so it starts out dematerialised and LogTable::showEvent brings
        //! it up.
        bool materialised = false;
 
        //! Sequence numbers below this were cleared from *this* filter ("Clear log") and
        //! must not come back when the rows are rebuilt from the store.
        LogSeq clearedBeforeSeq = 0;
 
        std::vector<Row> rows;
        mutable std::mutex rowsMutex;
 
        //! Shared pin registry (non-owning); nullptr until setMarkerRegistry().
        LogMarkerRegistry* markerRegistry = nullptr;
 
        RunningTask<LogTableModel>::pointer_type searchResultTask;
    };
} // namespace armarx