ZblLogScanner.cpp

Go to the documentation of this file.

#include "ZblLogScanner.h"
#include "ZblLogSearch.h"
#include "ZLogViewport.h"
#include "ZblLogManager.h"
#include <QSet>

namespace Zbl
{

const QString ZblLogScanner::m_highlightColor = "blue"; // TBD: should come from settings file

ZblLogScanner::ZblLogScanner()
{
    m_params = NULL;
    m_markupColumn = false;
    m_findCompleteSent = false;
    m_controlFlags = controlFlags(0);
}

ZblLogScanner::ZblLogScanner(
        const ZblLogSearchParams *searchParams,
        controlFlags control,
        bool markupColumn)
{
    m_params = searchParams;
    m_controlFlags = control;
    m_markupColumn = markupColumn;


    if(!m_markupColumn)
        m_controlFlags = m_controlFlags & (~HighlightSearchText);

    m_findCompleteSent = !signalFindComplete();
}

QVariantList ZblLogScanner::markupOrdinalRoleList(QVariantList data)
{
    const QList<int> roles = m_params->roles();

    const int roleCount = roles.count();
    //const int dataCount = data.count();

    for(int roleIndex=0; roleIndex < roleCount; roleIndex++)
    {
        if(roleIndex >= roleCount || roleIndex < 0)
            continue;

        bool searchTextFound = false;

        const int role = roles.at(roleIndex);

        QVariant next = data.at(role);

        data[role] = scanTextValue(next, searchTextFound);
    }

    return data;
}


// TBD: scanModelColumnRows method will take a model and chunk size, loop grabbing chunks
// from model and passing to markupTableColumnRows --> scanTableColumnRows(columnRows, markup, linklist*)


ZblLogSearchList ZblLogScanner::scanModelColumnRows(
        ZTableModel* model,
        int chunkSize,
        ZLogViewport* viewport,
        qint64 currentRecordID)
{
    ZblLogSearchList searchList;

    if(!chunkSize || !model)
        return searchList;

    const int modelRowCount = model->modelRowCount();

    const int chunkActualSize = chunkSize < modelRowCount ? chunkSize : modelRowCount;

    const int chunkCount = modelRowCount / chunkActualSize;

    const int chunkFraction = modelRowCount % chunkActualSize;

    QList<int> scanRoles = m_params->roles();

    if(signalRowsMatched() || (viewport && signalFindComplete()))
    {
        if(!scanRoles.contains(ZblLogManager::LogFieldRecordNum))
            scanRoles.append(ZblLogManager::LogFieldRecordNum);

        if(!scanRoles.contains(ZLogViewport::getSeekIndexRole()))
            scanRoles.append(ZLogViewport::getSeekIndexRole());
    }

    for(int i=0; i < chunkCount; i++)
    {
        const int startRow = i * chunkActualSize;

        QVariant vRows =
                model->getTableColumnRows(scanRoles, startRow, 0, chunkActualSize);

        ZTableRowList rows = vRows.value<ZTableRowList>();

        rows = scanTableColumnRows(rows, searchList, viewport);

        vRows = QVariant::fromValue<ZTableRowList>(rows);

        model->putTableColumnRows(vRows, startRow, 1);
    }

    if(chunkFraction)
    {
        const int startRow = chunkCount * chunkActualSize;

        QVariant vRows =
                model->getTableColumnRows( m_params->roles(), startRow, 0, chunkFraction);

        ZTableRowList rows = vRows.value<ZTableRowList>();

        rows = scanTableColumnRows(rows, searchList, viewport);

        vRows = QVariant::fromValue<ZTableRowList>(rows);

        model->putTableColumnRows(vRows, startRow, 0);
    }

#if 0

    if(m_search && signalRowsMatched() && !searchList.m_links.isEmpty())
        emit m_search->searchRowsMatched(searchList);

#endif

    return searchList;
}

ZTableRowList ZblLogScanner::scanTableColumnRows(
        ZTableRowList columnRows,
        ZblLogSearchList &searchList,
        ZLogViewport* viewport)
{
    ZTableRowList outRows;

    if(!m_params)
        return outRows;

    const int rowCount = columnRows.count();

    const QList<int>scanRoles = m_params->roles();


    // TBD: optionally create link list for searchRowMatched --> searchRowsMatched, optionally do markup operation

    for(int row=0; row < rowCount; row++)
    {

        QMap<int, QVariant> nextRow = columnRows.at(row);
        QList<int> roles = nextRow.keys();

        QMap<int, QVariant> outRow;
        QList<int> rolesFound;


        const int roleCount = roles.count();

        //qint64 lastRecordID = -1;

        for(int roleIndex = 0; roleIndex < roleCount; roleIndex++)
        {
            bool searchTextFound = false;

            const int role = roles.at(roleIndex);

            QVariant nextValue = nextRow.value(role);

            if(scanRoles.contains(role))
                nextValue = scanTextValue(nextValue, searchTextFound);

            if(outputHighlightedText())
                outRow.insert(role, nextValue);

            if(searchTextFound)
            {
                rolesFound.append(role);
            }
        }

        if(outputHighlightedText())
        {
            outRows.append(outRow);
            outRow.clear();
        }

        if(signalRowsMatched() && !rolesFound.isEmpty())
        {
            searchList.addRow(
                        getRowID(nextRow),
                        getRowSeekPos(nextRow),
                        rolesFound);
        }
    }

    return outRows;
}

QVariant ZblLogScanner::scanTextValue(QVariant data, bool &searchTextFound)
{
    if(!m_params)
    {
        searchTextFound = false;
        return QVariant();
    }

   QString markup;
   QString  text = data.toString();

   const int textLen = text.length();
   const int searchLen = m_params->phrase().length();

   if(!searchLen || !textLen)
       return data;

   QString fontStart = QString("<font color=\"%1\">").arg(m_highlightColor);

   int lastIx = 0;

   QString searchPhrase(m_params->phrase());

   for(int nextIx = text.indexOf(searchPhrase, 0, Qt::CaseInsensitive); nextIx != -1;
        nextIx = text.indexOf(searchPhrase, lastIx, Qt::CaseInsensitive))
    {
        searchTextFound = true;

        if(!outputHighlightedText())
            return data;

        markup += text.mid(lastIx, nextIx) + fontStart
                + text.mid(nextIx, searchLen)
                + "</font>";

        lastIx = nextIx + searchLen;
    }

    if(!searchTextFound)
        return data;

    if(textLen > lastIx + 1)
        markup += text.mid(lastIx);

    return QVariant(markup);
}

qint64 ZblLogScanner::getRowID(QMap<int, QVariant> row)
{
    return row.value(ZblLogManager::LogFieldRecordNum).toInt();
}

qint64 ZblLogScanner::getRowSeekPos(QMap<int, QVariant> row)
{
    return row.value(ZLogViewport::getSeekIndexRole()).toInt();
}

} // Zbl