KisExiv2IODevice Class Reference

#include <KisExiv2IODevice.h>

Inheritance diagram for KisExiv2IODevice:

Public Types
using	ptr_type = Exiv2::BasicIo::AutoPtr

Public Member Functions
int	close () override
bool	eof () const override
int	error () const override
int	getb () override
bool	isopen () const override
	KisExiv2IODevice (QString path)
Exiv2::byte *	mmap (bool isWriteable=false) override
int	munmap () override
int	open () override
std::string	path () const override
int	putb (Exiv2::byte data) override
long	read (Exiv2::byte *buf, long rcount) override
Exiv2::DataBuf	read (long rcount) override
int	seek (long offset, Position pos) override
size_t	size () const override
long	tell () const override
void	transfer (BasicIo &src) override
long	write (const Exiv2::byte *data, long wcount) override
long	write (Exiv2::BasicIo &src) override
	~KisExiv2IODevice () override

Private Member Functions
QString	filePathQString () const
bool	open (QFile::OpenMode mode)
bool	renameToCurrent (const QString srcPath)

Private Attributes
QFile	m_file
Exiv2::byte *	m_mappedArea

Detailed Description

Definition at line 18 of file KisExiv2IODevice.h.

Member Typedef Documentation

ptr_type

using KisExiv2IODevice::ptr_type = Exiv2::BasicIo::AutoPtr

Definition at line 24 of file KisExiv2IODevice.h.

Constructor & Destructor Documentation

KisExiv2IODevice()

KisExiv2IODevice::KisExiv2IODevice

(

QString

path

)

Definition at line 12 of file KisExiv2IODevice.cpp.

    : m_file(path)
    , m_mappedArea(nullptr)
{
}

~KisExiv2IODevice()

KisExiv2IODevice::~KisExiv2IODevice ( )

override

Definition at line 18 of file KisExiv2IODevice.cpp.

{
    m_file.close();
}

References m_file.

Member Function Documentation

close()

int KisExiv2IODevice::close ( )

override

Definition at line 33 of file KisExiv2IODevice.cpp.

{
    if (munmap() != 0) {
        return 1;
    }
    m_file.close();
    return 0;
}

References m_file, and munmap().

eof()

bool KisExiv2IODevice::eof ( ) const

override

Definition at line 261 of file KisExiv2IODevice.cpp.

{
    return m_file.atEnd();
}

References m_file.

error()

int KisExiv2IODevice::error ( ) const

override

Definition at line 255 of file KisExiv2IODevice.cpp.

{
    // zero if no error
    return m_file.error() != QFileDevice::NoError;
}

References m_file.

filePathQString()

QString KisExiv2IODevice::filePathQString ( ) const

private

Definition at line 297 of file KisExiv2IODevice.cpp.

{
    return QFileInfo(m_file).absoluteFilePath();
}

References m_file.

getb()

int KisExiv2IODevice::getb ( )

override

Definition at line 132 of file KisExiv2IODevice.cpp.

{
    char c;
    if (m_file.getChar(&c)) {
        return c;
    } else {
        return EOF;
    }
}

References m_file.

isopen()

bool KisExiv2IODevice::isopen ( ) const

override

Definition at line 250 of file KisExiv2IODevice.cpp.

{
    return m_file.isOpen();
}

References m_file.

mmap()

Exiv2::byte * KisExiv2IODevice::mmap ( bool isWriteable = false )

override

Definition at line 199 of file KisExiv2IODevice.cpp.

{
    Q_UNUSED(isWriteable);
 
    if (munmap() != 0) {
        qWarning() << "KisExiv2IODevice::mmap: Couldn't unmap the mapped file";
        return nullptr;
    }
 
    m_mappedArea = m_file.map(0, size(), QFile::NoOptions);
    if (!m_mappedArea) {
        // We show a warning, but originally we should be throwing an exception.
        qWarning() << "KisExiv2IODevice::mmap: Couldn't map the file" << m_file.fileName();
    }
    return m_mappedArea;
}

References m_file, m_mappedArea, munmap(), and size().

munmap()

int KisExiv2IODevice::munmap ( )

override

Definition at line 216 of file KisExiv2IODevice.cpp.

{
    if (m_mappedArea) {
        bool successful = m_file.unmap(m_mappedArea);
        m_mappedArea = nullptr;
        return !successful;
    }
    return 0;
}

References m_file, and m_mappedArea.

open() [1/2]

int KisExiv2IODevice::open ( )

override

Definition at line 23 of file KisExiv2IODevice.cpp.

{
    if (m_file.isOpen()) {
        m_file.close();
    }
 
    // return zero if successful
    return !m_file.open(QFile::ReadWrite);
}

References m_file.

open() [2/2]

bool KisExiv2IODevice::open ( QFile::OpenMode mode )

private

Definition at line 275 of file KisExiv2IODevice.cpp.

{
    if (m_file.isOpen()) {
        m_file.close();
    }
    return m_file.open(mode);
}

References m_file.

path()

std::string KisExiv2IODevice::path ( ) const

override

Definition at line 269 of file KisExiv2IODevice.cpp.

{
    return filePathQString().toStdString();
}

putb()

int KisExiv2IODevice::putb ( Exiv2::byte data )

override

Definition at line 86 of file KisExiv2IODevice.cpp.

{
    if (!m_file.isWritable()) {
        qWarning() << "KisExiv2IODevice: File not open for writing.";
        return 0;
    }
    if (m_file.putChar(data)) {
        return data;
    } else {
        return EOF;
    }
}

References m_file.

read() [1/2]

long KisExiv2IODevice::read ( Exiv2::byte * buf, long rcount )

override

Definition at line 119 of file KisExiv2IODevice.cpp.

{
    const qint64 bytesRead = m_file.read(reinterpret_cast<char *>(buf), rcount);
    if (bytesRead > 0) {
        return bytesRead;
    } else {
        qWarning() << "KisExiv2IODevice: Couldn't read file:" << m_file.errorString();
        // some error or EOF
        return 0;
    }
}

read() [2/2]

Exiv2::DataBuf KisExiv2IODevice::read ( long rcount )

override

Definition at line 102 of file KisExiv2IODevice.cpp.

{
    Exiv2::DataBuf buf(rcount);
#if EXIV2_TEST_VERSION(0,28,0)
    const size_t readCount = read(buf.data(), buf.size());
    buf.resize(readCount);
#else
    const long readCount = read(buf.pData_, buf.size_);
    buf.size_ = readCount;
#endif
    return buf;
}

renameToCurrent()

bool KisExiv2IODevice::renameToCurrent ( const QString srcPath )

private

Definition at line 283 of file KisExiv2IODevice.cpp.

{
    QFile::Permissions permissions = QFile::permissions(filePathQString());
    if (QFile::exists(filePathQString())) {
        QFile::remove(filePathQString());
    }
 
    if (!QFile(srcPath).rename(filePathQString())) {
        qWarning() << "KisExiv2IODevice:renameToCurrent Couldn't copy file from" << srcPath << "to" << filePathQString();
        return false;
    }
    return QFile(filePathQString()).setPermissions(permissions);
}

References filePathQString().

seek()

int KisExiv2IODevice::seek ( long offset, Position pos )

override

Definition at line 181 of file KisExiv2IODevice.cpp.

{
    qint64 pos = 0;
    switch (position) {
    case Exiv2::BasicIo::beg:
        pos = offset;
        break;
    case Exiv2::BasicIo::cur:
        pos = tell() + offset;
        break;
    case Exiv2::BasicIo::end:
        pos = size() + offset;
        break;
    }
    return m_file.seek(pos);
}

size()

size_t KisExiv2IODevice::size ( ) const

override

Definition at line 242 of file KisExiv2IODevice.cpp.

{
    if (m_file.isWritable()) {
        m_file.flush();
    }
    return m_file.size();
}

References m_file.

tell()

long KisExiv2IODevice::tell ( ) const

override

Definition at line 236 of file KisExiv2IODevice.cpp.

{
    return m_file.pos();
}

transfer()

void KisExiv2IODevice::transfer ( BasicIo & src )

override

Definition at line 142 of file KisExiv2IODevice.cpp.

{
    bool isFileBased = (dynamic_cast<Exiv2::FileIo *>(&src) || dynamic_cast<KisExiv2IODevice *>(&src));
    bool useFallback = false;
 
    if (isFileBased) {
        const QString srcPath = QString::fromStdString(src.path());
        // use fallback if copying failed (e.g on Android :( )
        useFallback = !renameToCurrent(srcPath);
    }
 
    if (!isFileBased || useFallback) {
        const bool wasOpen = isopen();
        const QIODevice::OpenMode oldMode = m_file.openMode();
 
        // this sets file positioner to the beginning.
        if (src.open() != 0) {
            qWarning() << "KisExiv2IODevice::transfer: Couldn't open src file" << QString::fromStdString(src.path());
            return;
        }
 
        if (!open(QIODevice::ReadWrite | QIODevice::Truncate)) {
            qWarning() << "KisExiv2IODevice::transfer: Couldn't open dest file" << filePathQString();
            return;
        }
        write(src);
        src.close();
 
        if (wasOpen) {
            open(oldMode);
        } else {
            close();
        }
    }
}

References close(), filePathQString(), isopen(), m_file, open(), renameToCurrent(), and write().

write() [1/2]

long KisExiv2IODevice::write ( const Exiv2::byte * data, long wcount )

override

Definition at line 45 of file KisExiv2IODevice.cpp.

{
    if (!m_file.isWritable()) {
        qWarning() << "KisExiv2IODevice: File not open for writing.";
        return 0;
    }
    const qint64 writeCount = m_file.write(reinterpret_cast<const char *>(data), wcount);
    if (writeCount > 0) {
        return writeCount;
    }
 
    return 0;
}

write() [2/2]

long KisExiv2IODevice::write ( Exiv2::BasicIo & src )

override

Definition at line 63 of file KisExiv2IODevice.cpp.

{
    if (static_cast<BasicIo *>(this) == &src) {
        return 0;
    }
    if (!src.isopen()) {
        return 0;
    }
    if (!m_file.isWritable()) {
        qWarning() << "KisExiv2IODevice: File not open for writing.";
        return 0;
    }
    Exiv2::byte buffer[4096];
    long readCount = 0;
    long totalWriteCount = 0;
    while ((readCount = src.read(buffer, sizeof(buffer))) != 0) {
        totalWriteCount += write(buffer, readCount);
    }
 
    return totalWriteCount;
}

Member Data Documentation

m_file

QFile KisExiv2IODevice::m_file

mutableprivate

Definition at line 78 of file KisExiv2IODevice.h.

m_mappedArea

Exiv2::byte* KisExiv2IODevice::m_mappedArea

private

Definition at line 80 of file KisExiv2IODevice.h.

---

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

• plugins/metadata/common/KisExiv2IODevice.h
• plugins/metadata/common/KisExiv2IODevice.cpp