KoStore Class Reference

#include <KoStore.h>

Inheritance diagram for KoStore:

Public Types
enum	Backend { Auto , Zip , Directory }
enum	Mode { Read , Write }

Public Member Functions
bool	atEnd () const
bool	bad () const
bool	close ()
QString	currentPath () const
QIODevice *	device () const
virtual QStringList	directoryList () 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.
virtual void	setCompressionEnabled (bool e)
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
virtual qint64	write (const char *data, qint64 length)
qint64	write (const QByteArray &data)
virtual	~KoStore ()

Static Public Member Functions
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 Member Functions
virtual bool	closeRead ()=0
virtual bool	closeWrite ()=0
virtual bool	doFinalize ()
virtual bool	enterAbsoluteDirectory (const QString &path)=0
virtual bool	enterRelativeDirectory (const QString &dirName)=0
virtual bool	fileExists (const QString &absPath) const =0
	KoStore (Mode mode, bool writeMimetype=true)
virtual bool	openRead (const QString &name)=0
virtual bool	openWrite (const QString &name)=0

Protected Attributes
KoStorePrivate *	d_ptr

Private Member Functions
	KoStore (const KoStore &store)
	don't copy
KoStore &	operator= (const KoStore &store)
	don't assign

Detailed Description

Saves and loads Krita documents using various backends. Currently supported backends are zip and directory. We call a "store" the file on the hard disk (the one the users sees) and call a "file" a file inside the store.

Definition at line 25 of file KoStore.h.

Member Enumeration Documentation

Backend

enum KoStore::Backend

Enumerator
Auto
Zip
Directory

Definition at line 30 of file KoStore.h.

{ Auto, Zip, Directory };

Mode

enum KoStore::Mode

Enumerator
Read
Write

Definition at line 29 of file KoStore.h.

{ Read, Write };

Constructor & Destructor Documentation

~KoStore()

KoStore::~KoStore ( )

virtual

Destroys the store (i.e. closes the file on the hard disk)

Definition at line 102 of file KoStore.cpp.

{
    Q_D(KoStore);
    delete d->stream;
    delete d_ptr;
}

References d_ptr.

KoStore() [1/2]

KoStore::KoStore ( Mode mode, bool writeMimetype = true )

protected

Definition at line 98 of file KoStore.cpp.

    : d_ptr(new KoStorePrivate(this, mode, writeMimetype))
{}

KoStore() [2/2]

KoStore::KoStore ( const KoStore & store )

private

don't copy

Member Function Documentation

atEnd()

bool KoStore::atEnd

(

)

const

Definition at line 353 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return d->stream->atEnd();
}

bad()

bool KoStore::bad

(

)

const

Returns

true if an error occurred

Definition at line 414 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return !d->good;
}

close()

bool KoStore::close

(

)

Close the file inside the store

Returns

true on success.

Definition at line 156 of file KoStore.cpp.

{
    Q_D(KoStore);
    if (!d->isOpen) {
        warnStore << "You must open before closing";
        return false;
    }
 
    bool ret = d->mode == Write ? closeWrite() : closeRead();
    delete d->stream;
    d->stream = 0;
    d->isOpen = false;
    return ret;
}

References closeRead(), closeWrite(), warnStore, and Write.

closeRead()

virtual bool KoStore::closeRead ( )

protectedpure virtual

Returns

true on success

Implemented in KoDirectoryStore, and KoQuaZipStore.

closeWrite()

virtual bool KoStore::closeWrite ( )

protectedpure virtual

Returns

true on success

Implemented in KoDirectoryStore, and KoQuaZipStore.

createStore() [1/2]

KoStore * KoStore::createStore ( const QString & fileName, Mode mode, const QByteArray & appIdentification = QByteArray(), Backend backend = Auto, bool writeMimetype = true )

static

Open a store (i.e. the representation on disk of a Krita document).

Parameters

fileName	the name of the file to open
mode	if KoStore::Read, open an existing store to read it. if KoStore::Write, create or replace a store.
backend	the backend to use for the data storage. Auto means automatically-determined for reading, and the current format (now Zip) for writing.
appIdentification	the application's mimetype, to be written in the file for "mime-magic" identification. Only meaningful if mode is Write, and if backend!=Directory.
writeMimetype	If true, some backends (notably the Zip store) will write a file called 'mimetype' automatically and fill it with data from the appIdentification. This is only applicable if Mode is set to Write.

Definition at line 39 of file KoStore.cpp.

{
    if (backend == Auto) {
        if (mode == KoStore::Write)
            backend = DefaultFormat;
        else {
            QFileInfo inf(fileName);
            if (inf.isDir())
                backend = Directory;
            else {
                QFile file(fileName);
                if (file.open(QIODevice::ReadOnly))
                    backend = determineBackend(&file);
                else
                    backend = DefaultFormat; // will create a "bad" store (bad()==true)
            }
        }
    }
    switch (backend) {
    case Zip:
        return new KoQuaZipStore(fileName, mode, appIdentification, writeMimetype);
    case Directory:
        return new KoDirectoryStore(fileName /* should be a dir name.... */, mode, writeMimetype);
    default:
        warnStore << "Unsupported backend requested for KoStore : " << backend;
        return 0;
    }
}

References Auto, DefaultFormat, determineBackend(), Directory, mode(), warnStore, Write, and Zip.

createStore() [2/2]

KoStore * KoStore::createStore ( QIODevice * device, Mode mode, const QByteArray & appIdentification = QByteArray(), Backend backend = Auto, bool writeMimetype = true )

static

Create a store for any kind of QIODevice: file, memory buffer... KoStore will take care of opening the QIODevice. This method doesn't support the Directory store!

Definition at line 68 of file KoStore.cpp.

{
    if (backend == Auto) {
        if (mode == KoStore::Write)
            backend = DefaultFormat;
        else {
            if (device->open(QIODevice::ReadOnly)) {
                backend = determineBackend(device);
                device->close();
            }
        }
    }
    switch (backend) {
    case Directory:
        errorStore << "Can't create a Directory store for a memory buffer!" << Qt::endl;
        return 0;
    case Zip:
        return new KoQuaZipStore(device, mode, appIdentification, writeMimetype);
    default:
        warnStore << "Unsupported backend requested for KoStore : " << backend;
        return 0;
    }
}

References Auto, DefaultFormat, determineBackend(), device(), Directory, errorStore, mode(), warnStore, Write, and Zip.

currentPath()

QString KoStore::currentPath

(

)

const

Returns the current path including a trailing slash. Note: Returns a path in "internal name" style

Definition at line 281 of file KoStore.cpp.

{
    Q_D(const KoStore);
    QString path;
    QStringList::ConstIterator it = d->currentPath.begin();
    QStringList::ConstIterator end = d->currentPath.end();
    for (; it != end; ++it) {
        path += *it;
        path += '/';
    }
    return path;
}

device()

QIODevice * KoStore::device

(

)

const

Get a device for reading a file from the store directly (slightly faster than read() calls) You need to call open first, and close afterwards.

Definition at line 171 of file KoStore.cpp.

{
    Q_D(const KoStore);
    if (!d->isOpen)
        warnStore << "You must open before asking for a device";
    if (d->mode != Read)
        warnStore << "Can not get device from store that is opened for writing";
    return d->stream;
}

References Read, and warnStore.

directoryList()

QStringList KoStore::directoryList ( ) const

virtual

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 in KoQuaZipStore.

Definition at line 426 of file KoStore.cpp.

{
    return QStringList();
}

doFinalize()

virtual bool KoStore::doFinalize ( )

inlineprotectedvirtual

Finalize store - called by finalize.

Returns

true on success

Reimplemented in KoQuaZipStore.

Definition at line 230 of file KoStore.h.

                              {
        return true;
    }

enterAbsoluteDirectory()

virtual bool KoStore::enterAbsoluteDirectory ( const QString & path )

protectedpure virtual

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

Implemented in KoDirectoryStore, and KoQuaZipStore.

enterDirectory()

bool KoStore::enterDirectory ( const QString & directory )

virtual

Enters one or multiple directories. In Read mode this actually checks whether the specified directories exist and returns false if they don't. In Write mode we don't create the directory, we just use the "current directory" to generate the absolute path if you pass a relative path (one not starting with tar:/) when opening a stream. Note: Operates on internal names

Definition at line 253 of file KoStore.cpp.

{
    Q_D(KoStore);
    //debugStore <<"enterDirectory" << directory;
    int pos;
    bool success = true;
    QString tmp(directory);
 
    while ((pos = tmp.indexOf('/')) != -1 &&
            (success = d->enterDirectoryInternal(tmp.left(pos))))
        tmp.remove(0, pos + 1);
 
    if (success && !tmp.isEmpty())
        return d->enterDirectoryInternal(tmp);
    return success;
}

References pos().

enterRelativeDirectory()

virtual bool KoStore::enterRelativeDirectory ( const QString & dirName )

protectedpure virtual

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

Implemented in KoDirectoryStore, and KoQuaZipStore.

extractFile()

bool KoStore::extractFile	(	const QString &	sourceName,
		QByteArray &	data )

Extracts a file out of the store to a buffer

Parameters

sourceName	file in the store
data	memory buffer

Definition at line 308 of file KoStore.cpp.

{
    Q_D(KoStore);
    QBuffer buffer(&data);
    return d->extractFile(srcName, buffer);
}

fileExists()

virtual bool KoStore::fileExists ( const QString & absPath ) const

protectedpure virtual

Check if a file exists inside the store.

Parameters

absPath

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

Implemented in KoDirectoryStore, and KoQuaZipStore.

finalize()

bool KoStore::finalize

(

)

Call this before destroying the store, to be able to catch errors (e.g. from ksavefile)

Definition at line 395 of file KoStore.cpp.

{
    Q_D(KoStore);
    Q_ASSERT(!d->finalized);   // call this only once!
    d->finalized = true;
    return doFinalize();
}

References doFinalize().

hasDirectory()

bool KoStore::hasDirectory

(

const QString &

directoryName

)

Returns

true if the given directory exists in the archive

Definition at line 390 of file KoStore.cpp.

{
    return enterAbsoluteDirectory(directoryName);
}

References enterAbsoluteDirectory().

hasFile()

bool KoStore::hasFile

(

const QString &

fileName

)

const

Returns

true if the given file exists in the current directory, i.e. if open(fileName) will work.

Definition at line 384 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return fileExists(d->toExternalNaming(fileName));
}

References fileExists().

isOpen()

bool KoStore::isOpen

(

)

const

Check whether a file inside the store is currently opened with open(), ready to be read or written.

Returns

true if a file is currently opened.

Definition at line 150 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return d->isOpen;
}

leaveDirectory()

bool KoStore::leaveDirectory

(

)

Leaves a directory. Equivalent to "cd .."

Returns

true on success, false if we were at the root already to make it possible to "loop to the root"

Definition at line 270 of file KoStore.cpp.

{
    Q_D(KoStore);
    if (d->currentPath.isEmpty())
        return false;
 
    d->currentPath.pop_back();
 
    return enterAbsoluteDirectory(currentPath());
}

References currentPath(), and enterAbsoluteDirectory().

mode()

KoStore::Mode KoStore::mode

(

)

const

Returns

the mode used when opening, read or write

Definition at line 420 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return d->mode;
}

open()

bool KoStore::open

(

const QString &

name

)

Open a new file inside the store

Parameters

name	The filename, internal representation ("root", "tar:/0"... ). If the tar:/ prefix is missing it's assumed to be a relative URI.

Returns

true on success.

Definition at line 109 of file KoStore.cpp.

{
    Q_D(KoStore);
    // This also converts from relative to absolute, i.e. merges the currentPath()
    d->fileName = d->toExternalNaming(_name);
 
    debugStore << "KOStore" << _name << d->fileName;
 
    if (d->isOpen) {
        warnStore << "Store is already opened, missing close";
        return false;
    }
 
    if (d->fileName.length() > 512) {
        errorStore << "KoStore: Filename " << d->fileName << " is too long" << Qt::endl;
        return false;
    }
 
    if (d->mode == Write) {
        debugStore << "opening for writing" << d->fileName;
        if (d->filesList.contains(d->fileName)) {
            warnStore << "KoStore: Duplicate filename" << d->fileName;
            return false;
        }
 
        d->filesList.append(d->fileName);
 
        d->size = 0;
        if (!openWrite(d->fileName))
            return false;
    } else if (d->mode == Read) {
        debugStore << "Opening for reading" << d->fileName;
        if (!openRead(d->fileName))
            return false;
    } else
        return false;
 
    d->isOpen = true;
    return true;
}

References debugStore, errorStore, openRead(), openWrite(), Read, warnStore, and Write.

openRead()

virtual bool KoStore::openRead ( const QString & name )

protectedpure virtual

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

Implemented in KoDirectoryStore, and KoQuaZipStore.

openWrite()

virtual bool KoStore::openWrite ( const QString & name )

protectedpure virtual

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

Implemented in KoDirectoryStore, and KoQuaZipStore.

operator=()

KoStore & KoStore::operator= ( const KoStore & store )

private

don't assign

popDirectory()

void KoStore::popDirectory

(

)

Restores the previously pushed directory. No-op if the stack is empty.

Definition at line 300 of file KoStore.cpp.

{
    Q_D(KoStore);
    d->currentPath.clear();
    enterAbsoluteDirectory(QString());
    enterDirectory(d->directoryStack.pop());
}

References enterAbsoluteDirectory(), and enterDirectory().

pos()

qint64 KoStore::pos

(

)

const

Definition at line 347 of file KoStore.cpp.

{
    Q_D(const KoStore);
    return d->stream->pos();
}

pushDirectory()

void KoStore::pushDirectory

(

)

Stacks the current directory. Restore the current path using popDirectory .

Definition at line 294 of file KoStore.cpp.

{
    Q_D(KoStore);
    d->directoryStack.push(currentPath());
}

References currentPath().

read() [1/2]

qint64 KoStore::read	(	char *	buffer,
		qint64	length )

Read data from the currently opened file. You can also use the streams for this.

Returns

size of data read, -1 on error

Definition at line 203 of file KoStore.cpp.

{
    Q_D(KoStore);
    if (!d->isOpen) {
        errorStore << "KoStore: You must open before reading" << Qt::endl;
        return -1;
    }
    if (d->mode != Read) {
        errorStore << "KoStore: Can not read from store that is opened for writing" << Qt::endl;
        return -1;
    }
 
    return d->stream->read(_buffer, _len);
}

References errorStore, and Read.

read() [2/2]

QByteArray KoStore::read

(

qint64

max

)

Read data from the currently opened file. You can also use the streams for this.

Definition at line 181 of file KoStore.cpp.

{
    Q_D(KoStore);
    QByteArray data;
 
    if (!d->isOpen) {
        warnStore << "You must open before reading";
        return data;
    }
    if (d->mode != Read) {
        errorStore << "KoStore: Can not read from store that is opened for writing" << Qt::endl;
        return data;
    }
 
    return d->stream->read(max);
}

References errorStore, Read, and warnStore.

seek()

bool KoStore::seek

(

qint64

pos

)

See QIODevice.

Definition at line 341 of file KoStore.cpp.

{
    Q_D(KoStore);
    return d->stream->seek(pos);
}

References pos().

setCompressionEnabled()

void KoStore::setCompressionEnabled ( bool e )

virtual

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

Reimplemented in KoQuaZipStore.

Definition at line 403 of file KoStore.cpp.

{
}

setSubstitution()

void KoStore::setSubstitution	(	const QString &	name,
		const QString &	substitution )

When reading, in the paths in the store where name occurs, substitution is used.

Definition at line 407 of file KoStore.cpp.

{
    Q_D(KoStore);
    d->substituteThis = name;
    d->substituteWith = substitution;
}

size()

qint64 KoStore::size

(

)

const

Returns

the size of the currently opened file, -1 on error. Can be used as an argument for the read methods, for instance

Definition at line 239 of file KoStore.cpp.

{
    Q_D(const KoStore);
    if (!d->isOpen) {
        warnStore << "You must open before asking for a size";
        return static_cast<qint64>(-1);
    }
    if (d->mode != Read) {
        warnStore << "Can not get size from store that is opened for writing";
        return static_cast<qint64>(-1);
    }
    return d->size;
}

References Read, and warnStore.

write() [1/2]

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

virtual

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

Reimplemented in KoQuaZipStore.

Definition at line 218 of file KoStore.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;
    }
 
    int nwritten = d->stream->write(_data, _len);
    Q_ASSERT(nwritten == (int)_len);
    d->size += nwritten;
 
    return nwritten;
}

References errorStore, and Write.

write() [2/2]

qint64 KoStore::write

(

const QByteArray &

data

)

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

Definition at line 198 of file KoStore.cpp.

{
    return write(data.constData(), data.size());   // see below
}

References write().

Member Data Documentation

d_ptr

KoStorePrivate* KoStore::d_ptr

protected

Definition at line 278 of file KoStore.h.

---

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

• libs/store/KoStore.h
• libs/store/KoStore.cpp