ZblLogBkSearch.cpp

Go to the documentation of this file.

#include "ZblLogBkSearch.h"
#include <QtQml>
#include "ZLogViewport.h"
#include "ZblLogSearch.h"
#include "ZblLogManager.h"
#include "ZblLogReader.h"
#include "ZLogReader.h"
#include "ZblLogSearchParams.h"
#include "ZblLogScanner.h"
#include <QVariantMap>
#include <QVariant>

namespace Zbl
{
ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZblLogBkSearch)

ZblLogBkSearch::ZblLogBkSearch(
        qint64 startPosition,
        ZblLogSearchParams params,
        ZblLogReader* reader)
    : m_params(params), m_reader(reader), m_startPosition(startPosition), m_upPosition(-1), m_downPosition(-1)
{
    zDebug() << "ZblLogBkSearch::ZblLogBkSearch";

    // create input viewports for background scanning

    static const int vpSize = 100; // TBD - arbitrary choice - experiment to determine optimal size

    m_vpUp = new ZLogViewport(m_reader, vpSize, this, true);

    connect(m_vpUp, &ZLogViewport::moveComplete, this, &ZblLogBkSearch::onMoveComplete);

    m_vpDown = new ZLogViewport(m_reader, vpSize, this, true);

    connect(m_vpDown, &ZLogViewport::loadComplete, this, &ZblLogBkSearch::onLoadComplete);
}

ZblLogBkSearch::~ZblLogBkSearch()
{
    zDebug() << "ZblLogBkSearch::~ZblLogBkSearch";
}



void ZblLogBkSearch::zInit()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterUncreatableType<ZblLogBkSearch>("org.zuble.qml", 1, 0,
                    "ZblLogBkSearch", "ZblLogBkSearch is an internal Zuble type. Use ZLogReader instead.");

}

void ZblLogBkSearch::markupViewport(QObject* viewport)
{
    markupViewport(viewport, &m_params);
}

void ZblLogBkSearch::markupViewport(QObject* viewport, ZblLogSearchParams params)
{
    markupViewport(viewport, &params);
}

void ZblLogBkSearch::markupViewport(QObject* viewport, ZblLogSearchParams* params)
{
    zDebug() << "ZblLogBkSearch::markupViewport called";

    const int chunkSize = 500;

    ZLogViewport* signalVp = qobject_cast<ZLogViewport*>(viewport);

    if(!signalVp)
        throw ZblException("Error - viewport must be a ZLogViewport object.");

    ZTableModel* model = signalVp->getZModel();

    //zblLogSearchPtr search = signalVp->getZSearch();

    ZblLogScanner::controlFlags flags =
            ZblLogScanner::HighlightSearchText;
            //| ZblLogScanner::SendRowsMatchedSignal // TBD: NEED THIS NO SIGNALS NOW?
            //| ZblLogScanner::SendFindCompleteSignal;

    ZblLogScanner scanner(params, flags, true);

    ZblLogSearchList searchList = scanner.scanModelColumnRows(model, chunkSize, signalVp);

    emit markupUpdated(signalVp, searchList);

    zDebug() << "markupViewport returned";
}

void ZblLogBkSearch::startSearch()
{

    zDebug() << "startSearch function entered";

    // set up initial parameters

    m_upPosition = 0;

    // dispatch call to scanForward


    zDebug() << "invoking initial scanForward...";

    QMetaObject::invokeMethod(this, "scanForward",
                              Qt::QueuedConnection);


    zDebug() << "invoked initial scanForward...";

}


void ZblLogBkSearch::scanForward()
{
    zDebug() << "scanForward called for seek position: " << m_downPosition;

    QVariantMap context;
    //context.insert("zbl-search-scan", QVariant(true));

   qint64 vpSize = m_vpDown->getMaxRecordCount();

    const bool loadMarkupColumn = false;


    // load input viewport which will signal onLoadViewportComplete

    QMetaObject::invokeMethod(m_reader, "loadViewport",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, m_vpDown),
                              Q_ARG(qint64, m_downPosition),
                              Q_ARG(qint64, vpSize),
                              Q_ARG(ZblLogSearchParams, m_params),
                              Q_ARG(bool, loadMarkupColumn),
                              Q_ARG(QVariantMap, context));

}

void ZblLogBkSearch::onLoadComplete(
        bool eof,
        QString errorMsg,
        QVariantMap context)
{

    zDebug() << "onLoadComplete called";

    if(!errorMsg.isEmpty())
    {
        zWarning() << "Scanning file error encountered:" << errorMsg;
    }

    ZTableModel* model = m_vpDown->getZModel();

    ZblLogScanner::controlFlags flags = ZblLogScanner::SendRowsMatchedSignal;

    const int chunkSize = 27; // arbitrary size for testing

    ZblLogScanner scanner(&m_params, flags, false);

    scanner.scanModelColumnRows(model, chunkSize);


    if(!eof)
    {
        const int rowCount = model->modelRowCount();

        m_downPosition = model->getValue(m_vpDown->getSeekIndexRole(), rowCount-1, 0).toInt();

        zDebug() << "invoking continued scanForward...";

        QMetaObject::invokeMethod(this, "scanForward",
                                  Qt::QueuedConnection);

        zDebug() << "invoked continued scanForward...";
    }
}




void ZblLogBkSearch::onMoveComplete(
        qint64 rowsFound,
        qint64 rowsStored,
        bool endOfData,
        QString errorMsg)
{

}


#if 0
void ZblLogBkSearch::searchViewport(
        ZLogViewport* viewport,
        bool forward,
        qint64 startRow,
        const QList<int> roles,
        int type,
        const QString& searchPhrase,
        bool signalFirstFind,
        qint64 endRow
        )
{
    zDebug() << "searchViewport called";



}
#endif

ZblLogBkSearch* ZblLogBkSearch::newLogSearcher()
{


    return 0;
}

} // Zbl