#include <KoDirectoryStore.h>

Inheritance diagram for KoDirectoryStore:

Public Member Functions
	KoDirectoryStore (const QString &path, Mode _mode, bool writeMimetype)

	~KoDirectoryStore () override

Public Member Functions inherited from KoStore
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 ()

Protected Member Functions
bool	closeRead () override

bool	closeWrite () override

bool	enterAbsoluteDirectory (const QString &path) override

bool	enterRelativeDirectory (const QString &dirName) override

bool	fileExists (const QString &absPath) const override

void	init ()

bool	openRead (const QString &name) override

bool	openReadOrWrite (const QString &name, QIODevice::OpenModeFlag ioMode)

bool	openWrite (const QString &name) override

Protected Member Functions inherited from KoStore
virtual bool	doFinalize ()

	KoStore (Mode mode, bool writeMimetype=true)

Private Attributes
QString	m_basePath

QString	m_currentPath

QFile *	m_file

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 14 of file KoDirectoryStore.h.

Constructor & Destructor Documentation

◆ KoDirectoryStore()

KoDirectoryStore::KoDirectoryStore	(	const QString &	path,
		Mode	_mode,
		bool	writeMimetype )

Definition at line 16 of file KoDirectoryStore.cpp.

    : KoStore(mode, writeMimetype)
    , m_basePath(path)
{
    //debugStore << "path:" << path
 
 
    //debugStore << "base path:" << m_basePath;
 
    init();
}

References init().

◆ ~KoDirectoryStore()

KoDirectoryStore::~KoDirectoryStore ( )

override

Definition at line 28 of file KoDirectoryStore.cpp.

29{

30}

Member Function Documentation

◆ closeRead()

bool KoDirectoryStore::closeRead ( )

inlineoverrideprotectedvirtual

Returns: true on success

Implements KoStore.

Definition at line 27 of file KoDirectoryStore.h.

                              {
        return true;
    }

◆ closeWrite()

bool KoDirectoryStore::closeWrite ( )

inlineoverrideprotectedvirtual

Returns: true on success

Implements KoStore.

Definition at line 30 of file KoDirectoryStore.h.

                               {
        return true;
    }

◆ enterAbsoluteDirectory()

bool KoDirectoryStore::enterAbsoluteDirectory ( const QString & path )

overrideprotectedvirtual

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

Implements KoStore.

Definition at line 95 of file KoDirectoryStore.cpp.

{
    m_currentPath = m_basePath + path;
    //debugStore <<"KoDirectoryStore::enterAbsoluteDirectory" << m_currentPath;
    QDir newDir(m_currentPath);
    Q_ASSERT(newDir.exists());   // We've been there before, therefore it must exist.
    return newDir.exists();
}

References m_basePath, and m_currentPath.

◆ enterRelativeDirectory()

bool KoDirectoryStore::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 77 of file KoDirectoryStore.cpp.

{
    QDir origDir(m_currentPath);
    m_currentPath += dirName;
    if (!m_currentPath.endsWith('/'))
        m_currentPath += '/';
    //debugStore <<"KoDirectoryStore::enterRelativeDirectory m_currentPath now" << m_currentPath;
    QDir newDir(m_currentPath);
    if (newDir.exists())
        return true;
    // Dir doesn't exist. If reading -> error. If writing -> create.
    if (mode() == Write && origDir.mkdir(dirName)) {
        debugStore << "Created" << dirName << " under" << origDir.absolutePath();
        return true;
    }
    return false;
}

References debugStore, m_currentPath, KoStore::mode(), and KoStore::Write.

◆ fileExists()

bool KoDirectoryStore::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 104 of file KoDirectoryStore.cpp.

{
    debugStore << "KoDirectoryStore::fileExists" << m_basePath + absPath;
    return QFile::exists(m_basePath + absPath);
}

References debugStore, and m_basePath.

◆ init()

void KoDirectoryStore::init ( )

protected

Definition at line 32 of file KoDirectoryStore.cpp.

{
    Q_D(KoStore);
 
    if (!m_basePath.endsWith('/'))
        m_basePath += '/';
    m_currentPath = m_basePath;
 
    QDir dir(m_basePath);
    if (dir.exists()) {
        d->good = true;
        return;
    }
    // Dir doesn't exist. If reading -> error. If writing -> create.
    if (d->mode == Write && dir.mkpath(m_basePath)) {
        debugStore << "KoDirectoryStore::init Directory created:" << m_basePath;
        d->good = true;
    }
}

References debugStore, m_basePath, m_currentPath, and KoStore::Write.

◆ openRead()

bool KoDirectoryStore::openRead ( const QString & name )

inlineoverrideprotectedvirtual

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 24 of file KoDirectoryStore.h.

                                                {
        return openReadOrWrite(name, QIODevice::ReadOnly);
    }

References openReadOrWrite().

◆ openReadOrWrite()

bool KoDirectoryStore::openReadOrWrite	(	const QString &	name,
		QIODevice::OpenModeFlag	ioMode )

protected

Definition at line 52 of file KoDirectoryStore.cpp.

{
    Q_D(KoStore);
    //debugStore <<"KoDirectoryStore::openReadOrWrite m_currentPath=" << m_currentPath <<" name=" << name;
    int pos = name.lastIndexOf('/');
    if (pos != -1) { // there are subdirs in the name -> maybe need to create them, when writing
        pushDirectory(); // remember where we were
        enterAbsoluteDirectory(QString());
        //debugStore <<"KoDirectoryStore::openReadOrWrite entering" << name.left(pos);
        bool ret = enterDirectory(name.left(pos));
        popDirectory();
        if (!ret)
            return false;
    }
    d->stream = new QFile(m_basePath + name);
    if (!d->stream->open(iomode)) {
        delete d->stream;
        d->stream = 0;
        return false;
    }
    if (iomode == QIODevice::ReadOnly)
        d->size = d->stream->size();
    return true;
}

References enterAbsoluteDirectory(), KoStore::enterDirectory(), m_basePath, KoStore::popDirectory(), KoStore::pos(), and KoStore::pushDirectory().

◆ openWrite()

bool KoDirectoryStore::openWrite ( const QString & name )

inlineoverrideprotectedvirtual

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 21 of file KoDirectoryStore.h.

                                                 {
        return openReadOrWrite(name, QIODevice::WriteOnly);
    }

References openReadOrWrite().

Member Data Documentation

◆ m_basePath

QString KoDirectoryStore::m_basePath

private

Definition at line 40 of file KoDirectoryStore.h.

◆ m_currentPath

QString KoDirectoryStore::m_currentPath

private

Definition at line 43 of file KoDirectoryStore.h.

◆ m_file

QFile* KoDirectoryStore::m_file

private

Definition at line 46 of file KoDirectoryStore.h.

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

libs/store/KoDirectoryStore.h
libs/store/KoDirectoryStore.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KoDirectoryStore()

◆ ~KoDirectoryStore()

Member Function Documentation

◆ closeRead()

◆ closeWrite()

◆ enterAbsoluteDirectory()

◆ enterRelativeDirectory()

◆ fileExists()

◆ init()

◆ openRead()

◆ openReadOrWrite()

◆ openWrite()

Member Data Documentation

◆ m_basePath

◆ m_currentPath

◆ m_file