KoQuaZipStore Class Reference

#include <KoQuaZipStore.h>

Inheritance diagram for KoQuaZipStore:

Classes
struct	Private

Public Member Functions
QStringList	directoryList () const override
	KoQuaZipStore (const QString &_filename, Mode _mode, const QByteArray &appIdentification, bool writeMimetype=true)
	KoQuaZipStore (QIODevice *dev, Mode mode, const QByteArray &appIdentification, bool writeMimetype=true)
void	setCompressionEnabled (bool enabled) override
qint64	write (const char *_data, qint64 _len) override
	~KoQuaZipStore () override
Public Member Functions inherited from KoStore
bool	atEnd () const
bool	bad () const
bool	close ()
QString	currentPath () const
QIODevice *	device () const
virtual bool	enterDirectory (const QString &directory)
bool	extractFile (const QString &sourceName, QByteArray &data)
bool	finalize ()
bool	hasDirectory (const QString &directoryName)
bool	hasFile (const QString &fileName) const
bool	isOpen () const
bool	leaveDirectory ()
Mode	mode () const
bool	open (const QString &name)
void	popDirectory ()
qint64	pos () const
void	pushDirectory ()
qint64	read (char *buffer, qint64 length)
QByteArray	read (qint64 max)
bool	seek (qint64 pos)
	See QIODevice.
void	setSubstitution (const QString &name, const QString &substitution)
	When reading, in the paths in the store where name occurs, substitution is used.
qint64	size () const
qint64	write (const QByteArray &data)
virtual	~KoStore ()

Protected Member Functions
bool	closeRead () override
bool	closeWrite () override
bool	doFinalize () override
bool	enterAbsoluteDirectory (const QString &path) override
bool	enterRelativeDirectory (const QString &dirName) override
bool	fileExists (const QString &absPath) const override
void	init (const QByteArray &appIdentification)
bool	openRead (const QString &name) override
bool	openWrite (const QString &name) override
Protected Member Functions inherited from KoStore
	KoStore (Mode mode, bool writeMimetype=true)

Private Attributes
const QScopedPointer< Private >	dd

Additional Inherited Members
Public Types inherited from KoStore
enum	Backend { Auto , Zip , Directory }
enum	Mode { Read , Write }
Static Public Member Functions inherited from KoStore
static KoStore *	createStore (const QString &fileName, Mode mode, const QByteArray &appIdentification=QByteArray(), Backend backend=Auto, bool writeMimetype=true)
static KoStore *	createStore (QIODevice *device, Mode mode, const QByteArray &appIdentification=QByteArray(), Backend backend=Auto, bool writeMimetype=true)
Protected Attributes inherited from KoStore
KoStorePrivate *	d_ptr

Detailed Description

Definition at line 15 of file KoQuaZipStore.h.

Constructor & Destructor Documentation

KoQuaZipStore() [1/2]

KoQuaZipStore::KoQuaZipStore	(	const QString &	_filename,
		KoStore::Mode	_mode,
		const QByteArray &	appIdentification,
		bool	writeMimetype = true )

Definition at line 43 of file KoQuaZipStore.cpp.

    : KoStore(_mode, writeMimetype)
    , dd(new Private())
{
    Q_D(KoStore);
    d->localFileName = _filename;
    dd->archive = new QuaZip(_filename);
    init(appIdentification);
 
}

References dd, and init().

KoQuaZipStore() [2/2]

KoQuaZipStore::KoQuaZipStore	(	QIODevice *	dev,
		KoStore::Mode	_mode,
		const QByteArray &	appIdentification,
		bool	writeMimetype = true )

Definition at line 54 of file KoQuaZipStore.cpp.

    : KoStore(_mode, writeMimetype)
    , dd(new Private())
{
    dd->archive = new QuaZip(dev);
    init(appIdentification);
}

References dd, and init().

~KoQuaZipStore()

KoQuaZipStore::~KoQuaZipStore ( )

override

Definition at line 62 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
 
    if (d->good && dd->currentFile && dd->currentFile->isOpen()) {
        dd->currentFile->close();
    }
 
    if (!d->finalized) {
        finalize();
    }
 
 
    // NOTE:
    //   If the dd->currentFile is corrupt (and ->getZipError() returns an error code)
    // QuaZip cannot really close it properly (and I don't see an accessible function to reset the error code).
    // Therefore the destructor thinks the file is open and tries to close it.
    // And closing the file means checking if the zip archive associated with the file is open or not.
    // Therefore the archive must exist when the file is being closed, therefore also when it's being deleted.
    // In comparison, the archive can be deleted whenever and it doesn't check the current file.
    // Therefore we gotta delete the file first, then the zip archive.
 
    //   From QuaZip code comments for `QuaZipFile(QuaZip *zip, QObject *parent =nullptr);`:
    // "* Summary: do not close \c zip object or change its current file as
    // * long as QuaZipFile is open."
 
    if (dd->currentFile) {
        delete dd->currentFile;
    }
    delete dd->archive;
 
}

References dd, and KoStore::finalize().

Member Function Documentation

closeRead()

bool KoQuaZipStore::closeRead ( )

overrideprotectedvirtual

Returns

true on success

Implements KoStore.

Definition at line 270 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
    d->stream = 0;
    return true;
}

closeWrite()

bool KoQuaZipStore::closeWrite ( )

overrideprotectedvirtual

Returns

true on success

Implements KoStore.

Definition at line 253 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
 
    bool r = true;
    if (dd->currentFile->write(dd->cache) != dd->cache.size()) {
        // write() returns number of bytes written, or -1 in case of error
        // let's allow write 0 bytes in the cache, when needed
        qWarning() << "Could not write buffer to the file";
        r = false;
    }
    dd->buffer.close();
    dd->currentFile->close();
    d->stream = 0;
    return (r && dd->currentFile->getZipError() == ZIP_OK);
}

References dd.

directoryList()

QStringList KoQuaZipStore::directoryList ( ) const

overridevirtual

If an store is opened for reading, then the directories of the store can be accessed via this function.

Returns

a stringlist with all directories found

Reimplemented from KoStore.

Definition at line 126 of file KoQuaZipStore.cpp.

{
    // If in Read mode, we can assume the directory listing won't change between invocations.
    if(mode() == Read) {
        if(!dd->directoryListCached) {
            dd->directoryListCache = dd->archive->getFileNameList();
            dd->directoryListCached = true;
        }
        return dd->directoryListCache;
    }
    else {
        return dd->archive->getFileNameList();
    }
}

References dd, KoStore::mode(), and KoStore::Read.

doFinalize()

bool KoQuaZipStore::doFinalize ( )

overrideprotectedvirtual

Finalize store - called by finalize.

Returns

true on success

Reimplemented from KoStore.

Definition at line 181 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
 
    d->stream = 0;
    if (d->good && !dd->usingSaveFile) {
        dd->archive->close();
    }
    return dd->archive->getZipError() == ZIP_OK;
 
}

References dd.

enterAbsoluteDirectory()

bool KoQuaZipStore::enterAbsoluteDirectory ( const QString & path )

overrideprotectedvirtual

Enter a directory where we've been before. It is guaranteed to always exist.

Implements KoStore.

Definition at line 282 of file KoQuaZipStore.cpp.

{
    QString fixedPath = path;
    fixedPath.replace("//", "/");
 
    if (fixedPath.isEmpty()) {
        fixedPath = "/";
    }
 
    QuaZipDir currentDir (dd->archive, fixedPath);
 
    return currentDir.exists();
}

References dd.

enterRelativeDirectory()

bool KoQuaZipStore::enterRelativeDirectory ( const QString & dirName )

overrideprotectedvirtual

Enter a subdirectory of the current directory. The directory might not exist yet in Write mode.

Implements KoStore.

Definition at line 277 of file KoQuaZipStore.cpp.

{
    return true;
}

fileExists()

bool KoQuaZipStore::fileExists ( const QString & absPath ) const

overrideprotectedvirtual

Check if a file exists inside the store.

Parameters

absPath

the absolute path inside the store, i.e. not relative to the current directory

Implements KoStore.

Definition at line 296 of file KoQuaZipStore.cpp.

{
    Q_D(const KoStore);
 
    QString fixedPath = absPath;
    fixedPath.replace("//", "/");
 
    if (!d->substituteThis.isEmpty()) {
        fixedPath = fixedPath.replace(d->substituteThis, d->substituteWith);
    }
 
    return directoryList().contains(fixedPath);
}

References directoryList().

init()

void KoQuaZipStore::init ( const QByteArray & appIdentification )

protected

Definition at line 141 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
 
    bool enableZip64 = false;
    if (appIdentification == "application/x-krita") {
        enableZip64 = KSharedConfig::openConfig()->group("").readEntry<bool>("UseZip64", false);
    }
 
    dd->archive->setDataDescriptorWritingEnabled(false);
    dd->archive->setZip64Enabled(enableZip64);
    dd->archive->setFileNameCodec("UTF-8");
    dd->usingSaveFile = dd->archive->getIoDevice() && dd->archive->getIoDevice()->inherits("QSaveFile");
    dd->archive->setAutoClose(!dd->usingSaveFile);
 
    d->good = dd->archive->open(d->mode == Write ? QuaZip::mdCreate : QuaZip::mdUnzip);
 
    if (!d->good) {
        return;
    }
 
    if (d->mode == Write) {
        if (d->writeMimetype) {
            QuaZipFile f(dd->archive);
            QuaZipNewInfo newInfo("mimetype");
            newInfo.setPermissions(QFileDevice::ReadOwner | QFileDevice::ReadGroup | QFileDevice::ReadOther);
            if (!f.open(QIODevice::WriteOnly, newInfo, 0, 0, 0, Z_NO_COMPRESSION)) {
                d->good = false;
                return;
            }
            f.write(appIdentification);
            f.close();
        }
    }
    else {
        debugStore << dd->archive->getEntriesCount() << directoryList();
        d->good = dd->archive->getEntriesCount();
    }
}

References dd, debugStore, directoryList(), and KoStore::Write.

openRead()

bool KoQuaZipStore::openRead ( const QString & name )

overrideprotectedvirtual

Open the file name in the store, for reading. On success, this method must set m_stream to a stream from which we can read, as well as setting m_iSize to the size of the file.

Parameters

name	"absolute path" (in the archive) to the file to open

Returns

true on success

Implements KoStore.

Definition at line 218 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
 
    QString fixedPath = name;
    fixedPath.replace("//", "/");
 
    delete d->stream;
    d->stream = 0;
    delete dd->currentFile;
    dd->currentFile = 0;
 
    if (!currentPath().isEmpty() && !fixedPath.startsWith(currentPath())) {
        fixedPath = currentPath() + '/' + fixedPath;
    }
 
    if (!d->substituteThis.isEmpty()) {
        fixedPath = fixedPath.replace(d->substituteThis, d->substituteWith);
    }
 
    if (!dd->archive->setCurrentFile(fixedPath)) {
        qWarning() << "\t\tCould not set current file" << dd->archive->getZipError() << fixedPath;
        return false;
    }
 
    dd->currentFile = new QuaZipFile(dd->archive);
    if (!dd->currentFile->open(QIODevice::ReadOnly)) {
        qWarning() << "\t\t\tBut could not open!!!" << dd->archive->getZipError();
        return false;
    }
    d->stream = dd->currentFile;
    d->size = dd->currentFile->size();
    return true;
}

References KoStore::currentPath(), and dd.

openWrite()

bool KoQuaZipStore::openWrite ( const QString & name )

overrideprotectedvirtual

Open the file name in the store, for writing On success, this method must set m_stream to a stream in which we can write.

Parameters

name	"absolute path" (in the archive) to the file to open

Returns

true on success

Implements KoStore.

Definition at line 193 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
    QString fixedPath = name;
    fixedPath.replace("//", "/");
 
    delete d->stream;
    d->stream = 0; // Not used when writing
 
    delete dd->currentFile;
    dd->currentFile = new QuaZipFile(dd->archive);
    QuaZipNewInfo newInfo(fixedPath);
    newInfo.setPermissions(QFileDevice::ReadOwner | QFileDevice::ReadGroup | QFileDevice::ReadOther);
    bool r = dd->currentFile->open(QIODevice::WriteOnly, newInfo, 0, 0, Z_DEFLATED, dd->compressionLevel);
    if (!r) {
        qWarning() << "Could not open" << name << dd->currentFile->getZipError();
    }
 
    dd->cache = QByteArray();
    dd->buffer.setBuffer(&dd->cache);
    dd->buffer.open(QBuffer::WriteOnly);
 
    return r;
}

References dd.

setCompressionEnabled()

void KoQuaZipStore::setCompressionEnabled ( bool e )

overridevirtual

Allow to enable or disable compression of the files. Only supported by the ZIP backend.

Reimplemented from KoStore.

Definition at line 95 of file KoQuaZipStore.cpp.

{
 
    if (enabled) {
        dd->compressionLevel = Z_DEFAULT_COMPRESSION;
    }
    else {
        dd->compressionLevel = Z_NO_COMPRESSION;
    }
}

References dd.

write()

qint64 KoQuaZipStore::write ( const char * data, qint64 length )

overridevirtual

Write data into the currently opened file. You can also use the streams for this.

Reimplemented from KoStore.

Definition at line 106 of file KoQuaZipStore.cpp.

{
    Q_D(KoStore);
    if (_len == 0) return 0;
 
    if (!d->isOpen) {
        errorStore << "KoStore: You must open before writing" << Qt::endl;
        return 0;
    }
 
    if (d->mode != Write) {
        errorStore << "KoStore: Can not write to store that is opened for reading" << Qt::endl;
        return 0;
    }
 
    qint64 nwritten = dd->buffer.write(_data, _len);
    d->size += nwritten;
    return nwritten;
}

References dd, errorStore, and KoStore::Write.

Member Data Documentation

dd

const QScopedPointer<Private> KoQuaZipStore::dd

private

Definition at line 44 of file KoQuaZipStore.h.

---

The documentation for this class was generated from the following files:

• libs/store/KoQuaZipStore.h
• libs/store/KoQuaZipStore.cpp