/****************************************************************************
** Meta object code from reading C++ file 'jobs.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.6.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../src/ark-17.04.3/kerfuffle/jobs.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'jobs.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.6.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_Kerfuffle__Job_t {
    QByteArrayData data[25];
    char stringdata0[234];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__Job_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__Job_t qt_meta_stringdata_Kerfuffle__Job = {
    {
QT_MOC_LITERAL(0, 0, 14), // "Kerfuffle::Job"
QT_MOC_LITERAL(1, 15, 12), // "entryRemoved"
QT_MOC_LITERAL(2, 28, 0), // ""
QT_MOC_LITERAL(3, 29, 5), // "entry"
QT_MOC_LITERAL(4, 35, 8), // "newEntry"
QT_MOC_LITERAL(5, 44, 15), // "Archive::Entry*"
QT_MOC_LITERAL(6, 60, 9), // "userQuery"
QT_MOC_LITERAL(7, 70, 17), // "Kerfuffle::Query*"
QT_MOC_LITERAL(8, 88, 6), // "doWork"
QT_MOC_LITERAL(9, 95, 11), // "onCancelled"
QT_MOC_LITERAL(10, 107, 7), // "onError"
QT_MOC_LITERAL(11, 115, 7), // "message"
QT_MOC_LITERAL(12, 123, 7), // "details"
QT_MOC_LITERAL(13, 131, 6), // "onInfo"
QT_MOC_LITERAL(14, 138, 4), // "info"
QT_MOC_LITERAL(15, 143, 7), // "onEntry"
QT_MOC_LITERAL(16, 151, 10), // "onProgress"
QT_MOC_LITERAL(17, 162, 8), // "progress"
QT_MOC_LITERAL(18, 171, 14), // "onEntryRemoved"
QT_MOC_LITERAL(19, 186, 4), // "path"
QT_MOC_LITERAL(20, 191, 10), // "onFinished"
QT_MOC_LITERAL(21, 202, 6), // "result"
QT_MOC_LITERAL(22, 209, 11), // "onUserQuery"
QT_MOC_LITERAL(23, 221, 6), // "Query*"
QT_MOC_LITERAL(24, 228, 5) // "query"

    },
    "Kerfuffle::Job\0entryRemoved\0\0entry\0"
    "newEntry\0Archive::Entry*\0userQuery\0"
    "Kerfuffle::Query*\0doWork\0onCancelled\0"
    "onError\0message\0details\0onInfo\0info\0"
    "onEntry\0onProgress\0progress\0onEntryRemoved\0"
    "path\0onFinished\0result\0onUserQuery\0"
    "Query*\0query"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__Job[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      12,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   74,    2, 0x06 /* Public */,
       4,    1,   77,    2, 0x06 /* Public */,
       6,    1,   80,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       8,    0,   83,    2, 0x0a /* Public */,
       9,    0,   84,    2, 0x09 /* Protected */,
      10,    2,   85,    2, 0x09 /* Protected */,
      13,    1,   90,    2, 0x09 /* Protected */,
      15,    1,   93,    2, 0x09 /* Protected */,
      16,    1,   96,    2, 0x09 /* Protected */,
      18,    1,   99,    2, 0x09 /* Protected */,
      20,    1,  102,    2, 0x09 /* Protected */,
      22,    1,  105,    2, 0x09 /* Protected */,

 // signals: parameters
    QMetaType::Void, QMetaType::QString,    3,
    QMetaType::Void, 0x80000000 | 5,    2,
    QMetaType::Void, 0x80000000 | 7,    2,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString, QMetaType::QString,   11,   12,
    QMetaType::Void, QMetaType::QString,   14,
    QMetaType::Void, 0x80000000 | 5,    3,
    QMetaType::Void, QMetaType::Double,   17,
    QMetaType::Void, QMetaType::QString,   19,
    QMetaType::Void, QMetaType::Bool,   21,
    QMetaType::Void, 0x80000000 | 23,   24,

       0        // eod
};

void Kerfuffle::Job::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Job *_t = static_cast<Job *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->entryRemoved((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 1: _t->newEntry((*reinterpret_cast< Archive::Entry*(*)>(_a[1]))); break;
        case 2: _t->userQuery((*reinterpret_cast< Kerfuffle::Query*(*)>(_a[1]))); break;
        case 3: _t->doWork(); break;
        case 4: _t->onCancelled(); break;
        case 5: _t->onError((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 6: _t->onInfo((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 7: _t->onEntry((*reinterpret_cast< Archive::Entry*(*)>(_a[1]))); break;
        case 8: _t->onProgress((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 9: _t->onEntryRemoved((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 10: _t->onFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 11: _t->onUserQuery((*reinterpret_cast< Query*(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (Job::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Job::entryRemoved)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (Job::*_t)(Archive::Entry * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Job::newEntry)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (Job::*_t)(Kerfuffle::Query * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Job::userQuery)) {
                *result = 2;
                return;
            }
        }
    }
}

const QMetaObject Kerfuffle::Job::staticMetaObject = {
    { &KJob::staticMetaObject, qt_meta_stringdata_Kerfuffle__Job.data,
      qt_meta_data_Kerfuffle__Job,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::Job::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::Job::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__Job.stringdata0))
        return static_cast<void*>(const_cast< Job*>(this));
    return KJob::qt_metacast(_clname);
}

int Kerfuffle::Job::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KJob::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 12)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 12)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 12;
    }
    return _id;
}

// SIGNAL 0
void Kerfuffle::Job::entryRemoved(const QString & _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Kerfuffle::Job::newEntry(Archive::Entry * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void Kerfuffle::Job::userQuery(Kerfuffle::Query * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_Kerfuffle__LoadJob_t {
    QByteArrayData data[7];
    char stringdata0[78];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__LoadJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__LoadJob_t qt_meta_stringdata_Kerfuffle__LoadJob = {
    {
QT_MOC_LITERAL(0, 0, 18), // "Kerfuffle::LoadJob"
QT_MOC_LITERAL(1, 19, 6), // "doWork"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 10), // "onFinished"
QT_MOC_LITERAL(4, 38, 6), // "result"
QT_MOC_LITERAL(5, 45, 10), // "onNewEntry"
QT_MOC_LITERAL(6, 56, 21) // "const Archive::Entry*"

    },
    "Kerfuffle::LoadJob\0doWork\0\0onFinished\0"
    "result\0onNewEntry\0const Archive::Entry*"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__LoadJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   29,    2, 0x0a /* Public */,
       3,    1,   30,    2, 0x09 /* Protected */,
       5,    1,   33,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    4,
    QMetaType::Void, 0x80000000 | 6,    2,

       0        // eod
};

void Kerfuffle::LoadJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        LoadJob *_t = static_cast<LoadJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        case 1: _t->onFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: _t->onNewEntry((*reinterpret_cast< const Archive::Entry*(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject Kerfuffle::LoadJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__LoadJob.data,
      qt_meta_data_Kerfuffle__LoadJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::LoadJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::LoadJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__LoadJob.stringdata0))
        return static_cast<void*>(const_cast< LoadJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::LoadJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__BatchExtractJob_t {
    QByteArrayData data[15];
    char stringdata0[168];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__BatchExtractJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__BatchExtractJob_t qt_meta_stringdata_Kerfuffle__BatchExtractJob = {
    {
QT_MOC_LITERAL(0, 0, 26), // "Kerfuffle::BatchExtractJob"
QT_MOC_LITERAL(1, 27, 8), // "newEntry"
QT_MOC_LITERAL(2, 36, 0), // ""
QT_MOC_LITERAL(3, 37, 15), // "Archive::Entry*"
QT_MOC_LITERAL(4, 53, 5), // "entry"
QT_MOC_LITERAL(5, 59, 9), // "userQuery"
QT_MOC_LITERAL(6, 69, 6), // "Query*"
QT_MOC_LITERAL(7, 76, 5), // "query"
QT_MOC_LITERAL(8, 82, 6), // "doWork"
QT_MOC_LITERAL(9, 89, 19), // "slotLoadingProgress"
QT_MOC_LITERAL(10, 109, 8), // "progress"
QT_MOC_LITERAL(11, 118, 19), // "slotExtractProgress"
QT_MOC_LITERAL(12, 138, 19), // "slotLoadingFinished"
QT_MOC_LITERAL(13, 158, 5), // "KJob*"
QT_MOC_LITERAL(14, 164, 3) // "job"

    },
    "Kerfuffle::BatchExtractJob\0newEntry\0"
    "\0Archive::Entry*\0entry\0userQuery\0"
    "Query*\0query\0doWork\0slotLoadingProgress\0"
    "progress\0slotExtractProgress\0"
    "slotLoadingFinished\0KJob*\0job"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__BatchExtractJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       6,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       2,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   44,    2, 0x06 /* Public */,
       5,    1,   47,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       8,    0,   50,    2, 0x0a /* Public */,
       9,    1,   51,    2, 0x08 /* Private */,
      11,    1,   54,    2, 0x08 /* Private */,
      12,    1,   57,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 6,    7,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Double,   10,
    QMetaType::Void, QMetaType::Double,   10,
    QMetaType::Void, 0x80000000 | 13,   14,

       0        // eod
};

void Kerfuffle::BatchExtractJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        BatchExtractJob *_t = static_cast<BatchExtractJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->newEntry((*reinterpret_cast< Archive::Entry*(*)>(_a[1]))); break;
        case 1: _t->userQuery((*reinterpret_cast< Query*(*)>(_a[1]))); break;
        case 2: _t->doWork(); break;
        case 3: _t->slotLoadingProgress((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 4: _t->slotExtractProgress((*reinterpret_cast< double(*)>(_a[1]))); break;
        case 5: _t->slotLoadingFinished((*reinterpret_cast< KJob*(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< KJob* >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (BatchExtractJob::*_t)(Archive::Entry * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&BatchExtractJob::newEntry)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (BatchExtractJob::*_t)(Query * );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&BatchExtractJob::userQuery)) {
                *result = 1;
                return;
            }
        }
    }
}

const QMetaObject Kerfuffle::BatchExtractJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__BatchExtractJob.data,
      qt_meta_data_Kerfuffle__BatchExtractJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::BatchExtractJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::BatchExtractJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__BatchExtractJob.stringdata0))
        return static_cast<void*>(const_cast< BatchExtractJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::BatchExtractJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 6)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 6)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    return _id;
}

// SIGNAL 0
void Kerfuffle::BatchExtractJob::newEntry(Archive::Entry * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void Kerfuffle::BatchExtractJob::userQuery(Query * _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
struct qt_meta_stringdata_Kerfuffle__CreateJob_t {
    QByteArrayData data[3];
    char stringdata0[29];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__CreateJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__CreateJob_t qt_meta_stringdata_Kerfuffle__CreateJob = {
    {
QT_MOC_LITERAL(0, 0, 20), // "Kerfuffle::CreateJob"
QT_MOC_LITERAL(1, 21, 6), // "doWork"
QT_MOC_LITERAL(2, 28, 0) // ""

    },
    "Kerfuffle::CreateJob\0doWork\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__CreateJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::CreateJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        CreateJob *_t = static_cast<CreateJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::CreateJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__CreateJob.data,
      qt_meta_data_Kerfuffle__CreateJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::CreateJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::CreateJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__CreateJob.stringdata0))
        return static_cast<void*>(const_cast< CreateJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::CreateJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__ExtractJob_t {
    QByteArrayData data[3];
    char stringdata0[30];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__ExtractJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__ExtractJob_t qt_meta_stringdata_Kerfuffle__ExtractJob = {
    {
QT_MOC_LITERAL(0, 0, 21), // "Kerfuffle::ExtractJob"
QT_MOC_LITERAL(1, 22, 6), // "doWork"
QT_MOC_LITERAL(2, 29, 0) // ""

    },
    "Kerfuffle::ExtractJob\0doWork\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__ExtractJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::ExtractJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        ExtractJob *_t = static_cast<ExtractJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::ExtractJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__ExtractJob.data,
      qt_meta_data_Kerfuffle__ExtractJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::ExtractJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::ExtractJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__ExtractJob.stringdata0))
        return static_cast<void*>(const_cast< ExtractJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::ExtractJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__TempExtractJob_t {
    QByteArrayData data[3];
    char stringdata0[34];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__TempExtractJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__TempExtractJob_t qt_meta_stringdata_Kerfuffle__TempExtractJob = {
    {
QT_MOC_LITERAL(0, 0, 25), // "Kerfuffle::TempExtractJob"
QT_MOC_LITERAL(1, 26, 6), // "doWork"
QT_MOC_LITERAL(2, 33, 0) // ""

    },
    "Kerfuffle::TempExtractJob\0doWork\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__TempExtractJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::TempExtractJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        TempExtractJob *_t = static_cast<TempExtractJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::TempExtractJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__TempExtractJob.data,
      qt_meta_data_Kerfuffle__TempExtractJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::TempExtractJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::TempExtractJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__TempExtractJob.stringdata0))
        return static_cast<void*>(const_cast< TempExtractJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::TempExtractJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__PreviewJob_t {
    QByteArrayData data[1];
    char stringdata0[22];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__PreviewJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__PreviewJob_t qt_meta_stringdata_Kerfuffle__PreviewJob = {
    {
QT_MOC_LITERAL(0, 0, 21) // "Kerfuffle::PreviewJob"

    },
    "Kerfuffle::PreviewJob"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__PreviewJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Kerfuffle::PreviewJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::PreviewJob::staticMetaObject = {
    { &TempExtractJob::staticMetaObject, qt_meta_stringdata_Kerfuffle__PreviewJob.data,
      qt_meta_data_Kerfuffle__PreviewJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::PreviewJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::PreviewJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__PreviewJob.stringdata0))
        return static_cast<void*>(const_cast< PreviewJob*>(this));
    return TempExtractJob::qt_metacast(_clname);
}

int Kerfuffle::PreviewJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = TempExtractJob::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__OpenJob_t {
    QByteArrayData data[1];
    char stringdata0[19];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__OpenJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__OpenJob_t qt_meta_stringdata_Kerfuffle__OpenJob = {
    {
QT_MOC_LITERAL(0, 0, 18) // "Kerfuffle::OpenJob"

    },
    "Kerfuffle::OpenJob"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__OpenJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Kerfuffle::OpenJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::OpenJob::staticMetaObject = {
    { &TempExtractJob::staticMetaObject, qt_meta_stringdata_Kerfuffle__OpenJob.data,
      qt_meta_data_Kerfuffle__OpenJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::OpenJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::OpenJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__OpenJob.stringdata0))
        return static_cast<void*>(const_cast< OpenJob*>(this));
    return TempExtractJob::qt_metacast(_clname);
}

int Kerfuffle::OpenJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = TempExtractJob::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__OpenWithJob_t {
    QByteArrayData data[1];
    char stringdata0[23];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__OpenWithJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__OpenWithJob_t qt_meta_stringdata_Kerfuffle__OpenWithJob = {
    {
QT_MOC_LITERAL(0, 0, 22) // "Kerfuffle::OpenWithJob"

    },
    "Kerfuffle::OpenWithJob"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__OpenWithJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       0,    0, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

       0        // eod
};

void Kerfuffle::OpenWithJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::OpenWithJob::staticMetaObject = {
    { &OpenJob::staticMetaObject, qt_meta_stringdata_Kerfuffle__OpenWithJob.data,
      qt_meta_data_Kerfuffle__OpenWithJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::OpenWithJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::OpenWithJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__OpenWithJob.stringdata0))
        return static_cast<void*>(const_cast< OpenWithJob*>(this));
    return OpenJob::qt_metacast(_clname);
}

int Kerfuffle::OpenWithJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OpenJob::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__AddJob_t {
    QByteArrayData data[5];
    char stringdata0[44];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__AddJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__AddJob_t qt_meta_stringdata_Kerfuffle__AddJob = {
    {
QT_MOC_LITERAL(0, 0, 17), // "Kerfuffle::AddJob"
QT_MOC_LITERAL(1, 18, 6), // "doWork"
QT_MOC_LITERAL(2, 25, 0), // ""
QT_MOC_LITERAL(3, 26, 10), // "onFinished"
QT_MOC_LITERAL(4, 37, 6) // "result"

    },
    "Kerfuffle::AddJob\0doWork\0\0onFinished\0"
    "result"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__AddJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x0a /* Public */,
       3,    1,   25,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    4,

       0        // eod
};

void Kerfuffle::AddJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        AddJob *_t = static_cast<AddJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        case 1: _t->onFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject Kerfuffle::AddJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__AddJob.data,
      qt_meta_data_Kerfuffle__AddJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::AddJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::AddJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__AddJob.stringdata0))
        return static_cast<void*>(const_cast< AddJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::AddJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__MoveJob_t {
    QByteArrayData data[5];
    char stringdata0[45];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__MoveJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__MoveJob_t qt_meta_stringdata_Kerfuffle__MoveJob = {
    {
QT_MOC_LITERAL(0, 0, 18), // "Kerfuffle::MoveJob"
QT_MOC_LITERAL(1, 19, 6), // "doWork"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 10), // "onFinished"
QT_MOC_LITERAL(4, 38, 6) // "result"

    },
    "Kerfuffle::MoveJob\0doWork\0\0onFinished\0"
    "result"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__MoveJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x0a /* Public */,
       3,    1,   25,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    4,

       0        // eod
};

void Kerfuffle::MoveJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        MoveJob *_t = static_cast<MoveJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        case 1: _t->onFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject Kerfuffle::MoveJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__MoveJob.data,
      qt_meta_data_Kerfuffle__MoveJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::MoveJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::MoveJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__MoveJob.stringdata0))
        return static_cast<void*>(const_cast< MoveJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::MoveJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__CopyJob_t {
    QByteArrayData data[5];
    char stringdata0[45];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__CopyJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__CopyJob_t qt_meta_stringdata_Kerfuffle__CopyJob = {
    {
QT_MOC_LITERAL(0, 0, 18), // "Kerfuffle::CopyJob"
QT_MOC_LITERAL(1, 19, 6), // "doWork"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 10), // "onFinished"
QT_MOC_LITERAL(4, 38, 6) // "result"

    },
    "Kerfuffle::CopyJob\0doWork\0\0onFinished\0"
    "result"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__CopyJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x0a /* Public */,
       3,    1,   25,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    4,

       0        // eod
};

void Kerfuffle::CopyJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        CopyJob *_t = static_cast<CopyJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        case 1: _t->onFinished((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject Kerfuffle::CopyJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__CopyJob.data,
      qt_meta_data_Kerfuffle__CopyJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::CopyJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::CopyJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__CopyJob.stringdata0))
        return static_cast<void*>(const_cast< CopyJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::CopyJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__DeleteJob_t {
    QByteArrayData data[3];
    char stringdata0[29];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__DeleteJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__DeleteJob_t qt_meta_stringdata_Kerfuffle__DeleteJob = {
    {
QT_MOC_LITERAL(0, 0, 20), // "Kerfuffle::DeleteJob"
QT_MOC_LITERAL(1, 21, 6), // "doWork"
QT_MOC_LITERAL(2, 28, 0) // ""

    },
    "Kerfuffle::DeleteJob\0doWork\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__DeleteJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::DeleteJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        DeleteJob *_t = static_cast<DeleteJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::DeleteJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__DeleteJob.data,
      qt_meta_data_Kerfuffle__DeleteJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::DeleteJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::DeleteJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__DeleteJob.stringdata0))
        return static_cast<void*>(const_cast< DeleteJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::DeleteJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__CommentJob_t {
    QByteArrayData data[3];
    char stringdata0[30];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__CommentJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__CommentJob_t qt_meta_stringdata_Kerfuffle__CommentJob = {
    {
QT_MOC_LITERAL(0, 0, 21), // "Kerfuffle::CommentJob"
QT_MOC_LITERAL(1, 22, 6), // "doWork"
QT_MOC_LITERAL(2, 29, 0) // ""

    },
    "Kerfuffle::CommentJob\0doWork\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__CommentJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::CommentJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        CommentJob *_t = static_cast<CommentJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::CommentJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__CommentJob.data,
      qt_meta_data_Kerfuffle__CommentJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::CommentJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::CommentJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__CommentJob.stringdata0))
        return static_cast<void*>(const_cast< CommentJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::CommentJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_Kerfuffle__TestJob_t {
    QByteArrayData data[4];
    char stringdata0[41];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kerfuffle__TestJob_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kerfuffle__TestJob_t qt_meta_stringdata_Kerfuffle__TestJob = {
    {
QT_MOC_LITERAL(0, 0, 18), // "Kerfuffle::TestJob"
QT_MOC_LITERAL(1, 19, 6), // "doWork"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 13) // "onTestSuccess"

    },
    "Kerfuffle::TestJob\0doWork\0\0onTestSuccess"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kerfuffle__TestJob[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x0a /* Public */,
       3,    0,   25,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void Kerfuffle::TestJob::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        TestJob *_t = static_cast<TestJob *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->doWork(); break;
        case 1: _t->onTestSuccess(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Kerfuffle::TestJob::staticMetaObject = {
    { &Job::staticMetaObject, qt_meta_stringdata_Kerfuffle__TestJob.data,
      qt_meta_data_Kerfuffle__TestJob,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


const QMetaObject *Kerfuffle::TestJob::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Kerfuffle::TestJob::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Kerfuffle__TestJob.stringdata0))
        return static_cast<void*>(const_cast< TestJob*>(this));
    return Job::qt_metacast(_clname);
}

int Kerfuffle::TestJob::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Job::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
QT_END_MOC_NAMESPACE
