ZLogReader.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZLogReader.cpp
 * Created on: 11/16/2015
 * Author:     Bob Dinitto
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include "ZLogReader.h"
#include "ZTableModel.h"
#include "ZblLogManager.h"
#include "ZApplication.h"
#include "ZblLogReader.h"
#include "ZLogViewport.h"
#include "ZLogBookmark.h"
#include "ZblLogSearch.h"
#include "ZblLogBkSearch.h"
#include "ZLogReclinkModel.h"
#include "ZblLogSearchParams.h"
#include "ZLogSearch.h"
#include <QJsonParseError>
#include <QJsonArray>
#include <QJsonDocument>
#include <QtQml>

namespace Zbl
{

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZLogReader)


ZLogReader::ZLogReader(QObject *parent) :
    QObject(parent), m_ready(false)
{
    //m_logModel = zLogMan.createLogBufferModel();

    m_reader = ZblLogReader::newLogReader();

    connect(m_reader, SIGNAL(openComplete(bool,QString,QVariantMap)),
            SLOT(onBackgroundOpenComplete(bool,QString,QVariantMap)));

    connect(m_reader, SIGNAL(notifyFileSize(qint64)),
            this, SIGNAL(notifyFileSize(qint64)));

    //connect(m_reader, SIGNAL(loadRecordsComplete(QObject*,QString,QVariantMap)),
    //        SLOT(onBackgroundLoadIndexComplete(QObject*,QString,QVariantMap)));


    m_model = new ZTableModel(this);

    m_model->setColumnCount(1);

    m_model->addRole(0, "searchObject");
}

ZLogReader::~ZLogReader()
{
    close();
}


void ZLogReader::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

    qmlRegisterType<ZLogReader>("org.zuble.qml", 1, 0, "ZLogReader");

    qmlRegisterUncreatableType<ZLogBookmark>("org.zuble.qml", 1, 0,
                    "ZLogBookmark", "ZLogBookmark objects are created using ZLogReader.");

    qmlRegisterUncreatableType<ZblLogSearch>("org.zuble.qml", 1, 0,
                    "ZblLogSearch", "ZblLogSearch objects are created automatically.");

    qmlRegisterUncreatableType<ZLogSearch>("org.zuble.qml", 1, 0,
                    "ZLogSearch", "ZLogSearch objects are created using ZLogReader.");

    qmlRegisterUncreatableType<ZLogReclinkModel>("org.zuble.qml", 1, 0,
                    "ZLogReclinkModel", "ZLogReclinkModel objects are created using ZLogSearch.");

    qRegisterMetaType<Zbl::ZblLogSearchList>("ZblLogSearchList");

    qRegisterMetaType<Zbl::ZblLogSearchParams>("ZblLogSearchParams");

    ZblLogReader::zInit(zLogMan.getLogBufferRoleCount());
    ZblLogSearch::zInit();
    ZblLogBkSearch::zInit();
}

#if 0
void ZLogReader::openLogFile(const QString& filePath)
{
    m_filePath = filePath;

    QVariantMap context;
    context.insert("loadOnOpen", QVariant(true));
    context.insert("recordCount", QVariant(-1));
    context.insert("recordIndex", QVariant(0));

    QMetaObject::invokeMethod(m_reader, "openFile",
                              Qt::QueuedConnection,
                              Q_ARG(const QString&, filePath),
                              Q_ARG(QVariantMap, context));
}
#endif

void ZLogReader::onBackgroundOpenComplete(bool success, QString errorMsg, QVariantMap contextMap)
{
    zDebug() << "Background log file opened!!";

    m_ready = success;

#if 0

    bool loadFile = contextMap.value("loadOnOpen", false).toBool();

    if(loadFile)
    {

    // create the viewport

        qint64 recordCount = contextMap.value("recordCount", QVariant(1000)).toInt();

        qint64 recordIndex = contextMap.value("recordIndex", QVariant(0)).toInt();

        ZLogViewport* viewport = new ZLogViewport(m_reader, m_searcher, recordCount);


    // load the viewport

    QMetaObject::invokeMethod(m_reader, "loadViewport",
                              Qt::QueuedConnection,
                              Q_ARG(QObject*, viewport),
                              Q_ARG(qint64, recordIndex), // record index
                              Q_ARG(qint64, recordCount), // viewport size
                              Q_ARG(QVariantMap, contextMap));

    }
    else
    {
        emit openComplete(m_filePath, success, errorMsg);
    }


#else
    emit openComplete(m_filePath, success, errorMsg);

#endif
}


#if 0
void ZLogReader::onBackgroundLoadIndexComplete(QObject *viewport,
        QString errorMsg,
        QVariantMap contextMap)
{
    emit loadComplete(viewport, errorMsg);
}
#endif

void ZLogReader::openFile(const QString& filePath)
{
    m_filePath = filePath;

    QVariantMap context;
    //context.insert("loadOnOpen", QVariant(false));
    //context.insert("recordCount", QVariant(0));
    //context.insert("recordIndex", QVariant(0));

    QMetaObject::invokeMethod(m_reader, "openFile",
                              Qt::QueuedConnection,
                              Q_ARG(const QString&, filePath),
                              Q_ARG(QVariantMap, context));
}

void ZLogReader::close()
{
    if(!m_ready)
        return;

    m_ready = false;

    emit closeAlert();

    purgeSearchModel();

    m_searchmarks.clear();

    QMetaObject::invokeMethod(m_reader,"close", Qt::QueuedConnection);
}

QObject* ZLogReader::newViewport()
{
    ZLogViewport* newVp = new ZLogViewport(m_reader, 0, this);

    //newVp->connect(this, &ZLogReader::searchDeleteRequested, newVp, &ZLogViewport::onSearchDeleteRequested);

    return newVp;
}

bool ZLogReader::getReady()
{
    return m_ready;
}

QString ZLogReader::getFilePath()
{
    return m_filePath;
}

ZblLogReader* ZLogReader::getBackgroundReader()
{
    return m_reader;
}


QObject* ZLogReader::newBookmark(const QString& name)
{
    ZLogBookmark* bookmark = NULL;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        if(hasBookmark(name))
        {
            QString msg("Error: Bookmark name: %1 already exists.");
            msg.arg(name);
            throw ZblException(msg);
        }

        //bookmark = new ZLogBookmark(this);

        bookmark->setMarkName(name);

        m_bookmarks.append(bookmark);


        connect(bookmark, &ZLogMap::selectionUpdated, this, &ZLogReader::bookmarksUpdated);

        emit bookmarksUpdated();
    }
    else
    {

        QMetaObject::invokeMethod(this,"newBookmark",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(ZLogBookmark*, bookmark),
                                  Q_ARG(const QString&, name)
                                  );
    }

    //zDebug() << "newBookmark returning name: " + bookmark->getMarkName();

    ZBL_SLOT_END_RETURN(bookmark, NULL,
    Z_FAC_JS, ZLogReader::newBookmark, newBookmark failed)
}

QObject* ZLogReader::getBookmark(const QString& name)
{
    ZLogBookmark* bookmark = NULL;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        const int count = m_bookmarks.count();

        for(int i=0; i<count; i++)
        {
            ZLogBookmark* nextMark = m_bookmarks.at(i);
            if(nextMark->getMarkName() == name)
            {
                bookmark = nextMark;
                break;
            }
        }
    }
    else
    {

        QMetaObject::invokeMethod(this,"getBookmark",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(ZLogBookmark*, bookmark),
                                  Q_ARG(const QString&, name)
                                  );
    }

    ZBL_SLOT_END_RETURN(bookmark, NULL,
    Z_FAC_JS, ZLogReader::getBookmark, getBookmark failed)

}

#if 0

QObject* ZLogReader::newSearchmark(const QString& searchPhrase, int searchType)
{
    ZLogSearch* searchmark = NULL;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        if(hasSearchmark(searchPhrase, searchType))
        {
            QString msg("Error: Searchmark phrase: %1 already exists.");
            msg.arg(searchPhrase);
            throw ZblException(msg);
        }

        QString markName = QString("Search: %1:%2").arg(searchType).arg(searchPhrase);

        searchmark = new ZLogSearch(this);

        searchmark->setMarkName(markName);

        searchmark->setPhrase(searchPhrase);

        searchmark->setSearchType(searchType);

        m_bookmarks.append(searchmark);

        //QObject::connect(searchmark, &ZLogMap::selectionUpdated, this, &ZLogReader::bookmarksUpdated);

        //emit bookmarksUpdated();
    }
    else
    {

        QMetaObject::invokeMethod(this,"newSearchmark",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(ZLogSearch*, searchmark),
                                  Q_ARG(const QString&, searchPhrase),
                                  Q_ARG(int, searchType)
                                  );
    }

    ZBL_SLOT_END_RETURN(searchmark, NULL,
    Z_FAC_JS, ZLogReader::newSearchmark, newSearchmark failed)
}
#endif

zblLogSearchPtr ZLogReader::getZSearch(const QString& searchPhrase, int searchType, QList<int> searchRoles)
{
    // empty search phrase always creates "null" search object - no roles and type 0

    QList<int> roles;
    int sType = 0;

    if(!searchPhrase.isEmpty())
    {
        roles = searchRoles;
        sType = searchType;
    }

    zDebug() << "ZLogReader returning search: " << searchPhrase << ";;;;; type=" << sType << "; roles=" << roles;

    QString searchName = ZblLogSearch::getSearchmarkName(searchPhrase, sType, roles);

    zDebug() << "Search name = " << searchName;

    QWeakPointer<ZblLogSearch> wkSearch = m_searchmarks.value(searchName);

    if(!wkSearch.isNull())
    {
        zblLogSearchPtr searchPtr(wkSearch.toStrongRef());

        if(!searchPtr.isNull())
        {
            zDebug() << "Returning existing search object.";

            return searchPtr;
        }
    }

#if 0
    ZblLogSearch* search = new ZblLogSearch(
                searchPhrase,
                searchType,
                searchRoles,
                ZblLogSearch::SearchDirectionForward,
                0,
                this);

#else
    ZblLogSearch* search = NULL;
#endif



    //zblLogSearchPtr newSearch(search,  &ZblLogSearch::dismiss);


#if 1

    zDebug() << "Creating new search object.";

    zblLogSearchPtr newSearch(
                new ZblLogSearch(
                searchPhrase,
                searchType,
                searchRoles,
                ZblLogSearch::SearchDirectionForward,
                0,
                this), &ZblLogSearch::dismiss);
#endif


    QQmlEngine::setObjectOwnership(newSearch.data(), QQmlEngine::CppOwnership);

    // TBD: should reserve mark name for end user?

    newSearch->setMarkName(searchName);

    //bool replacingExtantSearch = hasSearchMap(searchName);

    m_searchmarks.insert(searchName, newSearch.toWeakRef());

    appendSearchModel(newSearch);

    return newSearch;
}

void ZLogReader::appendSearchModel(zblLogSearchPtr search)
{
    zDebug() << "Adding search object to model: " << search->getMarkName();

    ZLogSearch* searchWrapper = new ZLogSearch(search, this);

    searchWrapper->setParent(this);

    QVariant vSearch = QVariant::fromValue(searchWrapper);

    ZDataRow row;

    row.append(vSearch);

    m_model->appendCells(row);
}

void ZLogReader::removeSearchModel(ZblLogSearch* search)
{
    zDebug() << "Removing search object from model: " << search->getMarkName();

    const int rowCount = m_model->modelRowCount();

    for(int i=0; i<rowCount; i++)
    {
        QVariant vSearch = m_model->getValue(0,i);

        ZLogSearch* wSearch = vSearch.value<ZLogSearch*>();

        QSharedPointer<ZblLogSearch> pSearch(wSearch->getZSearch());

        if(pSearch.data() == search)
        {
            if(pSearch->getMarkName() != search->getMarkName())
                zWarning() << "Mark name mismatch! -- " << search->getMarkName();

            m_model->removeRow(i);

            wSearch->deleteLater();

            return;
        }
    }
}

void ZLogReader::purgeSearchModel()
{
    zDebug() << "Removing all search objects from data model: " << m_filePath;

    const int rowCount = m_model->modelRowCount();

    for(int i=0; i<rowCount; i++)
    {
        QVariant vSearch = m_model->getValue(0,i);

        ZLogSearch* wSearch = vSearch.value<ZLogSearch*>();

        wSearch->deleteLater();
    }

    m_model->clearData();
}

QObject* ZLogReader::getSearchModel()
{
    return m_model;
}

bool ZLogReader::hasSearch(const QString& searchPhrase, int searchType, QList<int> searchRoles)
{
    return hasSearchMap(ZblLogSearch::getSearchmarkName(searchPhrase, searchType, searchRoles));
}

QObject* ZLogReader::getSearch(const QString& searchPhrase, int searchType, QList<int> searchRoles)
{
    zblLogSearchPtr searchObject(getZSearch(searchPhrase, searchType, searchRoles));

    ZLogSearch* searchWrapper = new ZLogSearch(searchObject, this);

    QObject::connect(searchObject.data(), &ZblLogSearch::invalidate, searchWrapper, &ZLogSearch::onInvalidate);

    return searchWrapper;
}

#if 0
void ZLogReader::purgeSearch()
{

    ZblLogSearch* zSearch = qobject_cast<ZblLogSearch*>(sender());

    if(!zSearch)
    {
        zWarning() << "Programming error: ZLogReader::purgeSearch() - Invalid connection or call!";
        return;
    }

    removeSearchModel(zSearch);

    int count = m_searchmarks.remove(zSearch->getMarkName());

    if(count == 0)
        zWarning() << "Programming error: Search object not found in search object map.";
}
#endif


bool ZLogReader::hasBookmark(const QString& name)
{
    const int count = m_bookmarks.count();

    for(int i=0; i<count; i++)
        if(m_bookmarks.at(i)->getMarkName() == name)
            return true;

    return false;
}

bool ZLogReader::hasSearchMap(const QString& searchName)
{
    QMap<QString, QWeakPointer<ZblLogSearch> >::iterator i = m_searchmarks.find(searchName);

    if(i == m_searchmarks.end())
        return false;

    zblLogSearchPtr searchObject(i.value());

    return !searchObject.isNull();
}



#if 0
bool ZLogReader::updateLogmark(const QObject* logMark, const QString& name)
{
    return false;
}
#endif


bool ZLogReader::setLogmapParameters(const QObject* parameters, const QString& name)
{
    return false;

}


bool ZLogReader::deleteBookmark(const QString& name)
{
    zDebug() << "ZLogReader::deleteBookmark function unimplelemted!";

    return false;

}

bool ZLogReader::deleteSearch(QObject* search)
{
    bool status = false;

    ZLogSearch* wSearch = qobject_cast<ZLogSearch*>(search);

    if(!wSearch)
    {
        zWarning() << "Programming error: search parameter must be a ZLogSearch object.";
        return status;
    }

    if(!wSearch->isValid())
        return status;

    zblLogSearchPtr pSearch(wSearch->getZSearch());

    if(pSearch->isNull())
    {
        zWarning() << "Programming error: dangling ZLogSearch object.";
        return status;
    }

    removeSearchModel(pSearch.data());

    QString searchName = pSearch->getMarkName();

    emit releaseSearchReferences(searchName);

    if(m_searchmarks.remove(searchName))
        status = true;

    pSearch->invalidate();

}

QMap<qint64, QStringList> ZLogReader::getBookmarkSet(qint64 firstID, qint64 lastID)
{
    QMap<qint64, QStringList> markset;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        if(firstID>lastID)
            throw ZblException("Error: lastID must be greater than or equal to firstID");

        for(qint64 i=firstID; i<=lastID; i++)
            markset.insert(i,getBookmarkNames(i));
    }
    else
    {
        QMetaObject::invokeMethod(this,"getBookmarkSet",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(zMarkSet, markset),
                                  Q_ARG(qint64, firstID),
                                  Q_ARG(qint64, lastID)
                                  );
    }

    ZBL_SLOT_END_RETURN(markset, zMarkSet(),
    Z_FAC_JS, ZLogReader::getBookmarkSet, getBookmarkSet failed)
}

QStringList ZLogReader::getBookmarkNames(qint64 recordID)
{
    QStringList names;

    ZBL_SLOT_BEGIN_TRY

    if(inObjectThread(this))
    {
        const int count = m_bookmarks.count();

        for(int i=0; i<count; i++)
        {
            ZLogBookmark* bookmark = m_bookmarks.at(i);

            if(bookmark->hasMark(recordID))
                names.append(bookmark->getMarkName());
        }
    }
    else
    {

        QMetaObject::invokeMethod(this,"getBookmarkNames",
                                  Qt::BlockingQueuedConnection,
                                  Q_RETURN_ARG(QStringList, names),
                                  Q_ARG(qint64, recordID)
                                  );
    }

    ZBL_SLOT_END_RETURN(names, QStringList(),
    Z_FAC_JS, ZLogReader::getBookmarkNames, getBookmarkNames failed)
}

QMap<qint64, QStringList> ZLogReader::getSearchmarkSet(qint64 firstID, qint64 lastID)
{
    return QMap<qint64, QStringList>();
}




#if 0
int ZLogReader::getMarkTypes(qint64 recordID)
{

    ZLogMap::MarkTypes markTypes = ZLogMap::Invalid;

    const int count = m_logMaps.count();

    for(int i=0; i<count; i++)
    {
        ZLogMap* nextMap = m_logMaps.at(i);

        ZLogMap::MarkType nextType = nextMap->getMarkType();

        if(nextType && markTypes)
            continue;

        if(nextMap->hasMark(recordID))
            markTypes |= nextType;

        if(markTypes == (ZLogMap::Selection | ZLogMap::Searchmap | ZLogMap::Bookmark))
            break;
    }

    return markTypes;

}

QList<QObject*> ZLogReader::getMarks(qint64 recordID, int markTypes)
{
    QList<QObject*> marks;

    const int count = m_logMaps.count();

    for(int i=0; i<count; i++)
    {
        ZLogMap* nextMap = m_logMaps.at(i);

        if((nextMap->getMarkType() | markTypes) && nextMap->hasMark(recordID))
            marks.append(nextMap);
    }

    return marks;
}
#endif

} // Zbl