ZFile.cpp

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZFile.cpp
 *
 *     Project: bitumen
 *     Created: Feb 23, 2012
 *      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 <QtQml>
#include <QFileInfo>
#include <QDir>

#include "ZFile.h"
#include "ZblThreadErr.h"
#include "ZByteArray.h"
#include "ZTextStream.h"
#include "ZDataStream.h"
#include "ZApplication.h"
#include "zglobal.h"

namespace Zbl
{
QVariant ZFile::m_tags;

ZBL_DEFINE_LOGGED_OBJECT(Zbl::ZFile)

ZFile::ZFile(QObject* parent) :
    QObject(parent)
{
    zDebug() << "ZFile::ZFile";

    createTags();

    initZioDevice();
}

ZFile::~ZFile()
{
    zDebug() << "::~ZFile";
    close();
}


void ZFile::registerType()
{
    ZBL_REGISTER_LOGGED_OBJECT

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

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

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

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

    QVariantMap map;

    map.insert("permissionReadOwner", ReadOwner);
    map.insert("permissionWriteOwner", WriteOwner);
    map.insert("permissionExeOwner", ExeOwner);
    map.insert("permissionReadUser", ReadUser);
    map.insert("permissionWriteUser", WriteUser);
    map.insert("permissionExeUser", ExeUser);
    map.insert("permissionReadGroup", ReadGroup);
    map.insert("permissionWriteGroup", WriteGroup);
    map.insert("permissionExeGroup", ExeGroup);
    map.insert("permissionReadOther", ReadOther);
    map.insert("permissionWriteOther", WriteOther);
    map.insert("permissionExeOther", ExeOther);

    m_tags = QVariant::fromValue(map);
}

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


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

void ZFile::getQDevice(QIODevice** device)
{
    *device = qobject_cast<QIODevice*>(m_f.data());
}

void ZFile::release()
{
    ZBL_SLOT_BEGIN_TRY
            m_f.clear();
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZFile::release, release failed)
}

void ZFile::close()
{
    ZBL_SLOT_BEGIN_TRY

    //validateFile();

   if(m_f)
        m_f->close();

    ZBL_SLOT_END_VOID(Z_FAC_JS, ZFile::close, close failed)
}

QString ZFile::getFileName() const
{
    QString fileName;

    ZBL_SLOT_BEGIN_TRY
    if(m_f)
        fileName = m_f->fileName();
    ZBL_SLOT_END_RETURN(fileName,  fileName,
    Z_FAC_JS, ZFile::getFileName, getFileName failed)
}

// note: setFileName will destroy and re-create the QFile

void ZFile::setFileName(const QString& fileName)
{
    ZBL_SLOT_BEGIN_TRY

    close();
    initFile(ZApplication::resolvePath(fileName, false));
    ZBL_SLOT_END_VOID(Z_FAC_JS, ZFile::setFileName, setFileName failed)
}

bool ZFile::open(int openMode)
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->open(QFile::OpenMode(openMode));
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::open, open failed)
}

bool ZFile::copy(const QString& newName)
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->copy(newName);
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::copy, copy failed)
}

bool ZFile::rename(const QString& newName)
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->rename(newName);
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::rename, rename failed)
}

bool ZFile::remove()
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->remove();
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::remove, remove failed)
}

bool ZFile::exists()
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    validateFile();
    retValue = m_f->exists();
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::exists, exists failed)
}

bool ZFile::exists(const QString& fileName)
{
    bool retValue;
    ZBL_SLOT_BEGIN_TRY
    retValue = QFile::exists(fileName);
    ZBL_SLOT_END_RETURN(retValue,  false,
    Z_FAC_JS, ZFile::exists, exists failed)
}

QString ZFile::getAbsoluteFilePath(const QString& filePath)
{
    QString retValue;
    ZBL_SLOT_BEGIN_TRY
    QFileInfo fi(QDir::cleanPath(filePath));
    retValue = fi.absoluteFilePath();
    ZBL_SLOT_END_RETURN(retValue,  QString(),
    Z_FAC_JS, ZFile::getAbsoluteFilePath, getAbsoluteFilePath failed)
}

QString ZFile::getCanonicalFilePath(const QString& filePath)
{
    QString retValue;
    ZBL_SLOT_BEGIN_TRY
    QFileInfo fi(QDir::cleanPath(filePath));
    retValue = fi.canonicalFilePath();
    ZBL_SLOT_END_RETURN(retValue,  QString(),
    Z_FAC_JS, ZFile::getCanonicalFilePath, getCanonicalFilePath failed)
}

QObject* ZFile::zReadDataLine(int maxSize)
{
    zDebug() << "::zReadDataLine";
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    QByteArray ba = m_f->readLine(maxSize);
    validateReadDataSuccess(ba);
    ZBL_SLOT_END_RETURN(new ZByteArray(ba),  NULL,
    Z_FAC_JS, ZFile::zReadDataLine, zReadDataLine failed)
}

QObject* ZFile::zReadData(int maxSize)
{
    zDebug() << "::zReadData";
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    QByteArray ba = m_f->read(maxSize);
    validateReadDataSuccess(ba);
    ZBL_SLOT_END_RETURN(new ZByteArray(ba),  NULL,
    Z_FAC_JS, ZFile::zReadData, zReadData failed)
}

QObject* ZFile::zReadDataAll()
{
    zDebug() << "::zReadDataAll";
    ZBL_SLOT_BEGIN_TRY
    validateReadable();
    QByteArray ba = m_f->readAll();
    validateReadDataSuccess(ba);
    ZBL_SLOT_END_RETURN(new ZByteArray(ba),  NULL,
    Z_FAC_JS, ZFile::zReadDataAll, zReadDataAll failed)
}

QList<int> ZFile::jReadDataLine(int maxSize)
{
    zDebug() << "::jReadDataLine";
    ZBL_SLOT_BEGIN_TRY
    ZBL_SLOT_END_RETURN(jGetData(maxSize, true),  QList<int>(),
    Z_FAC_JS, ZFile::jReadDataLine, jReadDataLine failed)
}

QList<int> ZFile::jReadData(int maxSize)
{
    zDebug() << "::jReadData";
    ZBL_SLOT_BEGIN_TRY

    ZBL_SLOT_END_RETURN(jGetData(maxSize, false),  QList<int>(),
    Z_FAC_JS, ZFile::jReadData, jReadData failed)
}

QList<int> ZFile::jReadDataAll()
{
    zDebug() << "::jReadDataAll";

    QList<int> array;

    ZBL_SLOT_BEGIN_TRY
    validateReadable();

    const int maxSize = 1024 * 16;

    while(true)
    {
        int previousSize = array.size();
        array.append(jGetData(maxSize,false));
        if((array.size() - previousSize < maxSize))
        {
            if(m_f->error() != QFileDevice::NoError)
            {
                if(m_f->error() != QFileDevice::NoError)
                {
                    QString msg("File error attempting to read data: %1");
                    throw ZblException(msg.arg(m_f->errorString()));
                }
            }
            break;
        }
    }
    ZBL_SLOT_END_RETURN(array,  array,
    Z_FAC_JS, ZFile::jReadDataAll, jReadDataAll failed)
}

QList<int> ZFile::jGetData(int maxSize, bool lineModeOn)
{
    validateReadable();

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

    try
    {
        //ASSERT(m_f);

        if(lineModeOn)
            sizeReturned = m_f->readLine(data, maxSize);
        else
            sizeReturned = m_f->read(data, maxSize);

        if(sizeReturned == -1 )
        {
            QString msg("File error attempting to read data: %1");
            throw ZblException(msg.arg(m_f->errorString()));
        }
        else if(sizeReturned < maxSize)
        {
            if(m_f->error() != QFileDevice::NoError)
            {
                QString msg("File error attempting to read data: %1");
                throw ZblException(msg.arg(m_f->errorString()));
            }
        }
        for(int i = 0; i < sizeReturned; i++)
            array.append(static_cast<int>(data[i]));
    }
    catch(...)
    {
        if(data)
            delete data;

        throw;
    }

    return array;
}

bool ZFile::zWriteData(const ZByteArray& data)
{
    zDebug() << "::zWriteData";
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    qint64 sizeWritten = m_f->write(*data.m_ba);

    if((sizeWritten == -1)
        || ((sizeWritten < data.m_ba->size())
                && (m_f->error() != QFileDevice::NoError)))
    {
        QString msg("File error attempting to write data: %1");
        throw ZblException(msg.arg(m_f->errorString()));
    }
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZFile::zWriteData, zWriteData failed)
}

bool ZFile::jWriteData(const QList<int> data)
{
    zDebug() << "::jWriteData";
    ZBL_SLOT_BEGIN_TRY
    validateWritable();
    const int size = data.size();
    for(int i = 0; i < size; i++)
    {
        if(!m_f->putChar(static_cast<char>(data.at(i))))
        {
            QString msg("File error attempting to write data: %1");
            throw ZblException(msg.arg(m_f->errorString()));
        }
    }
    ZBL_SLOT_END_RETURN(true,  false,
    Z_FAC_JS, ZFile::jWriteData, jWriteData failed)
}

QObject* ZFile::zTextStream()
{
zDebug() << "::zTextStream";
ZBL_SLOT_BEGIN_TRY
ZBL_SLOT_END_RETURN(new ZTextStream(m_f.dynamicCast<QIODevice>()),
NULL, Z_FAC_JS, ZFile::zTextStream, zTextStream failed)
}

QObject* ZFile::zDataStream()
{
zDebug() << "::zDataStream";
ZBL_SLOT_BEGIN_TRY
ZBL_SLOT_END_RETURN(new ZDataStream(m_f.dynamicCast<QIODevice>()),
NULL, Z_FAC_JS, ZFile::zDataStream, zDataStream failed)
}



} // Zbl