Some more code cosmetics.

Change-Id: If2a8d8ada04a0a9c89e6e7b52ff66565a12e1ac1
Reviewed-by: Tim Jenssen <tim.jenssen@nokia.com>

1 files changed, 422 insertions, 322 deletions

diff --git a/installerbuilder/libinstaller/3rdparty/p7zip_9.04/lib7z_facade.cpp b/installerbuilder/libinstaller/3rdparty/p7zip_9.04/lib7z_facade.cpp
index 88ee905dd..de84cabfa 100644
--- a/installerbuilder/libinstaller/3rdparty/p7zip_9.04/lib7z_facade.cpp
+++ b/installerbuilder/libinstaller/3rdparty/p7zip_9.04/lib7z_facade.cpp
@@ -37,15 +37,17 @@
 #include <common/errors.h>
 #include <common/fileutils.h>
 
-#include <QCoreApplication>
-#include <QDebug>
-#include <QDir>
-#include <QFileInfo>
-#include <QIODevice>
-#include <QPointer>
-#include <QString>
-#include <QStringList>
-#include <QTemporaryFile>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QDebug>
+#include <QtCore/QDir>
+#include <QtCore/QFileInfo>
+#include <QtCore/QIODevice>
+#include <QtCore/QMutex>
+#include <QtCore/QMutexLocker>
+#include <QtCore/QPointer>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QTemporaryFile>
 
 #ifdef _MSC_VER
 #pragma warning(disable:4297)
@@ -97,120 +99,135 @@ using namespace Lib7z;
 using namespace NWindows;
 
 namespace {
+/**
+* RAII class to create a directory (tryCreate()) and delete it on destruction unless released.
+*/
+struct DirectoryGuard {
+    explicit DirectoryGuard(const QString &path)
+        : m_path(path),
+        m_created(false),
+        m_released(false)
+    {
+        const QRegExp re(QLatin1String("\\\\|/"));
+        const QLatin1String sep("/");
+        m_path.replace(re, sep);
+    }
+
+    ~DirectoryGuard()
+    {
+        if (!m_created || m_released)
+            return;
+        QDir dir(m_path);
+        if (!dir.rmdir(m_path))
+            qWarning() << "Could not delete directory " << m_path;
+    }
+
     /**
-     * RAII class to create a directory (tryCreate()) and delete it on destruction unless released.
-     */
-    struct DirectoryGuard {
-        explicit DirectoryGuard(const QString &path)
-            : m_path(path),
-              m_created(false),
-              m_released(false)
+    * Tries to create the directorie structure.
+    * Returns a list of every directory created.
+    */
+    QStringList tryCreate() {
+        if (m_path.isEmpty())
+            return QStringList();
+
+        const QFileInfo fi(m_path);
+        if (fi.exists() && fi.isDir())
+            return QStringList();
+        if (fi.exists() && !fi.isDir())
+            throw SevenZipException(QObject::tr("Path exists but is not a folder: %1").arg(m_path));
+
+        QStringList created;
+
+        QDir toCreate(m_path);
+        while (!toCreate.exists())
         {
-            const QRegExp re(QLatin1String("\\\\|/"));
-            const QLatin1String sep("/");
-            m_path.replace(re, sep);
-        }
-        ~DirectoryGuard() {
-            if (!m_created || m_released)
-                return;
-            QDir dir(m_path);
-            if (!dir.rmdir(m_path))
-                qWarning() << "Could not delete directory " << m_path;
+            QString p = toCreate.absolutePath();
+            created.push_front(p);
+            p = p.section(QLatin1Char('/'), 0, -2);
+            toCreate = QDir(p);
         }
 
-        /**
-         * Tries to create the directorie structure.
-         * Returns a list of every directory created.
-         */
-        QStringList tryCreate() {
-            if (m_path.isEmpty())
-                return QStringList();
-
-            const QFileInfo fi(m_path);
-            if (fi.exists() && fi.isDir())
-                return QStringList();
-            if (fi.exists() && !fi.isDir())
-                throw SevenZipException(QObject::tr("Path exists but is not a folder: %1").arg(m_path));
-
-            QStringList created;
-
-            QDir toCreate(m_path);
-            while (!toCreate.exists())
-            {
-                QString p = toCreate.absolutePath();
-                created.push_front(p);
-                p = p.section(QLatin1Char('/'), 0, -2);
-                toCreate = QDir(p);
-            }
-
-            QDir dir(m_path);
-            m_created = dir.mkpath(m_path);
-            if (!m_created)
-                throw SevenZipException(QObject::tr("Could not create folder: %1").arg(m_path));
+        QDir dir(m_path);
+        m_created = dir.mkpath(m_path);
+        if (!m_created)
+            throw SevenZipException(QObject::tr("Could not create folder: %1").arg(m_path));
 
-            return created;
-        }
+        return created;
+    }
 
-        void release() {
-            m_released = true;
-        }
+    void release() {
+        m_released = true;
+    }
 
-        QString m_path;
-        bool m_created;
-        bool m_released;
-    };
+    QString m_path;
+    bool m_created;
+    bool m_released;
+};
 }
 
-static void throwIfNotOK(HRESULT result, const QString &msg) {
+static void throwIfNotOK(HRESULT result, const QString &msg)
+{
     if (result != S_OK)
         throw SevenZipException(msg);
 }
 
-static UString QString2UString(const QString &str) {
+static UString QString2UString(const QString &str)
+{
     return str.toStdWString().c_str();
 }
 
-static QString UString2QString(const UString& str) {
+static QString UString2QString(const UString& str)
+{
     return QString::fromStdWString(static_cast<const wchar_t*>(str));
 }
 
-static QString generateTempFileName() {
+static QString generateTempFileName()
+{
     QTemporaryFile tmp;
     if (!tmp.open())
-	throw SevenZipException(QObject::tr("Could not create temporary file"));
+        throw SevenZipException(QObject::tr("Could not create temporary file"));
     return QDir::toNativeSeparators(tmp.fileName());
 }
 
 /*
-static QStringList UStringVector2QStringList(const UStringVector& vec) {
-    QStringList res;
-    for (int i = 0; i < vec.Size(); ++i)
-        res += UString2QString(vec[i]);
-    return res;
+static QStringList UStringVector2QStringList(const UStringVector& vec)
+{
+QStringList res;
+for (int i = 0; i < vec.Size(); ++i)
+res += UString2QString(vec[i]);
+return res;
 }
 */
 
-static NCOM::CPropVariant readProperty(IInArchive* archive, int index, int propId) {
+static NCOM::CPropVariant readProperty(IInArchive* archive, int index, int propId)
+{
     NCOM::CPropVariant prop;
-    throwIfNotOK(archive->GetProperty(index, propId, &prop), QObject::tr("Could not retrieve property %1 for item %2").arg(QString::number(propId), QString::number(index)));
+    throwIfNotOK(archive->GetProperty(index, propId, &prop), QObject::tr("Could not retrieve property %1 "
+        "for item %2").arg(QString::number(propId), QString::number(index)));
     return prop;
 }
+
 static bool IsFileTimeZero(const FILETIME *lpFileTime)
 {
-  return (lpFileTime->dwLowDateTime == 0) && (lpFileTime->dwHighDateTime == 0);
+    return (lpFileTime->dwLowDateTime == 0) && (lpFileTime->dwHighDateTime == 0);
 }
 
 static bool IsDST(const QDateTime& datetime = QDateTime())
 {
-    const time_t seconds = static_cast< time_t >(datetime.isValid() ? datetime.toTime_t() : QDateTime::currentDateTime().toTime_t());
+    const time_t seconds = static_cast< time_t >(datetime.isValid() ? datetime.toTime_t()
+        : QDateTime::currentDateTime().toTime_t());
     const tm* const t = localtime(&seconds);
     return t->tm_isdst;
 }
 
-static QDateTime getDateTimeProperty(IInArchive* archive, int index, int propId, const QDateTime& defaultValue) {
+static
+    QDateTime getDateTimeProperty(IInArchive* archive, int index, int propId, const QDateTime& defaultValue)
+{
     const NCOM::CPropVariant prop = readProperty(archive, index, propId);
-    if (prop.vt != VT_FILETIME)
-        throw SevenZipException(QObject::tr("Property %1 for item %2 not of type VT_FILETIME but %3").arg(QString::number(propId), QString::number(index), QString::number(prop.vt)));
+    if (prop.vt != VT_FILETIME) {
+        throw SevenZipException(QObject::tr("Property %1 for item %2 not of type VT_FILETIME but %3")
+            .arg(QString::number(propId), QString::number(index), QString::number(prop.vt)));
+    }
     if (IsFileTimeZero(&prop.filetime))
         return defaultValue;
 
@@ -234,14 +251,16 @@ static QDateTime getDateTimeProperty(IInArchive* archive, int index, int propId,
     return result;
 }
 
-static quint64 getUInt64Property(IInArchive* archive, int index, int propId, quint64 defaultValue=0) {
+static quint64 getUInt64Property(IInArchive* archive, int index, int propId, quint64 defaultValue=0)
+{
     const NCOM::CPropVariant prop = readProperty(archive, index, propId);
     if (prop.vt == VT_EMPTY)
         return defaultValue;
     return static_cast<quint64>(ConvertPropVariantToUInt64(prop));
 }
 
-static quint32 getUInt32Property(IInArchive* archive, int index, int propId, quint32 defaultValue=0) {
+static quint32 getUInt32Property(IInArchive* archive, int index, int propId, quint32 defaultValue=0)
+{
     const NCOM::CPropVariant prop = readProperty(archive, index, propId);
     if (prop.vt == VT_EMPTY)
         return defaultValue;
@@ -252,8 +271,7 @@ static QFile::Permissions getPermissions(IInArchive* archive, int index, bool* h
 {
     quint32 attributes = getUInt32Property(archive, index, kpidAttrib, 0);
     QFile::Permissions permissions = 0;
-    if (attributes & FILE_ATTRIBUTE_UNIX_EXTENSION)
-    {
+    if (attributes & FILE_ATTRIBUTE_UNIX_EXTENSION) {
         if (hasPermissions != 0)
             *hasPermissions = true;
         // filter the unix permissions
@@ -261,133 +279,144 @@ static QFile::Permissions getPermissions(IInArchive* archive, int index, bool* h
         permissions |= static_cast< QFile::Permissions >((attributes & 0700) << 2);  // owner rights
         permissions |= static_cast< QFile::Permissions >((attributes & 0070) << 1);  // group
         permissions |= static_cast< QFile::Permissions >((attributes & 0007) << 0);  // and world rights
-    }
-    else if (hasPermissions != 0)
+    } else if (hasPermissions != 0) {
         *hasPermissions = false;
+    }
     return permissions;
 }
 
 namespace Lib7z {
-
-    class QIODeviceSequentialOutStream : public ISequentialOutStream, public CMyUnknownImp {
-    public:
-        MY_UNKNOWN_IMP
+class QIODeviceSequentialOutStream : public ISequentialOutStream, public CMyUnknownImp
+{
+public:
+    MY_UNKNOWN_IMP
         explicit QIODeviceSequentialOutStream(QIODevice* device);
-        ~QIODeviceSequentialOutStream();
+    ~QIODeviceSequentialOutStream();
 
-        /* reimp */ STDMETHOD(Write)(const void* data, UInt32 size, UInt32* processedSize);
+    /* reimp */ STDMETHOD(Write)(const void* data, UInt32 size, UInt32* processedSize);
 
-        private:
-            QPointer<QIODevice> m_device;
-            const bool closeOnDestroy;
-    };
+private:
+    QPointer<QIODevice> m_device;
+    const bool closeOnDestroy;
+};
 
+QIODeviceSequentialOutStream::QIODeviceSequentialOutStream(QIODevice* device)
+    : ISequentialOutStream(),
+    CMyUnknownImp(),
+    m_device(device),
+    closeOnDestroy(!device->isOpen())
+{
+    assert(m_device);
+    if (closeOnDestroy)
+        m_device->open(QIODevice::WriteOnly);
+}
 
-    QIODeviceSequentialOutStream::QIODeviceSequentialOutStream(QIODevice* device)
-        : ISequentialOutStream(),
-          CMyUnknownImp(),
-          m_device(device),
-          closeOnDestroy(!device->isOpen())
+QIODeviceSequentialOutStream::~QIODeviceSequentialOutStream()
+{
+    if (closeOnDestroy)
     {
-        assert(m_device);
-        if (closeOnDestroy)
-            m_device->open(QIODevice::WriteOnly);
+        m_device->close();
+        delete m_device;
     }
+}
 
-    QIODeviceSequentialOutStream::~QIODeviceSequentialOutStream()
-    {
-        if (closeOnDestroy)
-        {
-            m_device->close();
-            delete m_device;
-        }
+HRESULT QIODeviceSequentialOutStream::Write(const void* data, UInt32 size, UInt32* processedSize)
+{
+    if (!m_device) {
+        if (processedSize)
+            *processedSize = 0;
+        return E_FAIL;
     }
-
-    HRESULT QIODeviceSequentialOutStream::Write(const void* data, UInt32 size, UInt32* processedSize) {
-        if (!m_device) {
+    if (closeOnDestroy && !m_device->isOpen()) {
+        const bool opened = m_device->open(QIODevice::WriteOnly);
+        if (!opened) {
             if (processedSize)
                 *processedSize = 0;
-           return E_FAIL;
-        }
-        if (closeOnDestroy && !m_device->isOpen()) {
-            const bool opened = m_device->open(QIODevice::WriteOnly);
-            if (!opened) {
-                if (processedSize)
-                    *processedSize = 0;
-                return E_FAIL;
-            }
+            return E_FAIL;
         }
-
-        const qint64 written = m_device->write(reinterpret_cast<const char*>(data), size);
-        if (processedSize)
-            *processedSize = written;
-        return written >= 0 ? S_OK : E_FAIL;
     }
 
-    class QIODeviceInStream : public IInStream, public CMyUnknownImp {
-    public:
-        MY_UNKNOWN_IMP
+    const qint64 written = m_device->write(reinterpret_cast<const char*>(data), size);
+    if (processedSize)
+        *processedSize = written;
+    return written >= 0 ? S_OK : E_FAIL;
+}
 
-        explicit QIODeviceInStream(QIODevice* device)  : IInStream(), CMyUnknownImp(), m_device(device) {
-            assert(m_device);
-            assert(!m_device->isSequential());
-        }
+class QIODeviceInStream : public IInStream, public CMyUnknownImp
+{
+public:
+    MY_UNKNOWN_IMP
 
-        /* reimp */ STDMETHOD(Read)(void* data, UInt32 size, UInt32* processedSize) {
-            assert(m_device);
-            assert(m_device->isReadable());
-            const qint64 actual = m_device->read(reinterpret_cast<char*>(data), size);
-            Q_ASSERT(actual != 0 || m_device->atEnd());
-            if (processedSize)
-                *processedSize = actual;
-            return actual >= 0 ? S_OK : E_FAIL;
-        }
+    explicit QIODeviceInStream(QIODevice* device)  : IInStream(), CMyUnknownImp(), m_device(device)
+    {
+        assert(m_device);
+        assert(!m_device->isSequential());
+    }
 
-        /* reimp */ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64* newPosition) {
-            assert(m_device);
-            assert(!m_device->isSequential());
-            assert(m_device->isReadable());
-            if (seekOrigin > STREAM_SEEK_END)
-                return STG_E_INVALIDFUNCTION;
-            UInt64 np = 0;
-            switch(seekOrigin) {
-                case STREAM_SEEK_SET:
-                    np = offset;
-                    break;
-                case STREAM_SEEK_CUR:
-                    np = m_device->pos() + offset;
-                    break;
-                case STREAM_SEEK_END:
-                    np = m_device->size() + offset;
-                    break;
-                default:
-                    return STG_E_INVALIDFUNCTION;
-            }
+    /* reimp */ STDMETHOD(Read)(void* data, UInt32 size, UInt32* processedSize)
+    {
+        assert(m_device);
+        assert(m_device->isReadable());
+        const qint64 actual = m_device->read(reinterpret_cast<char*>(data), size);
+        Q_ASSERT(actual != 0 || m_device->atEnd());
+        if (processedSize)
+            *processedSize = actual;
+        return actual >= 0 ? S_OK : E_FAIL;
+    }
 
-            np = qBound(static_cast<UInt64>(0), np, static_cast<UInt64>(m_device->size() - 1));
-            const bool ok = m_device->seek(np);
-            if (newPosition)
-                *newPosition = np;
-            return ok ? S_OK : E_FAIL;
+    /* reimp */ STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64* newPosition)
+    {
+        assert(m_device);
+        assert(!m_device->isSequential());
+        assert(m_device->isReadable());
+        if (seekOrigin > STREAM_SEEK_END)
+            return STG_E_INVALIDFUNCTION;
+        UInt64 np = 0;
+        switch(seekOrigin) {
+        case STREAM_SEEK_SET:
+            np = offset;
+            break;
+        case STREAM_SEEK_CUR:
+            np = m_device->pos() + offset;
+            break;
+        case STREAM_SEEK_END:
+            np = m_device->size() + offset;
+            break;
+        default:
+            return STG_E_INVALIDFUNCTION;
         }
 
-        private:
-            QPointer<QIODevice> m_device;
-    };
+        np = qBound(static_cast<UInt64>(0), np, static_cast<UInt64>(m_device->size() - 1));
+        const bool ok = m_device->seek(np);
+        if (newPosition)
+            *newPosition = np;
+        return ok ? S_OK : E_FAIL;
+    }
+
+private:
+    QPointer<QIODevice> m_device;
+};
 }
 
-File::File() : permissions(0), uncompressedSize(0), compressedSize(0), isDirectory(false) {
+File::File()
+    : permissions(0)
+    , uncompressedSize(0)
+    , compressedSize(0)
+    , isDirectory(false)
+{
 }
 
-QVector<File> File::subtreeInPreorder() const {
+QVector<File> File::subtreeInPreorder() const
+{
     QVector<File> res;
     res += *this;
-    Q_FOREACH(const File& child, children)
+    Q_FOREACH (const File& child, children)
         res += child.subtreeInPreorder();
     return res;
 }
 
-bool File::operator<(const File& other) const {
+bool File::operator<(const File& other) const
+{
     if (path != other.path)
         return path < other.path;
     if (mtime != other.mtime)
@@ -403,17 +432,21 @@ bool File::operator<(const File& other) const {
     return false;
 }
 
-bool File::operator==(const File& other) const {
+bool File::operator==(const File& other) const
+{
     return mtime == other.mtime
-            && path == other.path
-            && uncompressedSize == other.uncompressedSize
-            && compressedSize == other.compressedSize
-            && isDirectory == other.isDirectory
-            && children == other.children
-            && (permissions == other.permissions || permissions == static_cast< QFile::Permissions >(-1) || other.permissions == static_cast< QFile::Permissions >(-1));
+        && path == other.path
+        && uncompressedSize == other.uncompressedSize
+        && compressedSize == other.compressedSize
+        && isDirectory == other.isDirectory
+        && children == other.children
+        && (permissions == other.permissions
+        || permissions == static_cast< QFile::Permissions >(-1)
+        || other.permissions == static_cast< QFile::Permissions >(-1));
 }
 
-QByteArray Lib7z::formatKeyValuePairs(const QVariantList& l) {
+QByteArray Lib7z::formatKeyValuePairs(const QVariantList& l)
+{
     assert(l.size() % 2 == 0);
     QByteArray res;
     for (QVariantList::ConstIterator it = l.constBegin(); it != l.constEnd(); ++it) {
@@ -426,78 +459,104 @@ QByteArray Lib7z::formatKeyValuePairs(const QVariantList& l) {
     return res;
 }
 
-class Job::Private {
+class Job::Private
+{
 public:
-    Private() : error(Lib7z::NoError) {}
+    Private()
+        : error(Lib7z::NoError)
+    {}
+
     int error;
     QString errorString;
 };
 
-Job::Job(QObject* parent) : QObject(parent), QRunnable(), d(new Private) {
+Job::Job(QObject* parent)
+    : QObject(parent)
+    , QRunnable()
+    , d(new Private)
+{
 }
 
-Job::~Job() {
+Job::~Job()
+{
     delete d;
 }
 
-void Job::emitResult() {
+void Job::emitResult()
+{
     emit finished(this);
 }
 
-void Job::setError(int code) {
+void Job::setError(int code)
+{
     d->error = code;
 }
 
-void Job::setErrorString(const QString &str) {
+void Job::setErrorString(const QString &str)
+{
     d->errorString = str;
 }
 
-void Job::emitProgress(qint64 completed, qint64 total) {
+void Job::emitProgress(qint64 completed, qint64 total)
+{
     emit progress(completed, total);
 }
 
-int Job::error() const {
+int Job::error() const
+{
     return d->error;
 }
 
-bool Job::hasError() const {
+bool Job::hasError() const
+{
     return d->error != NoError;
 }
 
-void Job::run() {
+void Job::run()
+{
     doStart();
 }
 
-QString Job::errorString() const {
+QString Job::errorString() const
+{
     return d->errorString;
 }
 
-void Job::start() {
+void Job::start()
+{
     QMetaObject::invokeMethod(this, "doStart", Qt::QueuedConnection);
 }
 
-class ListArchiveJob::Private {
+class ListArchiveJob::Private
+{
 public:
     QPointer<QIODevice> archive;
     QVector<File> files;
 };
 
-ListArchiveJob::ListArchiveJob(QObject* parent) : Job(parent), d(new Private) {
+ListArchiveJob::ListArchiveJob(QObject* parent)
+    : Job(parent)
+    , d(new Private)
+{
 }
 
-ListArchiveJob::~ListArchiveJob() {
+ListArchiveJob::~ListArchiveJob()
+{
     delete d;
 }
 
-QIODevice* ListArchiveJob::archive() const {
+QIODevice* ListArchiveJob::archive() const
+{
     return d->archive;
 }
 
-void ListArchiveJob::setArchive(QIODevice* device) {
+void ListArchiveJob::setArchive(QIODevice* device)
+{
     d->archive = device;
 }
 
-QVector<File> ListArchiveJob::index() const {
+QVector<File> ListArchiveJob::index() const
+{
     return d->files;
 }
 
@@ -506,14 +565,15 @@ class OpenArchiveInfo
 private:
     OpenArchiveInfo(QIODevice* device)
         : codecs(new CCodecs),
-          stream(new QIODeviceInStream(device))
+        stream(new QIODeviceInStream(device))
     {
         throwIfNotOK(codecs->Load(), QObject::tr("Could not load codecs"));
 
         if (!codecs->FindFormatForArchiveType(L"", formatIndices))
             throw SevenZipException(QObject::tr("Could not retrieve default format"));
 
-        throwIfNotOK(archiveLink.Open2(codecs.get(), formatIndices, false, stream, UString(), 0), QObject::tr("Could not open archive"));
+        throwIfNotOK(archiveLink.Open2(codecs.get(), formatIndices, false, stream, UString(), 0),
+            QObject::tr("Could not open archive"));
         if (archiveLink.Arcs.Size() == 0)
             throw SevenZipException(QObject::tr("No CArc found"));
 
@@ -555,7 +615,8 @@ void OpenArchiveInfoCleaner::deviceDestroyed(QObject* dev)
     delete OpenArchiveInfo::instances.take(device);
 }
 
-QVector<File> Lib7z::listArchive(QIODevice* archive) {
+QVector<File> Lib7z::listArchive(QIODevice* archive)
+{
     assert(archive);
     try {
         const OpenArchiveInfo* const openArchive = OpenArchiveInfo::instance(archive);
@@ -567,12 +628,14 @@ QVector<File> Lib7z::listArchive(QIODevice* archive) {
             IInArchive* const arch = arc.Archive;
 
             UInt32 numItems = 0;
-            throwIfNotOK(arch->GetNumberOfItems(&numItems), QObject::tr("Could not retrieve number of items in archive"));
+            throwIfNotOK(arch->GetNumberOfItems(&numItems), QObject::tr("Could not retrieve number of items "
+                "in archive"));
 
             flat.reserve(flat.size() + numItems);
             for (uint item = 0; item < numItems; ++item) {
                 UString s;
-                throwIfNotOK(arc.GetItemPath(item, s), QObject::tr("Could not retrieve path of archive item %1").arg(item));
+                throwIfNotOK(arc.GetItemPath(item, s), QObject::tr("Could not retrieve path of archive item "
+                    "%1").arg(item));
                 File f;
                 f.archiveIndex.setX(i);
                 f.archiveIndex.setY(item);
@@ -589,17 +652,17 @@ QVector<File> Lib7z::listArchive(QIODevice* archive) {
         return flat;
     } catch (const SevenZipException& e) {
         throw e;
-    }
-    catch(const char *err) {
+    } catch (const char *err) {
         throw SevenZipException(err);
-    }
-    catch (...) {
-        throw SevenZipException(QObject::tr("Unknown exception caught (%1)").arg(QString::fromLatin1(Q_FUNC_INFO)));
+    } catch (...) {
+        throw SevenZipException(QObject::tr("Unknown exception caught (%1)")
+            .arg(QString::fromLatin1(Q_FUNC_INFO)));
     }
     return QVector<File>(); // never reached
 }
 
-void ListArchiveJob::doStart() {
+void ListArchiveJob::doStart()
+{
     try {
         if (!d->archive)
             throw SevenZipException(tr("Could not list archive: QIODevice already destroyed"));
@@ -614,16 +677,17 @@ void ListArchiveJob::doStart() {
     emitResult();
 }
 
-class Lib7z::ExtractCallbackImpl : public IArchiveExtractCallback, public CMyUnknownImp {
+class Lib7z::ExtractCallbackImpl : public IArchiveExtractCallback, public CMyUnknownImp
+{
 public:
     MY_UNKNOWN_IMP
-    explicit ExtractCallbackImpl(ExtractCallback* qq)
+        explicit ExtractCallbackImpl(ExtractCallback* qq)
         : q(qq),
-          currentIndex(0),
-          arc(0),
-          total(0),
-          completed(0),
-          device(0)
+        currentIndex(0),
+        arc(0),
+        total(0),
+        completed(0),
+        device(0)
     {
     }
 
@@ -642,21 +706,19 @@ public:
     /* reimp */ STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream** outStream, Int32 askExtractMode)
     {
         Q_UNUSED(askExtractMode)
-        *outStream = 0;
-        if (device != 0)
-        {
+            *outStream = 0;
+        if (device != 0) {
             CMyComPtr<ISequentialOutStream> stream = new QIODeviceSequentialOutStream(device);
             *outStream = stream.Detach();
             return S_OK;
-        }
-        else if (!targetDir.isEmpty())
-        {
+        } else if (!targetDir.isEmpty()) {
             assert(arc);
 
             currentIndex = index;
 
             UString s;
-            throwIfNotOK(arc->GetItemPath(index, s), QObject::tr("Could not retrieve path of archive item %1").arg(index));
+            throwIfNotOK(arc->GetItemPath(index, s), QObject::tr("Could not retrieve path of archive item "
+                "%1").arg(index));
             const QString path = UString2QString(s).replace(QLatin1Char('\\'), QLatin1Char('/'));
 
             const QFileInfo fi(QString::fromLatin1("%1/%2").arg(targetDir, path));
@@ -666,9 +728,7 @@ public:
             bool isDir = false;
             IsArchiveItemFolder(arc->Archive, index, isDir);
             if (isDir)
-            {
                 QDir(fi.absolutePath()).mkdir(fi.fileName());
-            }
 
             // this makes sure that all directories created get removed as well
             for (QStringList::const_iterator it = directories.begin(); it != directories.end(); ++it)
@@ -679,9 +739,9 @@ public:
 
             q->setCurrentFile(fi.absoluteFilePath());
 
-            if (!isDir)
-            {
-                CMyComPtr< ISequentialOutStream > stream = new QIODeviceSequentialOutStream(new QFile(fi.absoluteFilePath()));
+            if (!isDir) {
+                CMyComPtr< ISequentialOutStream > stream = new QIODeviceSequentialOutStream(new QFile(fi
+                    .absoluteFilePath()));
                 *outStream = stream;
                 stream.Detach();
             }
@@ -692,22 +752,23 @@ public:
         return E_FAIL;
     }
 
-    /* reimp */ STDMETHOD(PrepareOperation)(Int32 askExtractMode) {
+    /* reimp */ STDMETHOD(PrepareOperation)(Int32 askExtractMode)
+    {
         Q_UNUSED(askExtractMode)
         return S_OK;
     }
 
-    /* reimp */ STDMETHOD(SetOperationResult)(Int32 resultEOperationResult) {
+    /* reimp */ STDMETHOD(SetOperationResult)(Int32 resultEOperationResult)
+    {
         Q_UNUSED(resultEOperationResult)
 
-        if (!targetDir.isEmpty() )
-        {
+        if (!targetDir.isEmpty()) {
             bool hasPerm;
             const QFile::Permissions permissions = getPermissions(arc->Archive, currentIndex, &hasPerm);
-            if (hasPerm)
-            {
+            if (hasPerm) {
                 UString s;
-                throwIfNotOK(arc->GetItemPath(currentIndex, s), QObject::tr("Could not retrieve path of archive item %1").arg(currentIndex));
+                throwIfNotOK(arc->GetItemPath(currentIndex, s), QObject::tr("Could not retrieve path of "
+                    "archive item %1").arg(currentIndex));
                 const QString path = UString2QString(s).replace(QLatin1Char('\\'), QLatin1Char('/'));
                 const QFileInfo fi(QString::fromLatin1("%1/%2").arg(targetDir, path));
                 QFile::setPermissions(fi.absoluteFilePath(), permissions);
@@ -716,37 +777,41 @@ public:
                 const quint32 attributes = getUInt32Property(arc->Archive, currentIndex, kpidAttrib, 0);
                 struct stat stat_info;
                 stat_info.st_mode = attributes >> 16;
-                if (S_ISLNK(stat_info.st_mode))
-                {
+                if (S_ISLNK(stat_info.st_mode)) {
                     QFile f(fi.absoluteFilePath());
                     f.open(QIODevice::ReadOnly);
                     const QByteArray path = f.readAll();
                     f.close();
                     f.remove();
 #ifdef Q_OS_WIN
-                    if (!CreateHardLinkWrapper( fi.absoluteFilePath(), QLatin1String(path)))
-                        throw SevenZipException(QObject::tr("Could not create file system lik at %1").arg(fi.absoluteFilePath()));
+                    if (!CreateHardLinkWrapper(fi.absoluteFilePath(), QLatin1String(path))) {
+                        throw SevenZipException(QObject::tr("Could not create file system lik at %1")
+                            .arg(fi.absoluteFilePath()));
+                    }
 #else
-                    if (!QFile::link(QString::fromLatin1(path), fi.absoluteFilePath()))
-                        throw SevenZipException(QObject::tr("Could not create softlink at %1").arg(fi.absoluteFilePath()));
+                    if (!QFile::link(QString::fromLatin1(path), fi.absoluteFilePath())) {
+                        throw SevenZipException(QObject::tr("Could not create softlink at %1")
+                            .arg(fi.absoluteFilePath()));
+                    }
 #endif
                 }
             }
-         }
+        }
 
         return S_OK;
     }
 
-    /* reimp */ STDMETHOD(SetTotal)(UInt64 t) {
+    /* reimp */ STDMETHOD(SetTotal)(UInt64 t)
+    {
         total = t;
         return S_OK;
     }
 
-    /* reimp */ STDMETHOD(SetCompleted)(const UInt64* c) {
+    /* reimp */ STDMETHOD(SetCompleted)(const UInt64* c)
+    {
         completed = *c;
-        if (total > 0) {
+        if (total > 0)
             return q->setCompleted(completed, total);
-        }
         return S_OK;
     }
 
@@ -766,27 +831,34 @@ private:
 };
 
 
-class Lib7z::ExtractCallbackPrivate {
+class Lib7z::ExtractCallbackPrivate
+{
 public:
-    explicit ExtractCallbackPrivate(ExtractCallback* qq) {
+    explicit ExtractCallbackPrivate(ExtractCallback* qq)
+    {
         impl = new ExtractCallbackImpl(qq);
     }
 
     CMyComPtr<ExtractCallbackImpl> impl;
 };
 
-ExtractCallback::ExtractCallback() : d(new ExtractCallbackPrivate(this)) {
+ExtractCallback::ExtractCallback()
+    : d(new ExtractCallbackPrivate(this))
+{
 }
 
-ExtractCallback::~ExtractCallback() {
+ExtractCallback::~ExtractCallback()
+{
     delete d;
 }
 
-ExtractCallbackImpl* ExtractCallback::impl() {
+ExtractCallbackImpl* ExtractCallback::impl()
+{
     return d->impl;
 }
 
-const ExtractCallbackImpl* ExtractCallback::impl() const {
+const ExtractCallbackImpl* ExtractCallback::impl() const
+{
     return d->impl;
 }
 
@@ -814,23 +886,29 @@ bool ExtractCallback::prepareForFile(const QString&)
     return true;
 }
 
-class Lib7z::ExtractCallbackJobImpl : public ExtractCallback {
-    public:
-        explicit ExtractCallbackJobImpl(ExtractItemJob* j) : ExtractCallback(), job(j) {}
-    private:
-        /* reimp */ HRESULT setCompleted(quint64 c, quint64 t) {
-            emit job->progress(c, t);
-            return S_OK;
-        }
+class Lib7z::ExtractCallbackJobImpl : public ExtractCallback
+{
+public:
+    explicit ExtractCallbackJobImpl(ExtractItemJob* j)
+        : ExtractCallback()
+        , job(j)
+    {}
+
+private:
+    /* reimp */ HRESULT setCompleted(quint64 c, quint64 t)
+    {
+        emit job->progress(c, t);
+        return S_OK;
+    }
 
-        ExtractItemJob* const job;
+    ExtractItemJob* const job;
 };
 
 class Lib7z::UpdateCallbackImpl : public IUpdateCallbackUI2, public CMyUnknownImp
 {
 public:
     MY_UNKNOWN_IMP
-    explicit UpdateCallbackImpl(UpdateCallback* qq)
+        explicit UpdateCallbackImpl(UpdateCallback* qq)
         : q(qq)
     {
     }
@@ -838,15 +916,15 @@ public:
     {
     }
     /**
-     * \reimp
-     */
+    * \reimp
+    */
     HRESULT SetTotal(UInt64)
     {
         return S_OK;
     }
     /**
-     * \reimp
-     */
+    * \reimp
+    */
     HRESULT SetCompleted(const UInt64*)
     {
         return S_OK;
@@ -915,8 +993,8 @@ public:
     }
 
     /**
-     * \reimp
-     */
+    * \reimp
+    */
     HRESULT SetOperationResult(Int32)
     {
         // TODO!
@@ -970,7 +1048,6 @@ UpdateCallbackImpl* UpdateCallback::impl()
     return d->impl();
 }
 
-
 void UpdateCallback::setSource(const QStringList &dir)
 {
     d->impl()->setSource(dir);
@@ -981,18 +1058,16 @@ void UpdateCallback::setTarget(QIODevice* target)
     d->impl()->setTarget(target);
 }
 
-class ExtractItemJob::Private {
+class ExtractItemJob::Private
+{
 public:
     Private(ExtractItemJob* qq)
         : q(qq),
-          target(0),
-          callback(new ExtractCallbackJobImpl(q))
+        target(0),
+        callback(new ExtractCallbackJobImpl(q))
     {
     }
 
-    ~Private() {
-    }
-
     ExtractItemJob* q;
     File item;
     QPointer<QIODevice> archive;
@@ -1001,34 +1076,44 @@ public:
     ExtractCallback* callback;
 };
 
-ExtractItemJob::ExtractItemJob(QObject* parent) : Job(parent), d(new Private(this)) {
+ExtractItemJob::ExtractItemJob(QObject* parent)
+    : Job(parent)
+    , d(new Private(this))
+{
 }
 
-ExtractItemJob::~ExtractItemJob() {
+ExtractItemJob::~ExtractItemJob()
+{
     delete d;
 }
 
-File ExtractItemJob::item() const {
+File ExtractItemJob::item() const
+{
     return d->item;
 }
 
-void ExtractItemJob::setItem(const File& item) {
+void ExtractItemJob::setItem(const File& item)
+{
     d->item = item;
 }
 
-QIODevice* ExtractItemJob::archive() const {
+QIODevice* ExtractItemJob::archive() const
+{
     return d->archive;
 }
 
-void ExtractItemJob::setArchive(QIODevice* archive) {
+void ExtractItemJob::setArchive(QIODevice* archive)
+{
     d->archive = archive;
 }
 
-QString ExtractItemJob::targetDirectory() const {
+QString ExtractItemJob::targetDirectory() const
+{
     return d->targetDirectory;
 }
 
-void ExtractItemJob::setTargetDirectory(const QString &dir) {
+void ExtractItemJob::setTargetDirectory(const QString &dir)
+{
     d->targetDirectory = dir;
     d->target = 0;
 }
@@ -1092,25 +1177,23 @@ void Lib7z::createArchive(QIODevice* archive, const QStringList &sourceDirectori
             QInstaller::blockingCopy(&file, archive, file.size());
         }
         QFile file(tempFile);
-        if (!file.remove())
-            qWarning("%s: Could not remove temporary file %s: %s", Q_FUNC_INFO, qPrintable(tempFile), qPrintable(file.errorString()));
-    }
-    catch(const char *err)
-    {
+        if (!file.remove()) {
+            qWarning("%s: Could not remove temporary file %s: %s", Q_FUNC_INFO, qPrintable(tempFile),
+                qPrintable(file.errorString()));
+        }
+    } catch (const char *err) {
         std::cout << err << std::endl;
         throw SevenZipException(err);
-    }
-    catch (const QInstaller::Error &err)
-    {
-	throw SevenZipException(err.message());
-    }
-    catch(...)
-    {
-        throw SevenZipException(QObject::tr("Unknown exception caught (%1)").arg(QString::fromLatin1(Q_FUNC_INFO)));
+    } catch (const QInstaller::Error &err) {
+        throw SevenZipException(err.message());
+    } catch (...) {
+        throw SevenZipException(QObject::tr("Unknown exception caught (%1)")
+            .arg(QString::fromLatin1(Q_FUNC_INFO)));
     }
 }
 
-void Lib7z::extractArchive(QIODevice* archive, const File& item, QIODevice* target, ExtractCallback* callback) {
+void Lib7z::extractArchive(QIODevice* archive, const File& item, QIODevice* target, ExtractCallback* callback)
+{
     assert(archive);
     assert(target);
 
@@ -1122,33 +1205,42 @@ void Lib7z::extractArchive(QIODevice* archive, const File& item, QIODevice* targ
         const OpenArchiveInfo* const openArchive = OpenArchiveInfo::instance(archive);
 
         const int arcIdx = item.archiveIndex.x();
-        if (arcIdx < 0 || arcIdx >= openArchive->archiveLink.Arcs.Size())
-            throw SevenZipException(QObject::tr("CArc index %1 out of bounds [0, %2]").arg(openArchive->archiveLink.Arcs.Size() - 1));
+        if (arcIdx < 0 || arcIdx >= openArchive->archiveLink.Arcs.Size()) {
+            throw SevenZipException(QObject::tr("CArc index %1 out of bounds [0, %2]")
+                .arg(openArchive->archiveLink.Arcs.Size() - 1));
+        }
         const CArc& arc = openArchive->archiveLink.Arcs[arcIdx];
         IInArchive* const parchive = arc.Archive;
 
         const UInt32 itemIdx = item.archiveIndex.y();
         UInt32 numItems = 0;
-        throwIfNotOK(parchive->GetNumberOfItems(&numItems), QObject::tr("Could not retrieve number of items in archive"));
-        if (itemIdx >= numItems)
-            throw SevenZipException(QObject::tr("Item index %1 out of bounds [0, %2]").arg(itemIdx).arg(numItems - 1));
+        throwIfNotOK(parchive->GetNumberOfItems(&numItems), QObject::tr("Could not retrieve number of items "
+            "in archive"));
+        if (itemIdx >= numItems) {
+            throw SevenZipException(QObject::tr("Item index %1 out of bounds [0, %2]").arg(itemIdx)
+                .arg(numItems - 1));
+        }
 
         UString s;
-        throwIfNotOK(arc.GetItemPath(itemIdx, s), QObject::tr("Could not retrieve path of archive item %1").arg(itemIdx));
+        throwIfNotOK(arc.GetItemPath(itemIdx, s), QObject::tr("Could not retrieve path of archive item %1")
+            .arg(itemIdx));
         assert(item.path == UString2QString(s).replace(QLatin1Char('\\'), QLatin1Char('/')));
 
         callback->setTarget(target);
         const LONG extractResult = parchive->Extract(&itemIdx, 1, /*testmode=*/1, callback->impl());
         //TODO: how to interpret result?
         throwIfNotOK(extractResult, QObject::tr("Extracting %1 failed.").arg(item.path));
-    } catch(const char *err) {
+    } catch (const char *err) {
         throw SevenZipException(err);
     } catch (...) {
-        throw SevenZipException(QObject::tr("Unknown exception caught (%1)").arg(QString::fromLatin1(Q_FUNC_INFO)));
+        throw SevenZipException(QObject::tr("Unknown exception caught (%1)")
+            .arg(QString::fromLatin1(Q_FUNC_INFO)));
     }
 }
 
-void Lib7z::extractArchive(QIODevice* archive, const File& item, const QString &targetDirectory, ExtractCallback* callback) {
+void Lib7z::extractArchive(QIODevice* archive, const File& item, const QString &targetDirectory,
+    ExtractCallback* callback)
+{
     assert(archive);
 
     std::auto_ptr<ExtractCallback> dummyCallback(callback ? 0 : new ExtractCallback);
@@ -1159,8 +1251,10 @@ void Lib7z::extractArchive(QIODevice* archive, const File& item, const QString &
     DirectoryGuard outDir(fi.absolutePath());
     outDir.tryCreate();
     QFile out(fi.absoluteFilePath());
-    if (!out.open(QIODevice::WriteOnly)) //TODO use tmp file
-        throw SevenZipException(QObject::tr("Could not create output file for writing: %1").arg(fi.absoluteFilePath()));
+    if (!out.open(QIODevice::WriteOnly)) { //TODO use tmp file
+        throw SevenZipException(QObject::tr("Could not create output file for writing: %1")
+            .arg(fi.absoluteFilePath()));
+    }
     if (item.permissions)
         out.setPermissions(item.permissions);
     callback->setTarget(&out);
@@ -1190,7 +1284,8 @@ void Lib7z::extractArchive(QIODevice* archive, const QString &targetDirectory, E
         IInArchive* const arch = arc.Archive;
         callback->impl()->setArchive(&arc);
         const LONG extractResult = arch->Extract(0, static_cast< UInt32 >(-1), false, callback->impl());
-        throwIfNotOK(extractResult, QObject::tr("Extraction failed.")); //TODO is it possible to get a more detailed error?
+        //TODO is it possible to get a more detailed error?
+        throwIfNotOK(extractResult, QObject::tr("Extraction failed."));
     }
 
     outDir.release();
@@ -1205,7 +1300,8 @@ bool Lib7z::isSupportedArchive(const QString &archive)
     return isSupportedArchive(&file);
 }
 
-bool Lib7z::isSupportedArchive(QIODevice* archive) {
+bool Lib7z::isSupportedArchive(QIODevice* archive)
+{
     assert(archive);
     assert(!archive->isSequential());
     const qint64 initialPos = archive->pos();
@@ -1219,26 +1315,30 @@ bool Lib7z::isSupportedArchive(QIODevice* archive) {
             throw SevenZipException(QObject::tr("Could not retrieve default format"));
 
         CArchiveLink archiveLink;
-        const CMyComPtr<IInStream> stream = new QIODeviceInStream(archive); //CMyComPtr is needed, otherwise it crashes in OpenStream()
+        //CMyComPtr is needed, otherwise it crashes in OpenStream()
+        const CMyComPtr<IInStream> stream = new QIODeviceInStream(archive);
 
-        const HRESULT result = archiveLink.Open2(codecs.get(), formatIndices, /*stdInMode*/false, stream, UString(), 0);
+        const HRESULT result = archiveLink.Open2(codecs.get(), formatIndices, /*stdInMode*/false, stream,
+            UString(), 0);
 
         archive->seek(initialPos);
         return result == S_OK;
     } catch (const SevenZipException& e) {
         archive->seek(initialPos);
         throw e;
-    } catch(const char *err) {
+    } catch (const char *err) {
         archive->seek(initialPos);
         throw SevenZipException(err);
-    } catch(...) {
+    } catch (...) {
         archive->seek(initialPos);
-        throw SevenZipException(QObject::tr("Unknown exception caught (%1)").arg(QString::fromLatin1(Q_FUNC_INFO)));
+        throw SevenZipException(QObject::tr("Unknown exception caught (%1)")
+            .arg(QString::fromLatin1(Q_FUNC_INFO)));
     }
     return false; // never reached
 }
 
-void ExtractItemJob::doStart() {
+void ExtractItemJob::doStart()
+{
     try {
         if (!d->archive)
             throw SevenZipException(tr("Could not list archive: QIODevice not set or already destroyed"));