ZFile.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * ZFile.h
 *
 *     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
 */

#ifndef ZFILE_H_
#define ZFILE_H_

#include "zglobal.h"
#include "ZioDevice.h"

#include <QObject>
#include <QFile>
#include <QSharedPointer>


#include <QTextStream>
#include <QDataStream>


namespace Zbl
{
class ZByteArray;
class ZTextStream;
class ZDataStream;

class ZFile: public QObject
{
    Q_OBJECT
    Q_ENUMS(Permission)
public:

    // to participate in automatic enum propagation
    // for QML programs we redeclare these QFileDevice enums;
    // note background Javascript programs can't use QML
    // type engine, those programs must use tags property instead

    enum Permission {
        ReadOwner = QFileDevice::ReadOwner,
        WriteOwner = QFileDevice::WriteOwner,
        ExeOwner = QFileDevice::ExeOwner,
        ReadUser  = QFileDevice::ReadUser,
        WriteUser  = QFileDevice::WriteUser,
        ExeUser  = QFileDevice::ExeUser,
        ReadGroup = QFileDevice::ReadGroup,
        WriteGroup = QFileDevice::WriteGroup,
        ExeGroup = QFileDevice::ExeGroup,
        ReadOther = QFileDevice::ReadOther,
        WriteOther = QFileDevice::WriteOther,
        ExeOther = QFileDevice::ExeOther
    };
    Q_DECLARE_FLAGS(Permissions, Permission)


    explicit ZFile(QObject* parent = 0);
    virtual ~ZFile();


    static void registerType();

    Q_PROPERTY(QString fileName READ getFileName WRITE setFileName)

    
    Q_PROPERTY(QObject* device READ getJsDevice CONSTANT)

    Q_PROPERTY(QVariant tags READ getTags NOTIFY tagsChanged)


    
    QString getFileName() const;
    void setFileName(const QString& fileName);
    QObject* getJsDevice();
    QVariant getTags();




    Q_INVOKABLE void release();

    Q_INVOKABLE void close();

    Q_INVOKABLE bool open(int openMode);

    Q_INVOKABLE bool copy(const QString& newName);

    Q_INVOKABLE bool rename(const QString& newName);

    Q_INVOKABLE bool remove();

    Q_INVOKABLE bool exists();

    Q_INVOKABLE bool exists(const QString& fileName);

    Q_INVOKABLE QString getAbsoluteFilePath(const QString& filePath);

    Q_INVOKABLE QString getCanonicalFilePath(const QString& filePath);

    Q_INVOKABLE QObject* zReadData(int maxSize);

    Q_INVOKABLE QObject* zReadDataLine(int maxSize);

    Q_INVOKABLE QObject* zReadDataAll();

    Q_INVOKABLE QList<int> jReadData(int maxSize);

    Q_INVOKABLE QList<int> jReadDataLine(int maxSize);

    Q_INVOKABLE QList<int> jReadDataAll();

    Q_INVOKABLE bool zWriteData(const ZByteArray& data); // tbd: this should be QObject*?

    Q_INVOKABLE bool jWriteData(const QList<int> data);

    Q_INVOKABLE QObject* zTextStream();

    Q_INVOKABLE QObject* zDataStream();


public slots:

    void getQDevice(QIODevice** device); // for ZioDevice::getCurrentDevice


signals:

    void tagsChanged();



protected:

    ZBL_DECLARE_LOGGED_OBJECT

    void initZioDevice();

    void createTags();


    QList<int> jGetData(int maxSize, bool lineModeOn = false);


    inline void initFile(const QString& fileName);

    inline void validateFile() const;

    inline void validateReadable() const;

    inline void validateWritable() const;

    inline void validateReadDataSuccess(const QByteArray& ba) const;


    ZqFilePtr m_f;

    ZioDevice* m_zd;

    static QVariant m_tags;
};



inline void ZFile::initFile(const QString& fileName)
{
    close();

    m_f = ZqFilePtr::create();

    m_f->setFileName(fileName);
}

inline void ZFile::validateFile() const
{
    if(!m_f)
        throw ZblException("File object not initialized. "
                           "Use ZFile::fileName property to set the file name.");
}




inline void ZFile::validateReadable() const
{
    validateFile();

    if(!m_f->isReadable())
        throw ZblException(
                "Error, file is not readable.");
}

inline void ZFile::validateWritable() const
{
    validateFile();

    if(!m_f->isWritable())
        throw ZblException(
                "Error, file is not writable.");
}

inline void ZFile::validateReadDataSuccess(const QByteArray& ba) const
{
    if(ba.isEmpty())
    {
        validateFile();

        if(m_f->error() != QFileDevice::NoError)
        {
            QString msg("File error attempting to read data: %1");
            msg = msg.arg(m_f->errorString());
            throw ZblException(msg);
        }
    }
}


} // Zbl

#endif /* ZFILE_H_ */