VFS_qrc.cpp

Go to the documentation of this file.

 
#include <QDirIterator>
#include <QFile>
#include <QFileInfo>
#include <QDir>
 
#include <QJsonDocument>
//#include <QJsonObject>
//#include <QJsonArray>
 
#include "VFS.h"
#include "VFS_qrc.h"
#include "utilities/rutils.h"
#include "VFS_base/VFS_node_type.h"
 
VFS_QRC::VFS_QRC(QString path, bool raw)
: VFS_node()
, _path(path)
, _raw(raw)
{
        if (_path.at(0)!=':' || !QFile::exists(_path))
        {       VFS::ERROR( QString("VFS_QRC nodes require a QT valid resource path.  Invalid path: '%1'").arg(_path) );
                _path = "/XXX";
        }
}
 
VFS_QRC::~VFS_QRC()
{
}
 
VFS_node *VFS_QRC::find(VFS_request *r)
{
        Q_UNUSED(r);
 
        //QMutexLocker l(&_lock);
 
        return this;
}
 
void VFS_QRC::read(VFS_request *r)
{
        //QMutexLocker l(&_lock);
 
        QString p = _path+"/"+r->_path;
 
        QFileInfo i(p);
 
        if (!i.exists())
        {
                r->_reason = "Path does not exist: "+r->_path;
                r->_success = false;
                return;
        }
 
        if (i.isDir())
        {
                QDir dir(p);
                QFileInfoList list = dir.entryInfoList( QDir::AllEntries | QDir::Readable | QDir::NoDotAndDotDot );
 
                QJsonObject o;
                QFileInfo info;
 
                for (int i=0;i<list.length();i++)
                {
                        info = list[i];
                        o[info.fileName()] = info.isDir();
                }
 
                r->_data = QJsonDocument(o);
                r->_success = true;
                return;
        }
        else
        {
                QFile file(p);
                if(file.open(QFile::ReadOnly))
                {
                        QJsonDocument d;
                        QByteArray f = file.readAll();
 
                        if (!_raw)
                        {
                                QJsonParseError e;
                                d = QJsonDocument::fromJson(f,&e);
                                if (e.error != QJsonParseError::NoError)
                                {
                                        VFS::ERROR( r->_reason = e.errorString() );
                                        return;
                                }
                        }
                        else
                        {       QJsonObject o;
                                o["data"] = QString(f);
                                d.setObject(o);
                        }
 
                        r->_data = d;
                        r->_success = true;
                        return;
                }
                else
                {
                        VFS::ERROR( r->_reason = QString("Unable to open '%1'.").arg(p) );
                        return;
                }
        }
 
        r->_reason = "Unknown QRC error.";
        r->_success = false;
}
 
void VFS_QRC::write(VFS_request *r)
{
        VFS::ERROR(QString("VFS_QRC nodes are read-only.  '%1' is unwritable.").arg(r->_path));
 
        r->_success = false;
}
 
void VFS_QRC::metadata(VFS_request *r)
{
        QString p = _path+"/"+r->_path;
 
        VFS_node::metadata(r);
 
        r->_metadata["type"] = VFS_node_type::getType(p);
        r->_success = true;
}
 
//virtual void report(VFS_request *r);
 
void VFS_QRC::submit(VFS_request *r)
{
        VFS::ERROR(QString("VFS_QRC nodes are read-only.  '%1' is unwritable.").arg(r->_path));
 
        r->_success = false;
}
 
void VFS_QRC::rm(VFS_request *r)
{
        VFS::ERROR(QString("VFS_QRC nodes are read-only.  '%1' is not deletable.").arg(r->_path));
 
        r->_success = false;
}
 
void VFS_QRC::subscribe(VFS_request *r)
{
        QString p = _path+"/"+r->_path;
        QFileInfo i(p);
 
        if (!i.exists())
        {
                r->_reason = QString("Can't subscribe to non-existent resource: '%1'").arg(p);
                r->_success = false;
        }
        else
                VFS_node::subscribe(r);
}
 
void VFS_QRC::ls(VFS_request *r)
{
        //QMutexLocker _l(&_lock);
 
        QString p = _path+"/"+r->_path;
 
        QString n,m;
        QFileInfo i(p);
 
        if (!i.exists())
        {
                VFS::WARN( r->_reason = QString("Illegal path: %1\n").arg(p) );
                r->_success = false;
                return;
        }
 
        //QJsonArray a;
        QJsonObject a;
 
        QDirIterator::IteratorFlags f = QDirIterator::FollowSymlinks;
        //if (recursive) f |= QDirIterator::Subdirectories;
 
        QDirIterator it(p,f);
        while (it.hasNext())
        {
                n = it.next();
                m = it.fileName();
                i = it.fileInfo();
                if (m!="." && m!="..")
                {
                        //a.push_back( m+(i.isDir()?"/":"") );
                        a[m] = i.isDir();
                }
        }
 
        if (r->_metadata.value("sequence").toBool(false))
                a = rutils::sequenceListing(a);
 
        //r->_data = QJsonDocument(a);
        r->_data.setObject(a);
        r->_success = true;
}
 
bool VFS_QRC::isContainer()
{
        return true;
}