LogTableModel.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     Mirko Waechter ( mirko.waechter at kit dot edu)
* @date       2012
* @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
*             GNU General Public License
*/
 
#include "LogTableModel.h"
 
#include <algorithm>
#include <cctype>
 
#include <QFont>
 
#include <ArmarXCore/core/logging/LogSender.h>
 
#include "LogTable.h"
 
namespace armarx
{
    namespace
    {
        // ASCII case-insensitive equality. Used for the exact (auto-generated) component
        // filters, which run per message per filter and previously converted both sides to
        // QString just to compare them.
        bool
        iEquals(const std::string& a, const std::string& b)
        {
            return a.size() == b.size() &&
                   std::equal(a.begin(),
                              a.end(),
                              b.begin(),
                              [](unsigned char x, unsigned char y)
                              { return std::tolower(x) == std::tolower(y); });
        }
 
        // Map a column header name (ARMARX_LOG_*STR) to its LogColumn once, when a filter
        // is created, so per-message filtering can switch on an enum instead of comparing
        // strings.
        LogColumn
        columnFromName(const std::string& name)
        {
            if (name == ARMARX_LOG_TIMESTR)
            {
                return LogColumn::Time;
            }
            if (name == ARMARX_LOG_COMPONENTSTR)
            {
                return LogColumn::Component;
            }
            if (name == ARMARX_LOG_TAGSTR)
            {
                return LogColumn::Tag;
            }
            if (name == ARMARX_LOG_VERBOSITYSTR)
            {
                return LogColumn::Verbosity;
            }
            if (name == ARMARX_LOG_MESSAGESTR)
            {
                return LogColumn::Message;
            }
            if (name == ARMARX_LOG_FILESTR)
            {
                return LogColumn::File;
            }
            if (name == ARMARX_LOG_FUNCTIONSTR)
            {
                return LogColumn::Function;
            }
            if (name == ARMARX_LOG_LOGGINGGROUPSTR)
            {
                return LogColumn::Group;
            }
            return LogColumn::Unknown;
        }
    } // namespace
 
    LogTableModel::LogTableModel(QObject* parent) : QAbstractTableModel(parent)
    {
        maxNewLogLevelType = eUNDEFINED;
    }
 
    void
    LogTableModel::setStore(const LogStore* store)
    {
        this->store = store;
    }
 
    int
    LogTableModel::rowCount(const QModelIndex& parent) const
    {
        return rows.size();
    }
 
    int
    LogTableModel::columnCount(const QModelIndex& parent) const
    {
        return 8;
    }
 
    const StoredLogEntry*
    LogTableModel::entryAt(int row) const
    {
        // Caller holds rowsMutex.
        if (!store || row < 0 || row >= (signed int)rows.size())
        {
            return nullptr;
        }
        const LogSeq seq = rows[row].seq;
        if (!store->contains(seq))
        {
            return nullptr;
        }
        return &store->at(seq);
    }
 
    QVariant
    LogTableModel::data(const QModelIndex& index, int role) const
    {
        const int& row = index.row();
        const int& column = index.column();
 
        switch (role)
        {
            case (int)UserRoles::FullMsgRole:
            {
                std::unique_lock lock(rowsMutex);
                const StoredLogEntry* stored = entryAt(row);
                if (!stored)
                {
                    return QString("n/A");
                }
 
                const LogMessage& entry = stored->message;
                switch (column)
                {
 
                    case 4:
                    {
                        if (role == Qt::ToolTipRole)
                        {
                            return "";
                        }
 
                        QString whatStr;
 
                        if (!entry.backtrace.empty())
                        {
                            whatStr = QString::fromStdString(entry.what + "\nBacktrace:\n" +
                                                             entry.backtrace);
                        }
                        else
                        {
                            whatStr = QString::fromStdString(entry.what);
                        }
 
                        return whatStr;
                    }
                    default:
                        return "";
                }
            }
            case Qt::DisplayRole:
            case Qt::ToolTipRole:
            {
                std::unique_lock lock(rowsMutex);
 
                const StoredLogEntry* stored = entryAt(row);
                if (!stored)
                {
                    return QString("n/A");
                }
 
                const LogMessage& entry = stored->message;
 
                switch (column)
                {
                    case 0:
                    {
                        return stored->timeString;
                    }
 
                    case 1:
                    {
                        return QString::fromStdString(entry.who);
                    }
 
                    case 2:
                    {
                        return QString::fromStdString(entry.tag);
                    }
 
                    case 3:
                    {
                        if (entry.type != eUNDEFINED)
                        {
                            return QString::fromStdString(
                                LogSender::levelToString((MessageTypeT)entry.type));
                        }
                        else
                        {
                            return QVariant();
                        }
                    }
 
                    case 4:
                    {
                        if (role == Qt::ToolTipRole)
                        {
                            return "";
                        }
                        return stored->displayMessage;
                    }
 
                    case 5:
                    {
                        if (role == Qt::ToolTipRole)
                        {
                            return QString::fromStdString(
                                "Double click to open file in editor: " + entry.file + ":" +
                                QString::number(entry.line).toStdString());
                        }
                        else if (!entry.file.empty())
                        {
                            return QString::fromStdString(
                                entry.file + ":" + QString::number(entry.line).toStdString());
                        }
                        else
                        {
                            return QVariant();
                        }
                    }
 
                    case 6:
                    {
                        return QString::fromStdString(entry.function);
                    }
 
                    case 7:
                    {
                        return QString::fromStdString(entry.group);
                    }
 
                    default:
                        return "";
                }
            }
 
            case Qt::DecorationRole:
                switch (column)
                {
                    case 5:
                        return QIcon(":icons/document-open-4.ico");
 
                    default:
                        return QVariant();
                }
 
            case Qt::FontRole:
            {
                // Injected pins (shown here although they do not match this filter) are
                // rendered italic so they are visually distinct from matching rows.
                std::unique_lock lock(rowsMutex);
                if (row >= 0 && row < (signed int)rows.size() && rows[row].injected)
                {
                    QFont font;
                    font.setItalic(true);
                    return font;
                }
                return QVariant();
            }
 
            case Qt::BackgroundColorRole:
            {
                std::unique_lock lock(rowsMutex);
 
                if (row < 0 || row >= (signed int)rows.size())
                {
                    return QVariant();
                }
 
                // Pinned rows: full-row label color, overriding verbosity color and search
                // highlight (see the concept: "Full-row background").
                if (rows[row].markerColor.isValid())
                {
                    return rows[row].markerColor;
                }
 
                if (column == 3) // Log Level color
                {
                    const StoredLogEntry* stored = entryAt(row);
                    if (!stored)
                    {
                        return QVariant();
                    }
 
                    switch (stored->message.type)
                    {
                        case eVERBOSE:
                            return QColor(200, 200, 250);
 
                        case eIMPORTANT:
                            return QColor(50, 255, 50);
 
                        case eWARN:
                            return QColor(216, 88, 0);
 
                        case eERROR:
                            return QColor(255, 64, 64);
 
                        case eFATAL:
                            return QColor(176, 0, 0);
 
                        default:
                            break;
                    }
                }
 
                if (activeSearchStr.length() == 0)
                {
                    return QVariant();
                }
 
                if (rows[row].matchesSearch)
                {
                    return QColor(255, 244, 127);
                }
                return QVariant();
            }
        }
 
        return QVariant();
    }
 
    bool
    LogTableModel::rowContainsString(int row, const QString& searchStr) const
    {
        if (searchStr.length() == 0)
        {
            return true;
        }
 
        for (int i = 0; i < columnCount(); i++)
        {
            if (data(createIndex(row, i), Qt::DisplayRole)
                    .toString()
                    .contains(searchStr, Qt::CaseInsensitive))
            {
                return true;
            }
        }
 
        return false;
    }
 
    bool
    LogTableModel::msgContainsString(const LogMessage& logMsg, QString searchStr) const
    {
        if (QString(logMsg.who.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString(logMsg.tag.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString(logMsg.what.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString(logMsg.backtrace.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString(logMsg.file.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString(logMsg.function.c_str()).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        if (QString::number(logMsg.line).contains(searchStr, Qt::CaseInsensitive))
        {
            return true;
        }
 
        return false;
    }
 
    void
    LogTableModel::search(const QString& searchStr)
    {
        activeSearchStr = searchStr;
 
        // Evaluate the search once per row here instead of on every repaint of every cell
        // (data() only reads the cached flag afterwards).
        std::size_t rowCount = 0;
        {
            std::unique_lock lock(rowsMutex);
            const bool hasSearch = searchStr.length() > 0;
            for (std::size_t i = 0; i < rows.size(); ++i)
            {
                const StoredLogEntry* stored = entryAt(static_cast<int>(i));
                rows[i].matchesSearch =
                    hasSearch && stored && msgContainsString(stored->message, searchStr);
            }
            rowCount = rows.size();
        }
 
        if (rowCount > 0)
        {
            emit dataChanged(index(0, 0), index(static_cast<int>(rowCount) - 1, 6));
        }
    }
 
    QVariant
    LogTableModel::headerData(int section, Qt::Orientation orientation, int role) const
    {
        if (role == Qt::DisplayRole)
        {
            if (orientation == Qt::Horizontal)
            {
                switch (section)
                {
                    case 0:
                        return QString(ARMARX_LOG_TIMESTR);
 
                    case 1:
                        return QString(ARMARX_LOG_COMPONENTSTR);
 
                    case 2:
                        return QString(ARMARX_LOG_TAGSTR);
 
                    case 3:
                        return QString(ARMARX_LOG_VERBOSITYSTR);
 
                    case 4:
                        return QString(ARMARX_LOG_MESSAGESTR);
 
                    case 5:
                        return QString(ARMARX_LOG_FILESTR);
 
                    case 6:
                        return QString(ARMARX_LOG_FUNCTIONSTR);
 
                    case 7:
                        return QString(ARMARX_LOG_LOGGINGGROUPSTR);
 
                    default:
                        return QString("");
                }
            }
        }
        else if (role == Qt::ToolTipRole)
        {
            if (orientation == Qt::Horizontal)
            {
                switch (section)
                {
                    case 0:
                        return QString(ARMARX_LOG_TIMESTR);
 
                    case 1:
                        return QString(ARMARX_LOG_COMPONENTSTR);
 
                    case 2:
                        return QString(ARMARX_LOG_TAGSTR);
 
                    case 3:
                        return QString(ARMARX_LOG_VERBOSITYSTR);
 
                    case 4:
                        return QString(ARMARX_LOG_MESSAGESTR);
 
                    case 5:
                        return QString::fromStdString(
                            std::string(ARMARX_LOG_FILESTR) +
                            std::string(": Double click cell to open Qtcreator at that location"));
 
                    case 6:
                        return QString(ARMARX_LOG_FUNCTIONSTR);
 
                    default:
                        return QString("");
                }
            }
        }
 
        return QVariant();
    }
 
    bool
    LogTableModel::setData(const QModelIndex& index, const QVariant& value, int role)
    {
        return false;
    }
 
    Qt::ItemFlags
    LogTableModel::flags(const QModelIndex& index) const
    {
        if (index.column() == getColumn(ARMARX_LOG_MESSAGESTR))
        {
            return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
        }
        else
        {
            return Qt::ItemIsSelectable | Qt::ItemIsEnabled;
        }
    }
 
    void
    LogTableModel::addFilter(const std::string& columnName,
                             const std::string& filter,
                             MatchMode mode)
    {
        LogFilter entry;
        entry.column = columnFromName(columnName);
        entry.value = filter;
        // Derive the comparison forms once here rather than per message in applyFilter().
        entry.qValue = QString::fromStdString(filter);
        entry.intValue = entry.qValue.toInt();
        entry.mode = mode;
        activeFilters.push_back(std::move(entry));
    }
 
    void
    LogTableModel::reapplyAllFilters()
    {
        beginResetModel();
        {
            std::unique_lock lock(rowsMutex);
            if (materialised)
            {
                rebuildRowsFromStore();
                applyMarkersLocked();
            }
            else
            {
                // Rows are rebuilt from the store, with the new filters, on the next
                // showEvent. Editing a filter does not make its table visible.
                rows.clear();
            }
        }
        maxNewLogLevelType = eUNDEFINED;
        endResetModel();
    }
 
    void
    LogTableModel::resetFilters()
    {
        activeFilters.clear();
    }
 
    void
    LogTableModel::setMarkerRegistry(LogMarkerRegistry* registry)
    {
        if (markerRegistry == registry)
        {
            return;
        }
        if (markerRegistry)
        {
            disconnect(markerRegistry, nullptr, this, nullptr);
        }
        markerRegistry = registry;
        if (markerRegistry)
        {
            connect(markerRegistry,
                    &LogMarkerRegistry::markersChanged,
                    this,
                    &LogTableModel::refreshMarkers);
        }
        refreshMarkers();
    }
 
    void
    LogTableModel::refreshMarkers()
    {
        if (!materialised)
        {
            // Rows are rebuilt (with markers applied) when the table becomes visible.
            return;
        }
 
        beginResetModel();
        {
            std::unique_lock lock(rowsMutex);
            applyMarkersLocked();
        }
        endResetModel();
    }
 
    void
    LogTableModel::applyMarkersLocked()
    {
        // Caller holds rowsMutex and brackets this with begin/endResetModel.
 
        // 1. Drop previously injected pin rows.
        rows.erase(std::remove_if(rows.begin(),
                                  rows.end(),
                                  [](const Row& r) { return r.injected; }),
                   rows.end());
 
        for (Row& row : rows)
        {
            row.markerColor = QColor();
        }
 
        if (!markerRegistry || !store)
        {
            return;
        }
 
        const std::vector<LogMarker> markers = markerRegistry->markers();
        if (markers.empty())
        {
            return;
        }
 
        // 2. Re-color the rows this filter holds itself.
        for (Row& row : rows)
        {
            for (const LogMarker& marker : markers)
            {
                if (marker.seq == row.seq)
                {
                    row.markerColor = marker.color;
                    break;
                }
            }
        }
 
        // 3. Inject markers that are not present as a row of this filter, in sequence
        // position, so a line pinned in another filter still appears here.
        for (const LogMarker& marker : markers)
        {
            if (!store->contains(marker.seq) || marker.seq < clearedBeforeSeq)
            {
                continue;
            }
            const bool present = std::any_of(rows.begin(),
                                             rows.end(),
                                             [&marker](const Row& r)
                                             { return !r.injected && r.seq == marker.seq; });
            if (present)
            {
                continue;
            }
 
            Row injected;
            injected.seq = marker.seq;
            injected.injected = true;
            injected.markerColor = marker.color;
            injected.matchesSearch =
                !activeSearchStr.isEmpty() &&
                msgContainsString(store->at(marker.seq).message, activeSearchStr);
 
            // Sequence numbers are assigned in arrival order, so ordering by seq is
            // ordering by time.
            const auto pos = std::lower_bound(rows.begin(),
                                              rows.end(),
                                              marker.seq,
                                              [](const Row& r, LogSeq seq)
                                              { return r.seq < seq; });
            rows.insert(pos, std::move(injected));
        }
    }
 
    void
    LogTableModel::rebuildRowsFromStore()
    {
        // Caller holds rowsMutex and brackets this with begin/endResetModel.
        rows.clear();
 
        if (!store)
        {
            return;
        }
 
        // Walk backwards from the newest entry so the scan can stop as soon as the display
        // window is full, instead of filtering the whole store every time.
        const LogSeq begin = std::max(store->firstSeq(), clearedBeforeSeq);
        std::vector<Row> collected;
        for (LogSeq seq = store->endSeq(); seq > begin;)
        {
            --seq;
            if (maxEntries != 0 && collected.size() >= maxEntries)
            {
                break;
            }
            const StoredLogEntry& stored = store->at(seq);
            if (!applyFilters(stored.message))
            {
                continue;
            }
            Row row;
            row.seq = seq;
            row.matchesSearch = !activeSearchStr.isEmpty() &&
                                msgContainsString(stored.message, activeSearchStr);
            collected.push_back(std::move(row));
        }
 
        rows.assign(collected.rbegin(), collected.rend());
    }
 
    void
    LogTableModel::setMaterialised(bool materialised)
    {
        if (this->materialised == materialised)
        {
            return;
        }
        this->materialised = materialised;
 
        beginResetModel();
        {
            std::unique_lock lock(rowsMutex);
            if (materialised)
            {
                rebuildRowsFromStore();
                applyMarkersLocked();
            }
            else
            {
                // A hidden table is never painted; releasing its rows is what keeps the
                // memory and the per-tick work independent of the number of filters.
                rows.clear();
                rows.shrink_to_fit();
            }
        }
        endResetModel();
    }
 
    int
    LogTableModel::addEntries(const std::vector<LogSeq>& seqs, MessageType* batchMaxLevelOut)
    {
        if (batchMaxLevelOut)
        {
            *batchMaxLevelOut = eUNDEFINED;
        }
        if (seqs.empty() || !store)
        {
            return 0;
        }
 
        // Snapshot the pins once per batch rather than locking the registry per row.
        std::vector<LogMarker> markers;
        if (markerRegistry)
        {
            markers = markerRegistry->markers();
        }
 
        std::vector<Row> accepted;
        accepted.reserve(seqs.size());
        MessageType batchMaxLevel = eUNDEFINED;
        for (const LogSeq seq : seqs)
        {
            if (!store->contains(seq))
            {
                continue;
            }
            const LogMessage& message = store->at(seq).message;
            if (!applyFilters(message))
            {
                continue;
            }
            if (message.type > batchMaxLevel)
            {
                batchMaxLevel = message.type;
            }
 
            Row row;
            row.seq = seq;
            row.matchesSearch =
                !activeSearchStr.isEmpty() && msgContainsString(message, activeSearchStr);
            for (const LogMarker& marker : markers)
            {
                if (marker.seq == seq)
                {
                    row.markerColor = marker.color;
                    break;
                }
            }
            accepted.push_back(std::move(row));
        }
 
        if (accepted.empty())
        {
            return 0;
        }
 
        const int addedCount = static_cast<int>(accepted.size());
 
        if (batchMaxLevel > maxNewLogLevelType)
        {
            maxNewLogLevelType = batchMaxLevel;
        }
        if (batchMaxLevelOut)
        {
            *batchMaxLevelOut = maxNewLogLevelType;
        }
 
        // A table that is not visible keeps only the count: its rows are rebuilt from the
        // store when it is shown again. Clear the level here too -- it is reported through
        // batchMaxLevelOut, and letting it accumulate would leave a hidden filter's badge
        // stuck at the highest level it ever saw.
        if (!materialised)
        {
            maxNewLogLevelType = eUNDEFINED;
            return addedCount;
        }
 
        const int firstRow = rowCount();
        // endInsertRows is emitted without rowsMutex held, because the view's rowsInserted
        // handler calls data(), which locks the same mutex.
        beginInsertRows(QModelIndex(), firstRow, firstRow + addedCount - 1);
        {
            std::unique_lock lock(rowsMutex);
            rows.insert(rows.end(),
                        std::make_move_iterator(accepted.begin()),
                        std::make_move_iterator(accepted.end()));
        }
        endInsertRows();
 
        // The views read getMaxNewLogLevelType() from their rowsInserted handler (emitted
        // by endInsertRows above), so it describes the batch that was just inserted and is
        // cleared again here.
        maxNewLogLevelType = eUNDEFINED;
 
        enforceMaxEntries();
        return addedCount;
    }
 
    void
    LogTableModel::setMaxEntries(std::size_t max)
    {
        maxEntries = max;
        enforceMaxEntries();
    }
 
    void
    LogTableModel::enforceMaxEntries()
    {
        if (maxEntries == 0 || !materialised)
        {
            return;
        }
 
        // Headroom factor: let the window grow to maxEntries * 1.3 before trimming back to
        // maxEntries, so the O(n) front-erase is amortized over many insertions instead of
        // running on every new message.
        constexpr double headroomFactor = 1.3;
 
        std::size_t currentSize;
        {
            std::unique_lock lock(rowsMutex);
            currentSize = rows.size();
        }
        if (currentSize <= static_cast<std::size_t>(maxEntries * headroomFactor))
        {
            return;
        }
 
        const int removeCount = static_cast<int>(currentSize - maxEntries);
        // endRemoveRows is emitted without rowsMutex held (the view may call data(), which
        // takes that mutex).
        beginRemoveRows(QModelIndex(), 0, removeCount - 1);
        {
            std::unique_lock lock(rowsMutex);
            rows.erase(rows.begin(), rows.begin() + removeCount);
        }
        endRemoveRows();
    }
 
    void
    LogTableModel::dropRowsBefore(LogSeq firstSeq)
    {
        if (!materialised)
        {
            return;
        }
 
        int removeCount = 0;
        {
            std::unique_lock lock(rowsMutex);
            const auto end = std::lower_bound(rows.begin(),
                                              rows.end(),
                                              firstSeq,
                                              [](const Row& r, LogSeq seq)
                                              { return r.seq < seq; });
            removeCount = static_cast<int>(std::distance(rows.begin(), end));
        }
        if (removeCount <= 0)
        {
            return;
        }
 
        beginRemoveRows(QModelIndex(), 0, removeCount - 1);
        {
            std::unique_lock lock(rowsMutex);
            rows.erase(rows.begin(), rows.begin() + removeCount);
        }
        endRemoveRows();
    }
 
    LogSeq
    LogTableModel::seqAt(int row) const
    {
        std::unique_lock lock(rowsMutex);
        if (row < 0 || row >= (signed int)rows.size())
        {
            return 0;
        }
        return rows[row].seq;
    }
 
    int
    LogTableModel::rowForSeq(LogSeq seq) const
    {
        std::unique_lock lock(rowsMutex);
        for (std::size_t row = 0; row < rows.size(); ++row)
        {
            if (rows[row].seq == seq)
            {
                return static_cast<int>(row);
            }
        }
        return -1;
    }
 
    bool
    LogTableModel::isRowMarked(int row) const
    {
        std::unique_lock lock(rowsMutex);
        if (row < 0 || row >= (signed int)rows.size())
        {
            return false;
        }
        return rows[row].markerColor.isValid();
    }
 
    int
    LogTableModel::getColumn(const std::string& columnName) const
    {
        if (columnName.empty())
        {
            return -1;
        }
 
        QString qcolumnName = QString::fromStdString(columnName);
 
        for (int i = 0; i < columnCount(QModelIndex()); i++)
        {
            if (headerData(i, Qt::Horizontal, Qt::DisplayRole).toString().compare(qcolumnName) == 0)
            {
                return i;
            }
        }
 
        return -1;
    }
 
    int
    LogTableModel::clearData()
    {
        // The store is shared, so clearing one filter can only clear this view. The
        // watermark keeps the cleared lines from reappearing when the rows are rebuilt
        // from the store (on hide/show, or on a filter change).
        if (store)
        {
            clearedBeforeSeq = store->endSeq();
        }
 
        int size = (int)rows.size();
        if (size == 0)
        {
            // Nothing to remove; beginRemoveRows(0, -1) would be an invalid range.
            return 0;
        }
        beginRemoveRows(QModelIndex(), 0, size - 1);
        {
            std::unique_lock lock(rowsMutex);
            rows.clear();
        }
        endRemoveRows();
        maxNewLogLevelType = eUNDEFINED;
        return size;
    }
 
    const LogMessage&
    LogTableModel::getLogEntry(size_t row) const
    {
        std::unique_lock lock(rowsMutex);
        const StoredLogEntry* stored = entryAt(static_cast<int>(row));
        if (!stored)
        {
            static const LogMessage empty{};
            return empty;
        }
        return stored->message;
    }
 
    int
    LogTableModel::lineCountAt(int row) const
    {
        std::unique_lock lock(rowsMutex);
        const StoredLogEntry* stored = entryAt(row);
        return stored ? stored->lineCount : 1;
    }
 
    bool
    LogTableModel::applyFilter(const LogFilter& filter, const LogMessage& logMsg)
    {
        // Substring match for manual filters; whole-value match for exact (auto) filters,
        // so e.g. the auto-filter for component "bar" does not also match "foo_bar".
        // Exact matches stay on std::string entirely; only the (rare, user-created)
        // substring filters convert the field, and never the filter value itself.
        const auto matches = [&filter](const std::string& field, Qt::CaseSensitivity cs)
        {
            if (filter.mode == MatchMode::Exact)
            {
                return cs == Qt::CaseSensitive ? field == filter.value
                                               : iEquals(field, filter.value);
            }
            return QString::fromStdString(field).contains(filter.qValue, cs);
        };
 
        switch (filter.column)
        {
            case LogColumn::Group:
                return matches(logMsg.group, Qt::CaseSensitive);
            case LogColumn::Component:
                return matches(logMsg.who, Qt::CaseInsensitive);
            case LogColumn::Tag:
                return matches(logMsg.tag, Qt::CaseInsensitive);
            case LogColumn::Verbosity:
                return !(logMsg.type < filter.intValue);
            case LogColumn::Message:
                return matches(logMsg.what, Qt::CaseInsensitive);
            case LogColumn::File:
                return matches(logMsg.file, Qt::CaseInsensitive) ||
                       filter.intValue == logMsg.line;
            case LogColumn::Function:
                return matches(logMsg.function, Qt::CaseInsensitive);
            case LogColumn::Time:
            case LogColumn::Unknown:
                break;
        }
 
        return true;
    }
 
    bool
    LogTableModel::applyFilters(const LogMessage& logMsg)
    {
        for (unsigned int i = 0; i < activeFilters.size(); i++)
        {
            if (!applyFilter(activeFilters[i], logMsg))
            {
                return false;
            }
        }
 
        return true;
    }
} // namespace armarx