ZblLogReader.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2015 Bob Dinitto
 *
 * Filename:   ZblLogReader.h
 * Created on: 11/22/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
 *
 */

#ifndef ZBLLOGREADER_H
#define ZBLLOGREADER_H

#include <QObject>
#include "zglobal.h"
#include <QFile>
#include <QMutex>
#include <QQueue>
#include <QJsonParseError>
#include <QUuid>
#include "ZblLogRecord.h"
#include "ZTableModel.h"
#include "ZSettings.h"
#include "ZblLogSearchParams.h"

namespace Zbl {

class ZTableModel;
class ZLogViewport;
class ZblLogBkSearch;
class ZblLogScanner;
//class ZblLogSearchParams;

class ZblLogReader : public QObject
{
    Q_OBJECT

    typedef QQueue<QByteArray> zRowBuffer;
    typedef QList<qint64> zSeekBuffer;
public:

    //typedef QMap<quint64, ZblLogMark> zLogMarkMap;

    explicit ZblLogReader(QObject *parent = 0);

    virtual ~ZblLogReader();

    static void zInit(int logRecordRoleCount);

    static ZblLogReader* newLogReader();

signals:

    void openComplete(bool success, QString errorMsg, QVariantMap contextMap);

    void loadRecordsComplete(QObject* viewport, QString errorMsg, QVariantMap contextMap);

    void loadComplete(
            QObject* viewport,
            ZblLogSearchParams searchParams,
            bool endOfData,
            QString errorMsg,
            QVariantMap context);

    void linkMessageText(
            QVariant linkList);


    void notifyFileSize(qint64 fileSize);

public slots:

    void openFile(const QString& filePath, QVariantMap contextMap = QVariantMap());

    void close();

    void loadViewport(
            QObject* viewport,
            qint64 seekPosition,
            qint64 viewportSize,
            ZblLogSearchParams searchParams,
            bool loadMarkupColumn = false,
            QVariantMap contextMap = QVariantMap());


    void move(
            QObject* viewport,
            qint64 recordCount,
            qint64 seekIndex,
            bool forward,
            ZblLogSearchParams searchParams,
            bool loadMarkupColumn);

    void loadRecordLinkMessageText(
            QObject* searchmark,
            QVariant links);

protected:

    class ZblLogError {

    public:

        ZblLogError():errorType(NO_ERROR){}

        enum zLogErrorType {
            NO_ERROR = 0,
            PARSE_ERROR,
            NOTARRAY_ERROR,
            FIELDCOUNT_ERROR
        };

        zLogErrorType errorType;

        QJsonParseError parseError;

        QString formatErrorString;
    };


    void timerEvent(QTimerEvent * event);


    void parseNextFileRecord(
            ZLogViewport* viewport,
            const QByteArray& ba,
            qint64 seekPos,
            ZblLogScanner &logScanner,
            ZDataRow& cellBuffer,
            ZblLogError& logError
            );

    void storeViewportData(
            ZDataRow& cellData,
            ZLogViewport* viewport,
            bool truncate = false);

    int parseAndStoreViewportData(
            zRowBuffer& logRecords,
            zSeekBuffer &seekPositions,
            qint64 rowCount,
            ZLogViewport* viewport,
            ZblLogScanner& logScanner);

    QString loadRowsAhead(
            ZLogViewport* viewport,
            qint64 seekPos,
            qint64 rowCount,
            bool truncate,
            const ZblLogSearchParams* searchParams,
            bool loadMarkupColumn,
            qint64& foundCount,
            qint64& storedCount,
            bool& eof
            );

    QString loadRowsBehind(
        ZLogViewport* viewport,
        qint64 seekPos,
        qint64 rowCount,
        const ZblLogSearchParams* searchParams,
        bool loadMarkupColumn,
        qint64& foundCount,
        qint64& storedCount,
        bool& bof);

    void initializeMetadata();

    ZBL_DECLARE_LOGGED_OBJECT

    QFile m_inputFile;

    bool m_fileActive;

    //zLogRecordList m_recordBuffer;

    //zLogMarkMap m_pageMap;

    static QMutex m_lock;

    static QThread* m_readerThread;

    static int m_readerCount;

    static qint64 m_defaultPageSize;

    static int m_recordRoleCount;

    const static int m_updateBatchSize;

    static const qint64 m_maxLineSize;


    ZSettings* m_notationFile;

    QVariantMap m_metadata;

    QUuid m_uuid;

    qint64 m_firstRecordPos;

    int m_timerID;

};

} // Zbl

#endif // ZBLLOGREADER_H