ZTextStream.cpp

Go to the documentation of this file.

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

namespace Zbl
{

QVariant ZTextStream::m_tags;

ZTextStream::ZTextStream(QObject *parent) :
    QObject(parent), m_d(nullptr)
{
    qDebug("ZTextStream creating input stream");

    m_t = new QTextStream(stdin, QFile::ReadOnly);

    if(!m_t)
        throw ZblException(
        "ZTextStream::ZTextStream - error creating QTextStream object");

    createTags();

    initZioDevice();
}

ZTextStream::ZTextStream(ZqIODevicePtr device, QObject *parent) :
    QObject(parent), m_d(device)
{
    m_t = new QTextStream();

    if(!m_t)
        throw ZblException(
        "ZTextStream::ZTextStream - error creating QTextStream object");

    m_t->setDevice(m_d.data());

    createTags();

    initZioDevice();
}

ZTextStream::ZTextStream(ZqStringPtr string, QObject *parent) :
    QObject(parent), m_d(nullptr), m_s(string)
{
    m_t = new QTextStream();

    if(!m_t)
        throw ZblException(
        "ZTextStream::ZTextStream - error creating QTextStream object");

    m_t->setString(m_s.data());

    createTags();

    initZioDevice();
}

ZTextStream::~ZTextStream()
{
    if(m_t)
        delete m_t;
}


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

    QVariantMap map;

    map.insert("SmartNotation", SmartNotation);
    map.insert("FixedNotation", FixedNotation);
    map.insert("ScientificNotation", ScientificNotation);

    map.insert("AlignLeft", AlignLeft);
    map.insert("AlignRight", AlignRight);
    map.insert("AlignCenter", AlignCenter);
    map.insert("AlignAccountingStyle", AlignAccountingStyle);

    map.insert("Ok", Ok);
    map.insert("ReadPastEnd", ReadPastEnd);
    map.insert("ReadCorruptData", ReadCorruptData);
    map.insert("WriteFailed", WriteFailed);

    map.insert("ShowBase", ShowBase);
    map.insert("ForcePoint", ForcePoint);
    map.insert("ForceSign", ForceSign);
    map.insert("UppercaseBase", UppercaseBase);
    map.insert("UppercaseDigits", UppercaseDigits);

    m_tags = QVariant::fromValue(map);
}

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

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

void ZTextStream::validateData() const
{
    if(!m_d && !m_s)
        throw ZblException("No device or string object available to stream.");

    if(!m_t)
        throw ZblException("Text stream object not initialized.");
}

void ZTextStream::validateReadable() const
{
    if(m_d && !m_d->isReadable())
        throw ZblException(
                "Error, device is not readable.");
}

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

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

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

void ZTextStream::setLocale(const QString &locale)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->setLocale(QLocale(locale));
    ZBL_SLOT_END_VOID(Z_FAC_JS,
    ZTextStream::getAutoDetectUnicode, getAutoDetectUnicode failed)
}

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

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

void ZTextStream::getQDevice(QIODevice** device)
{
    *device = m_t->device();
}


bool ZTextStream::getAutoDetectUnicode() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->autoDetectUnicode(),  false,
    Z_FAC_JS, ZTextStream::getAutoDetectUnicode, getAutoDetectUnicode failed)
}

void ZTextStream::setAutoDetectUnicode(bool autoDetectOn)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->setAutoDetectUnicode(autoDetectOn);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setAutoDetectUnicode,
                      setAutoDetectUnicode failed)
}

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

bool ZTextStream::atEnd() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->atEnd(),  true,
    Z_FAC_JS, ZTextStream::atEnd, atEnd failed)
}

QVariant ZTextStream::pos() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(QVariant(m_t->pos()),  true,
    Z_FAC_JS, ZTextStream::pos, pos failed)
}

uint ZTextStream::getNumberFlags() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_t->numberFlags()), 0,
    Z_FAC_JS, ZTextStream::getNumberFlags, getNumberFlags failed)
}

void ZTextStream::setNumberFlags(uint flags)
{
    ZBL_SLOT_BEGIN_TRY
            validateData();
    m_t->setNumberFlags(QTextStream::NumberFlags(flags));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setNumberFlags,
                      setNumberFlags failed)
}

uint ZTextStream::getRealNumberNotation() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_t->realNumberNotation()), 0,
    Z_FAC_JS, ZTextStream::getRealNumberNotation, getRealNumberNotation failed)
}

void ZTextStream::setRealNumberNotation(uint notation)
{
    ZBL_SLOT_BEGIN_TRY
            validateData();
    m_t->setRealNumberNotation(QTextStream::RealNumberNotation(notation));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setRealNumberNotation,
                      setRealNumberNotation failed)
}

uint ZTextStream::getFieldAlignment() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_t->fieldAlignment()), 0,
    Z_FAC_JS, ZTextStream::getFieldAlignment, getFieldAlignment failed)
}

void ZTextStream::setFieldAlignment(uint alignment)
{
    ZBL_SLOT_BEGIN_TRY
            validateData();
    m_t->setFieldAlignment(QTextStream::FieldAlignment(alignment));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setFieldAlignment,
                      setFieldAlignment failed)
}

int ZTextStream::getFieldWidth() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->fieldWidth(), 0,
    Z_FAC_JS, ZTextStream::getFieldWidth, getFieldWidth failed)
}

void ZTextStream::setFieldWidth(int width)
{
    ZBL_SLOT_BEGIN_TRY
            validateData();
    m_t->setFieldWidth(width);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setFieldWidth,
                      setFieldWidth failed)
}

int ZTextStream::getRealNumberPrecision() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->realNumberPrecision(), 0,
    Z_FAC_JS, ZTextStream::getRealNumberPrecision, getRealNumberPrecision failed)
}

void ZTextStream::setRealNumberPrecision(int precision)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->setRealNumberPrecision(precision);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setRealNumberPrecision,
                      setRealNumberPrecision failed)
}

uint ZTextStream::getPadChar() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(static_cast<uint>(m_t->padChar().unicode()), 0,
    Z_FAC_JS, ZTextStream::getPadChar, getPadChar failed)
}

void ZTextStream::setPadChar(uint ch)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->setPadChar(static_cast<char>(ch));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setPadChar,
                      setPadChar failed)
}

int ZTextStream::getIntegerBase() const
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->integerBase(), 0,
    Z_FAC_JS, ZTextStream::getIntegerBase, getIntegerBase failed)
}

void ZTextStream::setIntegerBase(int base)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->setIntegerBase(base);
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::setIntegerBase,
                      setIntegerBase failed)
}

QString ZTextStream::getString() const
{
    QString retString;
    ZBL_SLOT_BEGIN_TRY
    validateData();
    retString = *m_t->string();
    ZBL_SLOT_END_RETURN(retString, retString,
    Z_FAC_JS, ZTextStream::getString, getString failed)
}

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

void ZTextStream::release()
{
    ZBL_SLOT_BEGIN_TRY
    //m_t.clear();
    if(m_t)
    {
        delete m_t;
        m_t = nullptr;
    }
    m_d.clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::release, release failed)
}

void ZTextStream::reset()
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->reset();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::reset,
                      reset failed)
}

void ZTextStream::flush()
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->flush();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::flush,
                      flush failed)
}

bool ZTextStream::seek(QVariant pos)
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    ZBL_SLOT_END_RETURN(m_t->seek(pos.toLongLong()),  false,
    Z_FAC_JS, ZTextStream::getAutoDetectUnicode, getAutoDetectUnicode failed)
}

void ZTextStream::skipWhiteSpace()
{
    ZBL_SLOT_BEGIN_TRY
    validateData();
    m_t->skipWhiteSpace();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZTextStream::skipWhiteSpace,
                      skipWhiteSpace failed)
}

QString ZTextStream::readLine(qint64 maxSize)
{
    qDebug("ZTextStream::readLine maxsize = %d", maxSize);
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    ZBL_SLOT_END_RETURN(m_t->readLine(maxSize),  QString(),
    Z_FAC_JS, ZTextStream::readLine, readLine failed)
}

QString ZTextStream::read(qint64 maxSize)
{
    qDebug("ZTextStream::read");
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    ZBL_SLOT_END_RETURN(m_t->read(maxSize),  QString(),
    Z_FAC_JS, ZTextStream::read, read failed)
}

QString ZTextStream::readAll()
{
    qDebug("ZTextStream::readAll");
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    ZBL_SLOT_END_RETURN(m_t->readAll(),  QString(),
    Z_FAC_JS, ZTextStream::readAll, readAll failed)
}

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

readNumericDataType(signed short, ZTextStream, readShort)
readNumericDataType(unsigned short, ZTextStream, readUShort)
readNumericDataType(signed int, ZTextStream, readInt)
readNumericDataType(unsigned int, ZTextStream, readUInt)
readNumericDataType(signed long, ZTextStream, readLong)
readNumericDataType(unsigned long, ZTextStream, readULong)
readNumericDataType(qlonglong, ZTextStream, readLongLong)
readNumericDataType(qulonglong, ZTextStream, readULongLong)
readNumericDataType(float, ZTextStream, readFloat)
readNumericDataType(double, ZTextStream, readDouble)

uint ZTextStream::readChar()
{
    qDebug("ZTextStream::readChar");
    char c = 0;
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    *m_t >> c;
    ZBL_SLOT_END_RETURN(c,  0,
    Z_FAC_JS, ZTextStream::readChar, readChar failed)
}

QString ZTextStream::readString()
{
    qDebug("ZTextStream::readString");
    QString data;
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    *m_t >> data;
    ZBL_SLOT_END_RETURN(data,  data,
    Z_FAC_JS, ZTextStream::readString, readString failed)
}

QObject* ZTextStream::readBytes()
{
    qDebug("ZTextStream::readBytes");
    QByteArray data;
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    *m_t >> data;
    ZBL_SLOT_END_RETURN(new ZByteArray(data),  NULL,
    Z_FAC_JS, ZTextStream::readBytes, readBytes failed)
}



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


writeNumericDataType(signed short, ZTextStream, writeShort)
writeNumericDataType(unsigned short, ZTextStream, writeUShort)
writeNumericDataType(signed int, ZTextStream, writeInt)
writeNumericDataType(unsigned int, ZTextStream, writeUInt)
writeNumericDataType(signed long, ZTextStream, writeLong)
writeNumericDataType(unsigned long, ZTextStream, writeULong)
writeNumericDataType(qlonglong, ZTextStream, writeLongLong)
writeNumericDataType(qulonglong, ZTextStream, writeULongLong)
writeNumericDataType(float, ZTextStream, writeFloat)
writeNumericDataType(double, ZTextStream, writeDouble)

bool ZTextStream::writeChar(uint data)
{
    qDebug("ZTextStream::writeChar");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    *m_t << static_cast<char>(data);
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZTextStream::writeChar, writeChar failed)
}

bool ZTextStream::writeBytes(QObject* data)
{
    qDebug("ZTextStream::writeBytes");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    ZByteArray* zb = qobject_cast<ZByteArray*>(data);
    if(!zb)
        throw ZblException("Error: ZByteArray object expected. "
                           "Object passed was not a ZByteArray.");

    *m_t << zb->m_ba.data();
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZTextStream::writeBytes, writeBytes failed)
}

bool ZTextStream::writeString(const QString& text)
{
    qDebug("ZTextStream::writeString");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    *m_t << text;
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZTextStream::writeString, writeString failed)
}

bool ZTextStream::writeLine(const QString& text)
{
    qDebug("ZTextStream::writeLine");
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    *m_t << text << endl;
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZTextStream::writeLine, writeLine failed)
}


} // Zbl