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 <QFont>
 
#include <ArmarXCore/core/logging/LogSender.h>
 
#include "LogTable.h"
 
namespace armarx
{
    namespace
    {
        // Whole-line identity, matching LogMarkerRegistry: two rows are "the same line" iff
        // they share timestamp, component and message text.
        bool
        sameLine(const LogMessage& a, const LogMessage& b)
        {
            return a.time == b.time && a.who == b.who && a.what == b.what;
        }
 
        // 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;
        }
 
        // Format the time column (0) value the same way the model previously did inline,
        // but guard the substr against a missing space (which would otherwise throw).
        QString
        formatTime(Ice::Long timeMicroSeconds)
        {
            IceUtil::Time time = IceUtil::Time::microSeconds(timeMicroSeconds);
            std::string timeStr = time.toDateTime();
            const auto spacePos = timeStr.find(' ');
            if (spacePos != std::string::npos)
            {
                timeStr = timeStr.substr(spacePos);
            }
            return QString::fromStdString(timeStr);
        }
 
        // Build the message column (4) display string (truncated to a maximum number of
        // lines) and report how many display lines it spans.
        QString
        buildDisplayMessage(const LogMessage& entry, int& lineCount)
        {
            QString whatStr = entry.backtrace.empty()
                                  ? QString::fromStdString(entry.what)
                                  : QString::fromStdString(entry.what + "\nBacktrace:\n...");
 
            constexpr int maxLinesToShow = 50;
            int lines = 0;
            int pos = 0;
            for (int i = 0; i < whatStr.length(); i++)
            {
                if (whatStr.at(i) == '\n')
                {
                    lines++;
                }
                if (lines == maxLinesToShow)
                {
                    break;
                }
                pos++;
            }
            if (lines >= maxLinesToShow)
            {
                whatStr.truncate(pos);
                whatStr += "\n...";
            }
 
            lineCount = whatStr.count('\n') + 1;
            return whatStr;
        }
    } // namespace
 
    LogTableModel::LogTableModel(QObject* parent) : QAbstractTableModel(parent)
    {
        newEntryCount = 0;
        maxNewLogLevelType = eUNDEFINED;
    }
 
    int
    LogTableModel::rowCount(const QModelIndex& parent) const
    {
        return logEntries.size();
    }
 
    int
    LogTableModel::columnCount(const QModelIndex& parent) const
    {
        return 8;
    }
 
    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(logEntriesMutex);
                if (row >= (signed int)logEntries.size() || row < 0)
                {
                    return QString("n/A");
                }
 
                const LogMessage& entry = logEntries[row].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(logEntriesMutex);
 
                //std::cout << "row " << row << " column:" << column << std::endl;
                if (row >= (signed int)logEntries.size() || row < 0)
                {
                    return QString("n/A");
                }
 
                const LogEntry& logEntry = logEntries[row];
                const LogMessage& entry = logEntry.message;
 
                switch (column)
                {
                    case 0:
                    {
                        return logEntry.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 logEntry.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 native rows.
                std::unique_lock lock(logEntriesMutex);
                if (row >= 0 && row < (signed int)logEntries.size() && logEntries[row].injected)
                {
                    QFont font;
                    font.setItalic(true);
                    return font;
                }
                return QVariant();
            }
 
            case Qt::BackgroundColorRole:
            {
                // Pinned rows: full-row label color, overriding verbosity color and search
                // highlight (see the concept: "Full-row background").
                {
                    std::unique_lock lock(logEntriesMutex);
                    if (row >= 0 && row < (signed int)logEntries.size() &&
                        logEntries[row].markerColor.isValid())
                    {
                        return logEntries[row].markerColor;
                    }
                }
 
                if (column == 3) // Log Level color
                {
                    if (row >= (signed int)logEntries.size() || row < 0)
                    {
                        return QVariant();
                    }
 
                    const LogMessage& entry = logEntries[row].message;
 
                    switch (entry.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();
                }
 
 
                std::unique_lock lock(logEntriesMutex);
 
                //std::cout << "row " << row << " column:" << column << std::endl;
                if (row >= (signed int)logEntries.size() || row < 0)
                {
                    return QVariant();
                }
 
                if (logEntries[row].matchesSearch)
                {
                    return QColor(255, 244, 127);
                }
                else
                {
                    return QVariant();
                }
            }
 
                //        case Qt::SizeHintRole:
                //        {
                //            if(column == 4)
                //            {
                ////                const armarx::LogMessage & entry = logEntries[row];
                ////                int lines = std::count(entry.what.begin(), entry.what.end(), '\n') +1 ;
                ////                if(lines > 5)
                ////                    lines = 5;
                ////                std::cout << "SizeHintRole lines: " << lines << "-> " << lines*14 << std::endl;
                //                return QSize(350,logRowSize[row]);
                //            }
 
                //        }
        }
 
        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::unique_lock lock(logEntriesMutex);
            const bool hasSearch = searchStr.length() > 0;
            for (LogEntry& logEntry : logEntries)
            {
                logEntry.matchesSearch =
                    hasSearch && msgContainsString(logEntry.message, searchStr);
            }
        }
 
        if (!logEntries.empty())
        {
            emit dataChanged(index(0, 0), index(logEntries.size() - 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("");
                }
            }
        }
 
        //    else if(role == Qt::SizeHintRole)
        //    {
        //        QSize size(100,18);
        //        if (orientation == Qt::Horizontal) {
        //            std::cout << "size of header questioned" << std::endl;
        //            switch (section)
        //            {
        //                case 0:
        //                case 1:
        //                case 2:
        //                    size.setWidth(90);
        //                    return size;
        //                case 3:
        //                    size.setWidth(60);
        //                    return size;
        //                case 4:
        //                    size.setWidth(350);
        //                    return size;
        //                case 5:
        //                    size.setWidth(150);
        //                    return size;
        //                case 6:
        //                    size.setWidth(200);
        //                    return size;
        //                default:
        //                    std::cout << "standard size" << std::endl;
        //                    return size;
        //            }
        //        }
        //    }
 
        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::updateView()
    {
        //    QModelIndex topLeft = createIndex(0,0);
        //    emit dataChanged(topLeft, topLeft);
        QModelIndex leftTop = index(logEntries.size() - newEntryCount, 0);
        QModelIndex rightBottom = index(logEntries.size() - 1, 6);
        //    std::cout << "updating  " << leftTop.row() << " til " << rightBottom.row() << std::endl;
        emit dataChanged(leftTop, rightBottom);
        newEntryCount = 0;
        maxNewLogLevelType = eUNDEFINED;
    }
 
    bool
    LogTableModel::insertRows(int row, int count, const QModelIndex& parent)
    {
        beginInsertRows(QModelIndex(), row, row + count - 1);
        int newEntries = row + count - logEntries.size();
 
        for (int i = 0; i < newEntries; i++)
        {
            logEntries.push_back(LogEntry());
        }
 
        endInsertRows();
        return true;
    }
 
    void
    LogTableModel::addFilter(const std::string& columnName,
                             const std::string& filter,
                             MatchMode mode)
    {
        activeFilters.push_back(LogFilter{columnFromName(columnName), filter, mode});
    }
 
    void
    LogTableModel::reapplyAllFilters()
    {
        // Rebuild the kept entries in one pass instead of erasing in a loop. The old
        // code did `it = erase(it); it--;`, which steps before begin() when the first
        // element is dropped (UB), and vector::erase-per-row is O(n^2). A single reset
        // is correct and cheap for this (non-hot) path.
        beginResetModel();
        {
            std::unique_lock lock(logEntriesMutex);
            std::vector<LogEntry> kept;
            kept.reserve(logEntries.size());
            for (LogEntry& logEntry : logEntries)
            {
                if (applyFilters(logEntry.message))
                {
                    kept.push_back(std::move(logEntry));
                }
            }
            logEntries.swap(kept);
        }
        newEntryCount = 0;
        maxNewLogLevelType = eUNDEFINED;
        endResetModel();
 
        // Re-apply drops injected pins (they do not pass the filters) and may change which
        // native rows exist; rebuild the injected set and re-color accordingly.
        refreshMarkers();
    }
 
    void
    LogTableModel::resetFilters()
    {
        activeFilters.clear();
    }
 
    LogTableModel::LogEntry
    LogTableModel::buildLogEntry(const LogMessage& message) const
    {
        LogEntry entry;
        entry.message = message;
        entry.timeString = formatTime(message.time);
        entry.displayMessage = buildDisplayMessage(message, entry.lineCount);
        entry.matchesSearch =
            !activeSearchStr.isEmpty() && msgContainsString(message, activeSearchStr);
        if (markerRegistry)
        {
            if (const LogMarker* marker = markerRegistry->markerForMessage(message))
            {
                entry.markerColor = marker->color;
            }
        }
        return entry;
    }
 
    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()
    {
        // Snapshot the markers before taking logEntriesMutex; the registry has its own lock
        // (lock order is always logEntriesMutex -> registry mutex, never the reverse).
        std::vector<LogMarker> markers;
        if (markerRegistry)
        {
            markers = markerRegistry->markers();
        }
 
        beginResetModel();
        {
            std::unique_lock lock(logEntriesMutex);
 
            // 1. Drop previously injected pin rows.
            logEntries.erase(std::remove_if(logEntries.begin(),
                                            logEntries.end(),
                                            [](const LogEntry& e) { return e.injected; }),
                             logEntries.end());
 
            // 2. Re-color native rows from the current registry.
            for (LogEntry& entry : logEntries)
            {
                entry.markerColor = QColor();
                for (const LogMarker& marker : markers)
                {
                    if (sameLine(marker.snapshot, entry.message))
                    {
                        entry.markerColor = marker.color;
                        break;
                    }
                }
            }
 
            // 3. Inject markers not present as a native row, in time position, so a line
            // pinned in another filter still appears here.
            for (const LogMarker& marker : markers)
            {
                const bool present = std::any_of(
                    logEntries.begin(),
                    logEntries.end(),
                    [&marker](const LogEntry& e)
                    { return !e.injected && sameLine(marker.snapshot, e.message); });
                if (present)
                {
                    continue;
                }
 
                LogEntry injected = buildLogEntry(marker.snapshot);
                injected.injected = true;
                injected.markerColor = marker.color;
 
                std::size_t idx = 0;
                while (idx < logEntries.size() &&
                       logEntries[idx].message.time <= marker.snapshot.time)
                {
                    ++idx;
                }
                logEntries.insert(logEntries.begin() + idx, std::move(injected));
            }
        }
        endResetModel();
    }
 
    int
    LogTableModel::rowForMessage(const LogMessage& message) const
    {
        std::unique_lock lock(logEntriesMutex);
        for (std::size_t row = 0; row < logEntries.size(); ++row)
        {
            if (sameLine(logEntries[row].message, message))
            {
                return static_cast<int>(row);
            }
        }
        return -1;
    }
 
    bool
    LogTableModel::containsNativeLine(const LogMessage& message) const
    {
        std::unique_lock lock(logEntriesMutex);
        for (const LogEntry& entry : logEntries)
        {
            if (!entry.injected && sameLine(entry.message, message))
            {
                return true;
            }
        }
        return false;
    }
 
    bool
    LogTableModel::isRowMarked(int row) const
    {
        std::unique_lock lock(logEntriesMutex);
        if (row < 0 || row >= (signed int)logEntries.size())
        {
            return false;
        }
        return logEntries[row].markerColor.isValid();
    }
 
    bool
    LogTableModel::addEntry(const LogMessage& entry, int* entriesAdded)
    {
        if (entriesAdded)
        {
            *entriesAdded = 0;
        }
 
        if (!applyFilters(entry))
        {
            return false;
        }
 
        // Precompute the derived display data once, so the hot data() / rendering paths
        // never recompute time formatting or the message line count per repaint.
        LogEntry logEntry = buildLogEntry(entry);
 
        // New row: bracket the container mutation with begin/endInsertRows so the view
        // stays consistent (previously the push happened outside any begin/end block).
        // endInsertRows is emitted without logEntriesMutex held, because the view's
        // rowsInserted handler calls data(), which locks the same mutex.
        const int insertRow = rowCount();
        beginInsertRows(QModelIndex(), insertRow, insertRow);
        {
            std::unique_lock lock(logEntriesMutex);
            newEntryCount++;
            if (entry.type > maxNewLogLevelType)
            {
                maxNewLogLevelType = entry.type;
            }
            logEntries.push_back(std::move(logEntry));
        }
        endInsertRows();
 
        if (entriesAdded)
        {
            (*entriesAdded)++;
        }
        return true;
    }
 
    int
    LogTableModel::addEntries(const std::vector<LogMessage>& entryList, const QString& filterStr)
    {
        if (entryList.size() == 0)
        {
            return 0;
        }
 
        int entriesAdded = 0;
 
        // Each addEntry now brackets its own insertion with begin/endInsertRows, so we
        // no longer issue a batch begin/endInsertRows here (which used to run *after* the
        // rows were already appended, violating the model/view contract).
        for (const LogMessage& entry : entryList)
        {
            if (addEntry(entry))
            {
                entriesAdded++;
            }
        }
        if (entriesAdded > 0)
        {
            updateView();
            enforceMaxEntries();
        }
        return entriesAdded;
    }
 
    void
    LogTableModel::setMaxEntries(std::size_t max)
    {
        maxEntries = max;
        enforceMaxEntries();
    }
 
    void
    LogTableModel::enforceMaxEntries()
    {
        if (maxEntries == 0)
        {
            return;
        }
 
        // Headroom factor: let the buffer 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(logEntriesMutex);
            currentSize = logEntries.size();
        }
        if (currentSize <= static_cast<std::size_t>(maxEntries * headroomFactor))
        {
            return;
        }
 
        const int removeCount = static_cast<int>(currentSize - maxEntries);
        // endRemoveRows is emitted without logEntriesMutex held (the view may call data(),
        // which takes that mutex).
        beginRemoveRows(QModelIndex(), 0, removeCount - 1);
        {
            std::unique_lock lock(logEntriesMutex);
            logEntries.erase(logEntries.begin(), logEntries.begin() + removeCount);
        }
        endRemoveRows();
    }
 
    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()
    {
        int size = (int)logEntries.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(logEntriesMutex);
            logEntries.clear();
        }
        endRemoveRows();
        newEntryCount = 0;
        maxNewLogLevelType = eUNDEFINED;
        return size;
    }
 
    const LogMessage&
    LogTableModel::getLogEntry(size_t row) const
    {
        return logEntries.at(row).message;
    }
 
    int
    LogTableModel::lineCountAt(int row) const
    {
        std::unique_lock lock(logEntriesMutex);
        if (row < 0 || row >= (signed int)logEntries.size())
        {
            return 1;
        }
        return logEntries[row].lineCount;
    }
 
    bool
    LogTableModel::applyFilter(const LogFilter& filter, const LogMessage& logMsg)
    {
        const QString filterStr = QString::fromStdString(filter.value);
 
        // 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".
        const auto matches = [&filter, &filterStr](const std::string& field,
                                                   Qt::CaseSensitivity cs)
        {
            const QString value = QString::fromStdString(field);
            return filter.mode == MatchMode::Exact ? value.compare(filterStr, cs) == 0
                                                   : value.contains(filterStr, 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 < filterStr.toInt());
            case LogColumn::Message:
                return matches(logMsg.what, Qt::CaseInsensitive);
            case LogColumn::File:
                return matches(logMsg.file, Qt::CaseInsensitive) ||
                       filterStr.toInt() == 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;
    }
 
    //bool LogTableModel::applyFilter(std::pair filter, int row)
    //{
    //    int selectedColumn = getColumn(filter.first);
 
    //    if(selectedColumn == -1)
    //    {
    //        ARMARX_WARNING << "Could not find column " << filter.first << flush;
    //        return true;
    //    }
 
    //    return true;
    //}
} // namespace armarx