ZDataStream.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * Filename:   ZDataStream.cpp
 * Created on: 11/9/2014
 * 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 "ZDataStream.h"
#include "ZByteArray.h"
#include <QtQml>
#include "zglobal.h"

namespace Zbl
{

QVariant ZDataStream::m_tags;


void ZDataStream::createTags()
{
    if(!m_tags.isNull())
        return;

    QVariantMap map;

    map.insert("StatusOk", StatusOk);
    map.insert("StatusReadPastEnd", StatusReadPastEnd);
    map.insert("StatusReadCorruptData", StatusReadCorruptData);
    map.insert("StatusWriteFailed", StatusWriteFailed);

    map.insert("ByteOrderBigEndian", ByteOrderBigEndian);
    map.insert("ByteOrderLittleEndian", ByteOrderLittleEndian);

    map.insert("FpSinglePrecision", FpSinglePrecision);
    map.insert("FpDoublePrecision", FpDoublePrecision);

    map.insert("Version_Qt_1_0", Version_Qt_1_0);
    map.insert("Version_Qt_2_0", Version_Qt_2_0);
    map.insert("Version_Qt_2_1", Version_Qt_2_1);
    map.insert("Version_Qt_3_0", Version_Qt_3_0);
    map.insert("Version_Qt_3_1", Version_Qt_3_1);
    map.insert("Version_Qt_3_3", Version_Qt_3_3);
    map.insert("Version_Qt_4_0", Version_Qt_4_0);
    map.insert("Version_Qt_4_1", Version_Qt_4_1);
    map.insert("Version_Qt_4_2", Version_Qt_4_2);
    map.insert("Version_Qt_4_3", Version_Qt_4_3);
    map.insert("Version_Qt_4_4", Version_Qt_4_4);
    map.insert("Version_Qt_4_5", Version_Qt_4_5);
    map.insert("Version_Qt_4_6", Version_Qt_4_6);
    map.insert("Version_Qt_4_7", Version_Qt_4_7);
    map.insert("Version_Qt_4_8", Version_Qt_4_8);
    map.insert("Version_Qt_4_9", Version_Qt_4_9);
    map.insert("Version_Qt_5_0", Version_Qt_5_0);
    map.insert("Version_Qt_5_1", Version_Qt_5_1);
    map.insert("Version_Qt_5_2", Version_Qt_5_2);
    map.insert("Version_Qt_5_3", Version_Qt_5_3);
    map.insert("Version_Qt_5_4", Version_Qt_5_4);
    map.insert("Version_Qt_5_5", Version_Qt_5_5);
    map.insert("Version_Qt_5_6", Version_Qt_5_6);
    map.insert("Version_Qt_5_7", Version_Qt_5_7);
    map.insert("Version_Qt_5_8", Version_Qt_5_8);
    map.insert("Version_Qt_5_9", Version_Qt_5_9);
    map.insert("Version_Qt_5_10", Version_Qt_5_10);
    map.insert("Version_Qt_5_11", Version_Qt_5_11);
    map.insert("Version_Qt_5_12", Version_Qt_5_12);
    map.insert("Version_Qt_5_13", Version_Qt_5_13);

    m_tags = QVariant::fromValue(map);
}

ZDataStream::ZDataStream(QObject *parent) :
    QObject(parent)
{
    qDebug("ZDataStream::ZDataStream");

    initZioDevice();

    createTags();

}

ZDataStream::ZDataStream(ZqIODevicePtr device, QObject *parent) :
    QObject(parent), m_dv(device)
{
    qDebug("ZDataStream::ZDataStream - QIODevice");

    initZioDevice();

    createTags();

    m_ds = QDataStreamPtr::create();

    if(m_ds.isNull())
        throw ZblException(
        "ZDataStream::ZDataStream - error creating QDataStream object");

    m_ds->setDevice(m_dv.data());
}

ZDataStream::ZDataStream(ZqByteArrayPtr byteArray, QObject *parent) :
    QObject(parent), m_b(byteArray)
{
    qDebug("ZDataStream::ZDataStream - QByteArray");

    initZioDevice();

    createTags();

    m_ds.reset(new QDataStream(byteArray.data(), QIODevice::ReadWrite));

    if(m_ds.isNull())
        throw ZblException(
        "ZDataStream::ZDataStream - error creating QDataStream object");

    qDebug() << "ZDataStream::ZDataStream - " << m_ds->device()->errorString();
}

void ZDataStream::initZioDevice()
{
    m_zd = new ZioDevice(this);

    connect(m_zd, SIGNAL(getCurrentDevice(QIODevice**)),
            SLOT(getQDevice(QIODevice**)), Qt::DirectConnection);
}


void ZDataStream::registerType()
{
    qmlRegisterType<ZDataStream>("org.zuble.qml", 1, 0, "ZDataStream");
}

void ZDataStream::validateData() const
{
    if(!m_dv && !m_b)
        throw ZblException("No device or byte array object available to stream.");

    if(!m_ds)
        throw ZblException("Data stream object not initialized.");
}

void ZDataStream::validateReadable() const
{
    validateData();

    if(m_dv && !m_dv->isReadable())
        throw ZblException(
                "Error, device is not readable.");
}

void ZDataStream::validateWritable() const
{
    validateData();

    if(m_dv && !m_dv->isWritable())
        throw ZblException(
                "Error, device is not writable.");
}

void ZDataStream::release()
{
    ZBL_SLOT_BEGIN_TRY
    disconnect(m_zd, SIGNAL(getDevice(QIODevice**)), this,
            SLOT(getQDevice(QIODevice**)));
    m_ds.clear();
    m_b.clear();
    m_dv.clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDataStream::release, release failed)
}

void ZDataStream::resetStatus()
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_ds->resetStatus();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDataStream::resetStatus, resetStatus failed)
}

QObject* ZDataStream::getJsDevice()
{
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(m_zd,  NULL,
    Z_FAC_JS, ZDataStream::getJsDevice, getJsDevice failed)
}

void ZDataStream::getQDevice(QIODevice** device)
{
    *device = m_ds->device();
}

uint ZDataStream::getStatus() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_ds->status()),  false,
    Z_FAC_JS, ZDataStream::getStatus, getStatus failed)
}

QVariant ZDataStream::getTags()
{
    return m_tags;
}

void ZDataStream::setByteOrder(uint byteOrder)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_ds->setByteOrder(QDataStream::ByteOrder(byteOrder));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDataStream::setByteOrder, setByteOrder failed)
}

uint ZDataStream::getByteOrder() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_ds->byteOrder()),  false,
    Z_FAC_JS, ZDataStream::getByteOrder, getByteOrder failed)
}

void ZDataStream::setFloatingPointPrecision(uint floatingPointPrecision)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_ds->setFloatingPointPrecision(
    QDataStream::FloatingPointPrecision(floatingPointPrecision));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDataStream::setFloatingPointPrecision,
    setFloatingPointPrecision failed)
}

uint ZDataStream::getFloatingPointPrecision() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_ds->floatingPointPrecision()),  false,
    Z_FAC_JS, ZDataStream::getFloatingPointPrecision,
    getFloatingPointPrecision failed)
}

void ZDataStream::setVersion(uint version)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_ds->setVersion(QDataStream::Version(version));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZDataStream::setVersion, setVersion failed)
}

uint ZDataStream::getVersion() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_ds->version()),  false,
    Z_FAC_JS, ZDataStream::getVersion, getVersion failed)
}

bool ZDataStream::jWriteBytes(const QList<int> data)
{
    qDebug("ZDataStream::jWriteBytes");
    bool status = false;

    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    const int size = data.size();
    char* bytes = new char[size];

    for(int i = 0; i < size; i++)
        bytes[i] = static_cast<char>(data.at(i));

    qDebug("ZDataStream::jWriteBytes - writing %d bytes", size);

    m_ds->writeBytes(bytes, size);
    status = m_ds->status() == QDataStream::Ok;
    delete[] bytes;

    ZBL_SLOT_END_RETURN(status,  false,
    Z_FAC_JS, ZDataStream::jWriteBytes, jWriteBytes failed)
}

QList<int> ZDataStream::jReadBytes()
{
    qDebug("ZDataStream::jReadBytes");

    uint sizeReturned = 0;
    QList<int> array;
    char* data = NULL;

    ZBL_SLOT_BEGIN_TRY
    validateReadable();

    try
    {
        m_ds->readBytes(data, sizeReturned);

        qDebug("ZDataStream::jReadBytes - size returned = %u", sizeReturned);

        for(uint i = 0; i < sizeReturned; i++)
                array.append(data[i]);

        if(data)
            delete[] data;
    }
    catch(...)
    {
        if(data)
            delete[] data;
        throw;
    }
    ZBL_SLOT_END_RETURN(array, array,
    Z_FAC_JS, ZDataStream::jReadBytes, jReadBytes failed)

}

QObject* ZDataStream::zReadBytes()
{
    qDebug("ZDataStream::zReadBytes");
    QByteArray byteArray;
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    *m_ds.data() >> byteArray;
    ZBL_SLOT_END_RETURN(new ZByteArray(byteArray), NULL,
    Z_FAC_JS, ZDataStream::zReadBytes, zReadBytes failed)
}

bool ZDataStream::zWriteBytes(QObject* zByteArray)
{
    qDebug("ZDataStream::zWriteBytes");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    ZByteArray* pByteArray = qobject_cast<ZByteArray*>(zByteArray);
    if(!pByteArray)
    throw ZblException("Object passed is not a ZByteArray.");
    ZqByteArrayPtr byteArray(pByteArray->qByteArray());
    *m_ds.data() << *byteArray.data();
    ZBL_SLOT_END_RETURN(true, false,
    Z_FAC_JS, ZDataStream::zWriteBytes, zWriteBytes failed)
}


bool ZDataStream::jWriteRawData(const QList<int> data)
{
    qDebug("ZDataStream::jWriteBytes");
    bool status = false;

    ZBL_SLOT_BEGIN_TRY
    validateWritable();

    const int size = data.size();
    char* bytes = new char[size];

    try
    {
        for(int i = 0; i < size; i++)
            bytes[i] = static_cast<qint8>(data.at(i));

        qDebug("ZDataStream::jWriteRawData - writing %d bytes", size);

        m_ds->writeRawData(static_cast<const char*>(bytes), size);
        status = m_ds->status() == QDataStream::Ok;
        delete[] bytes;

    }
    catch(...)
    {
        delete[] bytes;
        throw;
    }

    ZBL_SLOT_END_RETURN(status,  false,
    Z_FAC_JS, ZDataStream::jWriteRawData, jWriteRawData failed)
}

QList<int> ZDataStream::jReadRawData(uint len)
{
    qDebug("ZDataStream::jReadRawData");

    int sizeReturned = 0;
    QList<int> array;
    char* data = new char[len];

    ZBL_SLOT_BEGIN_TRY
    validateReadable();

    try
    {
        sizeReturned = m_ds->readRawData(data, len);

        qDebug("ZDataStream::jReadRawData - size returned = %d", sizeReturned);

        if(sizeReturned == -1)
            throw ZblException("QDataStream::readRawData encountered an error.");

        for(int i = 0; i < sizeReturned; i++)
                array.append(data[i]);

        delete[] data;
    }
    catch(...)
    {
        if(data)
            delete[] data;
        throw;
    }
    ZBL_SLOT_END_RETURN(array, array,
    Z_FAC_JS, ZDataStream::jReadRawData, jReadRawData failed)

}

QObject* ZDataStream::zReadRawData(uint len)
{
    qDebug("ZDataStream::zReadRawData");
    QByteArray byteArray;

    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    int sizeReturned = 0;
    char* data = new char[len];

    try
    {
        sizeReturned = m_ds->readRawData(data, len);

        qDebug("ZDataStream::zReadRawData - size returned = %d", sizeReturned);

        if(sizeReturned == -1)
            throw ZblException("QDataStream::readRawData encountered an error.");

        byteArray.append(data, sizeReturned);

        delete[] data;
    }
    catch(...)
    {
        delete[] data;
        throw;
    }

    ZBL_SLOT_END_RETURN(new ZByteArray(byteArray), NULL,
    Z_FAC_JS, ZDataStream::zReadRawData, zReadRawData failed)
}

bool ZDataStream::zWriteRawData(QObject* zByteArray)
{
    qDebug("ZDataStream::zWriteRawData");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    ZByteArray* pByteArray = qobject_cast<ZByteArray*>(zByteArray);
    if(!pByteArray)
    throw ZblException("Object passed is not a ZByteArray.");
    ZqByteArrayPtr qByteArray(pByteArray->qByteArray());
    const int size = qByteArray->size();
    qDebug("ZDataStream::jWriteRawData - writing %d bytes", size);
    m_ds->writeRawData(qByteArray->constData(), size);
    ZBL_SLOT_END_RETURN(true, false,
    Z_FAC_JS, ZDataStream::zWriteRawData, zWriteRawData failed)
}

uint ZDataStream::skipRawData(uint len)
{
    qDebug("ZDataStream::skipRawData");
    int sizeReturned = -1;
    ZBL_SLOT_BEGIN_TRY
    sizeReturned = m_ds->skipRawData(len);
    ZBL_SLOT_END_RETURN(sizeReturned, -1,
    Z_FAC_JS, ZDataStream::skipRawData, skipRawData failed)
}



#define readNumericDataType(dataType, className, methodName) \
    dataType className::methodName() \
    { \
        qDebug("%s::%s", #className, #methodName); \
        dataType data = 0; \
        ZBL_SLOT_BEGIN_TRY \
        validateReadable(); \
        *m_ds >> data; \
        ZBL_SLOT_END_RETURN(data,  0, \
        Z_FAC_JS, className::methodName, methodName failed) \
    }

readNumericDataType(qint16, ZDataStream, readInt16)
readNumericDataType(quint16, ZDataStream, readUInt16)
readNumericDataType(qint32, ZDataStream, readInt32)
readNumericDataType(quint32, ZDataStream, readUInt32)
readNumericDataType(qint64, ZDataStream, readInt64)
readNumericDataType(quint64, ZDataStream, readUInt64)
readNumericDataType(float, ZDataStream, readFloat)
readNumericDataType(double, ZDataStream, readDouble)

quint8 ZDataStream::readByte()
{
    qDebug("ZDataStream::readChar");
    qint8 byte = 0;
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    *m_ds >> byte;
    ZBL_SLOT_END_RETURN(byte,  0,
    Z_FAC_JS, ZDataStream::readByte, readByte failed)
}

#define writeNumericDataType(dataType, className, methodName) \
    bool className::methodName(dataType data) \
    { \
        qDebug("%s::%s", #className, #methodName); \
        ZBL_SLOT_BEGIN_TRY \
        validateWritable(); \
        *m_ds << data; \
        ZBL_SLOT_END_RETURN(true,  false, \
        Z_FAC_JS, className::methodName, methodName failed) \
    }


writeNumericDataType(qint16, ZDataStream, writeInt16)
writeNumericDataType(quint16, ZDataStream, writeUInt16)
writeNumericDataType(qint32, ZDataStream, writeInt32)
writeNumericDataType(quint32, ZDataStream, writeUInt32)
writeNumericDataType(qint64, ZDataStream, writeInt64)
writeNumericDataType(quint64, ZDataStream, writeUInt64)
writeNumericDataType(float, ZDataStream, writeFloat)
writeNumericDataType(double, ZDataStream, writeDouble)

bool ZDataStream::writeByte(quint8 data)
{
    qDebug("ZDataStream::writeChar");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    *m_ds << data; //static_cast<qint8>(data);
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZDataStream::writeByte, writeByte failed)
}

#if 0
uint getStatus() const;
bool atEnd() const;
void setByteOrder(uint byteOrder);
uint getByteOrder() const;

void setFloatingPointPrecision(uint floatingPointPrecision);
uint getFloatingPointPrecision() const;

void setVersion(uint version);
uint getVersion() const;
#endif

} // Zbl