ZioDevice.cpp

Go to the documentation of this file.

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

namespace Zbl {

QVariant ZioDevice::m_tags;


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

    QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership); // TBD: need this? parent has QmlEngine ownership.

    createTags();
}



void ZioDevice::registerType()
{
    qmlRegisterUncreatableType<ZioDevice>
            ("org.zuble.qml", 1, 0, "ZioDevice",
             QString("ZioDevice is obtained from \"device\" property "
                     "of the I/O object you are reading or writing."));
}

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

    QVariantMap map;

    map.insert("NotOpen", QIODevice::NotOpen);
    map.insert("ReadOnly", QIODevice::ReadOnly);
    map.insert("WriteOnly", QIODevice::WriteOnly);
    map.insert("ReadWrite", QIODevice::ReadWrite);
    map.insert("Append", QIODevice::Append);
    map.insert("Truncate", QIODevice::Truncate);
    map.insert("Text", QIODevice::Text);
    map.insert("Unbuffered", QIODevice::Unbuffered);

    m_tags = QVariant::fromValue(map);
}


bool ZioDevice::isOpen() const
{
    qDebug("ZioDevice::isOpen");
    bool openFlag = false;
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    openFlag = device->isOpen();
    ZBL_SLOT_END_RETURN(openFlag,  openFlag,
    Z_FAC_JS, ZioDevice::isOpen, isOpen failed)
}

int ZioDevice::openMode() const
{
    qDebug("ZioDevice::openMode");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(static_cast<uint>(device->openMode()),
                        ZioDevice::NotOpen, Z_FAC_JS, ZioDevice::openMode, openMode failed)
}

bool ZioDevice::getTextMode() const
{
    qDebug("ZioDevice::getTextMode");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->isTextModeEnabled(),  false,
    Z_FAC_JS, ZioDevice::getTextMode, getTextMode failed)
}

void ZioDevice::setTextMode(bool textModeEnabled)
{
    qDebug("ZioDevice::setTextMode");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    device->setTextModeEnabled(textModeEnabled);
    ZBL_SLOT_END_VOID(Z_FAC_JS,
    ZioDevice::setTextMode, setTextMode failed)
}

qint64 ZioDevice::size() const
{
    qDebug("ZioDevice::size");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->size(),  -1,
    Z_FAC_JS, ZioDevice::size, size failed)
}

qint64 ZioDevice::pos() const
{
    qDebug("ZioDevice::pos");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->pos(),  -1,
    Z_FAC_JS, ZioDevice::pos, pos failed)
}

qint64 ZioDevice::bytesAvailable() const
{
    qDebug("ZioDevice::bytesAvailable");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->bytesAvailable(),  -1,
    Z_FAC_JS, ZioDevice::bytesAvailable, bytesAvailable failed)
}

qint64 ZioDevice::bytesToWrite() const
{
    qDebug("ZioDevice::bytesToWrite");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->bytesToWrite(),  -1,
    Z_FAC_JS, ZioDevice::bytesToWrite, bytesToWrite failed)
}



bool ZioDevice::isSequential()
{
    qDebug("ZioDevice::isSequential");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->isSequential(), false,
    Z_FAC_JS, ZioDevice::isSequential, isSequential failed)
}


bool ZioDevice::isWritable() const
{
    qDebug("ZioDevice::isWritable");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->isWritable(), false,
    Z_FAC_JS, ZioDevice::isWritable, isWritable failed)

}

bool ZioDevice::isReadable() const
{
    qDebug("ZioDevice::isSequential");
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->isReadable(), false,
    Z_FAC_JS, ZioDevice::isReadable, isReadable failed)

}

bool ZioDevice::atEnd() const
{
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->atEnd(),  true,
    Z_FAC_JS, ZioDevice::atEnd, atEnd failed)
}


QIODevice* ZioDevice::connectedDevice() const
{
    QIODevice* dev = nullptr;
    emit getCurrentDevice(&dev);
    if(!dev)
        throw ZblException("Error: No connected Device.");
    return dev;
}



QString ZioDevice::getErrorString()
{
    QIODevice* device = nullptr;

    emit getCurrentDevice( &device);

    if(device == nullptr)
        return QString("Can't get error string: No connected Device.");

    return device->errorString();
}

void ZioDevice::reset()
{
    QIODevice* device = nullptr;

    emit getCurrentDevice( &device);

    if(device == nullptr)
        qDebug("Error: No connected Device.");
    else
        device->reset();
}

void ZioDevice::close()
{
    QIODevice* device = nullptr;

    emit getCurrentDevice( &device);

    if(device == nullptr)
        qDebug("Error: No connected Device.");
    else
        device->close();
}

bool ZioDevice::seek(qint64 pos)
{
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->seek(pos),  true,
    Z_FAC_JS, ZioDevice::seek, seek failed)
}

bool ZioDevice::waitForBytesWritten(int msecs)
{
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->waitForBytesWritten(msecs),  true,
    Z_FAC_JS, ZioDevice::waitForBytesWritten, waitForBytesWritten failed)
}

bool ZioDevice::waitForReadyRead(int msecs)
{
    ZBL_SLOT_BEGIN_TRY
    QIODevice* device = connectedDevice();
    ZBL_SLOT_END_RETURN(device->waitForReadyRead(msecs),  true,
    Z_FAC_JS, ZioDevice::waitForReadyRead, waitForReadyRead failed)
}

qint64 ZioDevice::writeString(const QString& text)
{
    ZBL_SLOT_BEGIN_TRY

        QIODevice* device = connectedDevice();

        qint64 sizeWritten = device->write(text.toUtf8().constData());

        if(sizeWritten == -1)
        {
            QString msg("File error attempting to write data: %1");
            throw ZblException(msg.arg(getErrorString()));
        }
    ZBL_SLOT_END_RETURN(sizeWritten,  -1,
    Z_FAC_JS, ZioDevice::writeString, writeString failed)
}

qint64 ZioDevice::writeBytes(const QObject* data)
{
    ZBL_SLOT_BEGIN_TRY

        const ZByteArray* constBa = qobject_cast<const ZByteArray*>(data);
        ZByteArray* ba = const_cast<ZByteArray*>(constBa);

        if(!ba)
            throw ZblException("Programming error: ZioDevice::writeData() argument must be a ZByteArray");

        QIODevice* device = connectedDevice();

        qint64 sizeWritten = device->write(*ba->qByteArray());

         if((sizeWritten == -1)
                || (sizeWritten < ba->getSize()))
        {
            QString msg("ZProcess error attempting to write data: %1");
            throw ZblException(msg.arg(getErrorString()));
        }
    ZBL_SLOT_END_RETURN(sizeWritten,  -1,
    Z_FAC_JS, ZioDevice::writeBytes, writeBytes failed)
}


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



} // Zbl