ZblLogSearch.cpp

Go to the documentation of this file.

#include "ZblLogSearch.h"
#include "ZLogReclinkModel.h"
#include "ZLogReader.h"
#include "ZblLogReader.h"
#include "ZblLogLinkList.h"
#include "ZblLogBkSearch.h"
#include "ZblLogSearchParams.h"


namespace Zbl
{

QThread* ZblLogSearch::m_searcherThread = 0;


ZblLogSearch::ZblLogSearch(
        const QString& searchPhrase,
        int searchType,
        QList<int> searchRoles,
        ZblLogSearch::TextSearchDirections directions,
        qint64 startPosition,
        ZLogReader* reader
        ) : ZLogBookmark(reader), m_searchArea(reader),
    m_searchPhrase(searchPhrase),
    m_startPosition(startPosition),
    m_endSize(-1)
{
#if 1

    m_active = true;

    m_saved = false;

        m_searchType = zValidateSearchType(searchType);

        m_rolesSearched = QSet<int>::fromList(searchRoles);

        m_searchDirection = directions;

        m_searchState = BEGIN;

        QString markName = getSearchmarkName(searchPhrase, searchType, searchRoles);

        setMarkName(markName);

        m_searcher =  new ZblLogBkSearch(startPosition, getSearchParameters(), reader->getBackgroundReader());

        m_searcher->moveToThread(m_searcherThread);

        connect(m_searcher, &ZblLogBkSearch::searchRowsMatched, this, &ZblLogSearch::onSearchRowsMatched);

        //connect(reader, &ZblLogReader::linkMessageText, this, &ZblLogSearch::onLinkMessageText);
#endif
}


void ZblLogSearch::zInit()
{
    m_searcherThread = new QThread();
    m_searcherThread->start();
}

bool ZblLogSearch::validateReader(ZLogReader* reader)
{
    return reader == m_reader;
}


void ZblLogSearch::dismiss(QObject* search)
{
    ZblLogSearch* zSearch = qobject_cast<ZblLogSearch*>(search);

    if(!zSearch)
    {
        qWarning("Programming error: ZblLogSearch::dismiss called for invalid object type.");
        return;
    }

    //emit zSearch->detach();

    zSearch->deleteLater();
}

ZblLogBkSearch* ZblLogSearch::getSearcher()
{
    return m_searcher;
}



void ZblLogSearch::pause()
{

}

void ZblLogSearch::resume()
{

}

void ZblLogSearch::abort()
{

}


QString ZblLogSearch::getSearchmarkName(QString searchPhrase, int searchType, QList<int> searchRoles)
{
    QString markName("%1:%2:%3");
    markName = markName.arg(searchPhrase).arg(searchType).arg(getSearchRolesName(searchRoles));
    return markName;
}

QString ZblLogSearch::getSearchRolesName(QList<int> searchRoles)
{
    QString name;

     // eliminate duplicates

    QSet<int> roles = QSet<int>::fromList(searchRoles);

    searchRoles = roles.toList();

    // sort and concatenate

    std::sort(searchRoles.begin(), searchRoles.end());

    for(int i=0; i<searchRoles.count(); i++)
        name += QString("%1:").arg(searchRoles.at(i));

    return name;
}


#if 0

int ZLogSearch::appendModelRoles(ZTableModel* model, int nextRole)
{
    nextRole = ZLogBookmark::appendModelRoles(model, nextRole);
    model->addRole(nextRole++, "search_phrase");
    return nextRole;
}

void ZLogSearch::appendModelData(
        const MarkNode& logMark,
        ZDataRow data)
{
    ZLogBookmark::appendModelData(logMark, data);

    data.append(m_searchPhrase);
}

#endif

QString ZblLogSearch::getPhrase() const
{
    return m_searchPhrase;
}

int ZblLogSearch::getSearchType() const
{
    return m_searchType;
}

ZblLogSearch::searchState ZblLogSearch::getSearchState() const
{
    return m_searchState;
}


bool ZblLogSearch::getSearchForward() const
{
    return m_searchDirection & SearchDirectionForward;
}

void ZblLogSearch::setSearchForward(bool forward)
{
    // TBD: changing direction bits has state implications!

    if(forward)
        m_searchDirection = m_searchDirection | SearchDirectionForward;
    else
        m_searchDirection = m_searchDirection & ~SearchDirectionForward;
}

bool ZblLogSearch::getSearchBackward() const
{
    return m_searchDirection & SearchDirectionBackward;
}

void ZblLogSearch::setSearchBackward(bool backward)
{
    // TBD: changing direction bits has state implications!

    if(backward)
        m_searchDirection = m_searchDirection | SearchDirectionBackward;
    else
        m_searchDirection = m_searchDirection & ~SearchDirectionBackward;

}

ZblLogSearch::TextSearchDirections ZblLogSearch::getSearchDirections() const
{
    return m_searchDirection;
}

void ZblLogSearch::setSearchDirections(ZblLogSearch::TextSearchDirections directions)
{
    // TBD: changing direction bits has state implications!

    m_searchDirection = directions;

}

bool ZblLogSearch::getActive() const
{
    return m_active;
}

bool ZblLogSearch::getSaved() const
{
    return m_saved;
}

qint64 ZblLogSearch::getCompletionFileSize() const
{
    return m_endSize;
}

int ZblLogSearch::logMapType()
{
    return Searchmap;
}

void  ZblLogSearch::addRoleFound(int roleNumber)
{
    m_rolesFound.insert(roleNumber);
}

void ZblLogSearch::addRolesFound(QList<int> rolesFound)
{
    QSet<int>addSet = QSet<int>::fromList(rolesFound);

    m_rolesFound.unite(addSet);
}

void  ZblLogSearch::clearRolesFound()
{
    m_rolesFound.clear();
}

QList<int>  ZblLogSearch::getRolesFound() const
{
    return m_rolesFound.toList();
}

void ZblLogSearch::addSearchRole(int roleNumber)
{
    if(!m_rolesSearched.contains(roleNumber))
    {
        m_rolesSearched.insert(roleNumber);

        clear();
    }
}

void ZblLogSearch::addSearchRoles(QList<int> rolesToSearch)
{
    QSet<int>addSet = QSet<int>::fromList(rolesToSearch);

    if(!m_rolesSearched.contains(addSet))
    {
        m_rolesSearched.unite(addSet);

        clear();
    }
}

void ZblLogSearch::clearSearchRoles()
{
    m_rolesSearched.clear();

    clear();
}

QList<int> ZblLogSearch::getSearchRoles() const
{
    return m_rolesSearched.toList();
}

bool ZblLogSearch::containsSearchRoles(QList<int> searchRoles) const
{
    QSet<int> roleSet = QSet<int>::fromList(searchRoles);

    return m_rolesSearched.contains(roleSet);
}


bool ZblLogSearch::equalsSearchRoles(QList<int> searchRoles) const
{
    QSet<int> roleSet = QSet<int>::fromList(searchRoles);

    return m_rolesSearched == roleSet;
}

bool ZblLogSearch::isSearch(const QString& searchPhrase, int searchType, QList<int> searchRoles) const
{
    QSet<int> testRoles = QSet<int>::fromList(searchRoles);

    return (searchPhrase == m_searchPhrase) && (searchType == m_searchType) && (testRoles == m_rolesSearched);
}

bool ZblLogSearch::isNull()
{
    if(m_searchPhrase.isEmpty() || m_rolesSearched.isEmpty())
        return true;
    else
        return false;
}


void ZblLogSearch::onSearchRowMatched(
        qint64 recordID,
        qint64 seekPosition,
        QList<int> modelRoles)
{
    // TDB: this will be deprecated in favor of onSearchRowsMatched, below

    zDebug() << "Search row matched - id =" << recordID
             << "seekPosition =" << seekPosition << ", modelRoles ="
             << modelRoles;

    // TBD: send signal to add row to attached link data models

    insertMark(recordID, recordID, seekPosition);

    addRolesFound(modelRoles);

}

void ZblLogSearch::onSearchRowsMatched(ZblLogSearchList rowsFound)
{
    zDebug() << "Search rows matched, count = " << rowsFound.m_links.count();

    // TBD: should get message text here?

    const int rowCount = rowsFound.m_links.count();

    for(int i=0; i < rowCount; i++)
    {
        const ZblLogSearchList::LinkNode& nextNode = rowsFound.m_links.at(i);

        // TBD: should have insertMark convenience method for a single-record mark?

        insertMark(nextNode.m_recordID, nextNode.m_recordID, nextNode.m_seekPos);
    }
}


QObject* ZblLogSearch::linkModel()
{
    // TBD: make threadsafe? Should only be used in foreground thread

    QSharedPointer<ZblLogReclinkData> strongRef = m_linkModel.toStrongRef();

    if(!strongRef.isNull())
    {
        return new ZLogReclinkModel(strongRef);
    }
    else
    {
        QSharedPointer<ZblLogReclinkData>
                newRef(new ZblLogReclinkData(), deleteReclinkData);

        populateLinkModel(*newRef.data());

#if 0

        // TBD: should connect to onSearchRowsMatched instead?

        connect(this, &ZblLogSearch::searchRowMatched,
                newRef.data(), &ZblLogReclinkData::onSearchRowMatched);
#endif
        m_linkModel = newRef.toWeakRef();

        return new ZLogReclinkModel(newRef);
    }
}


void ZblLogSearch::deleteReclinkData(ZblLogReclinkData* data)
{
    // TBD: check if m_linkModel has a reference here - it should not!

    data->deleteLater();
}

void ZblLogSearch::populateLinkModel(ZblLogReclinkData& linkModel)
{
    ZDataRow data;
    ZblLogLinkList links = m_map.getLogLinkList();

    for(int i=0; i < links.m_links.count(); i++)
    {

        //qint64 id = it->getFirstID();

        const ZblLogLinkList::LinkNode& node = links.m_links.at(i);


        // WARNING: the following data.append() calls are order dependent!

        data.append(node.m_index);
        data.append(node.m_value);
        data.append(QVariant("<data unavailable>")); // dummy message

        // TBD: APPEND ROLES FOUND HERE?

        linkModel.zModel()->appendCells(data);
        data.clear();

    }

    //ZblLogReader* reader = getReader()->getBackgroundReader();

    QVariant vLinks(QVariant::fromValue<ZblLogLinkList>(links));

    QMetaObject::invokeMethod(m_reader, "loadRecordLinkMessageText",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, this),
                              Q_ARG(QVariant, vLinks));


}

void ZblLogSearch::onLinkTextComplete(QVariant linkList)
{
    zDebug() << "Processing onLinkTextComplete...";

    ZblLogLinkList links = linkList.value<Zbl::ZblLogLinkList>();

    QSharedPointer<ZblLogReclinkData> linkModel = m_linkModel.toStrongRef();

    if(linkModel.isNull())
        return;

    ZTableModel* tableModel = linkModel->zModel();

    for(int i=0; i<links.m_links.count(); i++)
    {
        const ZblLogLinkList::LinkNode& nextNode = links.m_links.at(i);

        zDebug() << "index = " << nextNode.m_index << ", text = " << nextNode.m_value;

        // TBD: is row index correct? only on first invocation? need to send model row number in message text request?

        tableModel->putValue(ZLogMap::MessageText, i, nextNode.m_value);
    }

    tableModel->invalidateModel();

}

bool ZblLogSearch::search(
        int direction,
        qint64 startPos
        )
{
    zDebug() << "search function entered...";

#if 0

    if(m_motionLock)
    {
        zDebug() << "Programming error - Can't search while background "
                    "operation is in progress.";

        return false;
    }
#endif

    //TBD: don't search if a search is already in progress
    //      validate columns exist in viewport model
    // validate type
    // validate phrase

    // TBD: check if search was already executed

        ZblLogSearchParams searchParams(getSearchParameters());

        //m_currentSearch->clear();

        // STATE_CHANGE: ENTER SCAN STATE

        QMetaObject::invokeMethod(m_searcher, "search",
                                  Qt::QueuedConnection,
                                  Q_ARG(QObject*, this),
                                  Q_ARG(ZblLogSearchParams, searchParams));

    return true;

}

ZblLogSearchParams ZblLogSearch::getSearchParameters()
{
    return ZblLogSearchParams(m_searchDirection,
                                    0,
                                    m_rolesSearched.toList(),
                                    m_searchPhrase,
                                    m_searchType);
}





} // Zbl