/****************************************************************************
** Meta object code from reading C++ file 'clicommand.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/kid3-3.4.5/src/app/cli/clicommand.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'clicommand.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_CliCommand_t {
    QByteArrayData data[4];
    char stringdata0[31];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_CliCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_CliCommand_t qt_meta_stringdata_CliCommand = {
    {
QT_MOC_LITERAL(0, 0, 10), // "CliCommand"
QT_MOC_LITERAL(1, 11, 8), // "finished"
QT_MOC_LITERAL(2, 20, 0), // ""
QT_MOC_LITERAL(3, 21, 9) // "terminate"

    },
    "CliCommand\0finished\0\0terminate"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_CliCommand[] = {

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

 // signals: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x06 /* Public */,

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

 // signals: parameters
    QMetaType::Void,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void CliCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        CliCommand *_t = static_cast<CliCommand *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->finished(); break;
        case 1: _t->terminate(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (CliCommand::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&CliCommand::finished)) {
                *result = 0;
                return;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject CliCommand::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_CliCommand.data,
      qt_meta_data_CliCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *CliCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_CliCommand.stringdata0))
        return static_cast<void*>(const_cast< CliCommand*>(this));
    return QObject::qt_metacast(_clname);
}

int CliCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::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;
}

// SIGNAL 0
void CliCommand::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
}
struct qt_meta_stringdata_HelpCommand_t {
    QByteArrayData data[1];
    char stringdata0[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_HelpCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_HelpCommand_t qt_meta_stringdata_HelpCommand = {
    {
QT_MOC_LITERAL(0, 0, 11) // "HelpCommand"

    },
    "HelpCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_HelpCommand[] = {

 // 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 HelpCommand::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 HelpCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_HelpCommand.data,
      qt_meta_data_HelpCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *HelpCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_HelpCommand.stringdata0))
        return static_cast<void*>(const_cast< HelpCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int HelpCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TimeoutCommand_t {
    QByteArrayData data[1];
    char stringdata0[15];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TimeoutCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TimeoutCommand_t qt_meta_stringdata_TimeoutCommand = {
    {
QT_MOC_LITERAL(0, 0, 14) // "TimeoutCommand"

    },
    "TimeoutCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TimeoutCommand[] = {

 // 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 TimeoutCommand::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 TimeoutCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TimeoutCommand.data,
      qt_meta_data_TimeoutCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TimeoutCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TimeoutCommand.stringdata0))
        return static_cast<void*>(const_cast< TimeoutCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TimeoutCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_QuitCommand_t {
    QByteArrayData data[1];
    char stringdata0[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QuitCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QuitCommand_t qt_meta_stringdata_QuitCommand = {
    {
QT_MOC_LITERAL(0, 0, 11) // "QuitCommand"

    },
    "QuitCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QuitCommand[] = {

 // 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 QuitCommand::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 QuitCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_QuitCommand.data,
      qt_meta_data_QuitCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *QuitCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QuitCommand.stringdata0))
        return static_cast<void*>(const_cast< QuitCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int QuitCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_CdCommand_t {
    QByteArrayData data[1];
    char stringdata0[10];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_CdCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_CdCommand_t qt_meta_stringdata_CdCommand = {
    {
QT_MOC_LITERAL(0, 0, 9) // "CdCommand"

    },
    "CdCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_CdCommand[] = {

 // 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 CdCommand::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 CdCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_CdCommand.data,
      qt_meta_data_CdCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *CdCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_CdCommand.stringdata0))
        return static_cast<void*>(const_cast< CdCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int CdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_PwdCommand_t {
    QByteArrayData data[1];
    char stringdata0[11];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PwdCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PwdCommand_t qt_meta_stringdata_PwdCommand = {
    {
QT_MOC_LITERAL(0, 0, 10) // "PwdCommand"

    },
    "PwdCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PwdCommand[] = {

 // 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 PwdCommand::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 PwdCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PwdCommand.data,
      qt_meta_data_PwdCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *PwdCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_PwdCommand.stringdata0))
        return static_cast<void*>(const_cast< PwdCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PwdCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_LsCommand_t {
    QByteArrayData data[1];
    char stringdata0[10];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LsCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LsCommand_t qt_meta_stringdata_LsCommand = {
    {
QT_MOC_LITERAL(0, 0, 9) // "LsCommand"

    },
    "LsCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LsCommand[] = {

 // 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 LsCommand::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 LsCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_LsCommand.data,
      qt_meta_data_LsCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *LsCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_LsCommand.stringdata0))
        return static_cast<void*>(const_cast< LsCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int LsCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_SaveCommand_t {
    QByteArrayData data[1];
    char stringdata0[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SaveCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SaveCommand_t qt_meta_stringdata_SaveCommand = {
    {
QT_MOC_LITERAL(0, 0, 11) // "SaveCommand"

    },
    "SaveCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SaveCommand[] = {

 // 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 SaveCommand::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 SaveCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SaveCommand.data,
      qt_meta_data_SaveCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *SaveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_SaveCommand.stringdata0))
        return static_cast<void*>(const_cast< SaveCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SaveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_SelectCommand_t {
    QByteArrayData data[1];
    char stringdata0[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SelectCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SelectCommand_t qt_meta_stringdata_SelectCommand = {
    {
QT_MOC_LITERAL(0, 0, 13) // "SelectCommand"

    },
    "SelectCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SelectCommand[] = {

 // 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 SelectCommand::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 SelectCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SelectCommand.data,
      qt_meta_data_SelectCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *SelectCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_SelectCommand.stringdata0))
        return static_cast<void*>(const_cast< SelectCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SelectCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TagCommand_t {
    QByteArrayData data[1];
    char stringdata0[11];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TagCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TagCommand_t qt_meta_stringdata_TagCommand = {
    {
QT_MOC_LITERAL(0, 0, 10) // "TagCommand"

    },
    "TagCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TagCommand[] = {

 // 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 TagCommand::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 TagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagCommand.data,
      qt_meta_data_TagCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TagCommand.stringdata0))
        return static_cast<void*>(const_cast< TagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_GetCommand_t {
    QByteArrayData data[1];
    char stringdata0[11];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_GetCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_GetCommand_t qt_meta_stringdata_GetCommand = {
    {
QT_MOC_LITERAL(0, 0, 10) // "GetCommand"

    },
    "GetCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_GetCommand[] = {

 // 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 GetCommand::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 GetCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_GetCommand.data,
      qt_meta_data_GetCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *GetCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_GetCommand.stringdata0))
        return static_cast<void*>(const_cast< GetCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int GetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_SetCommand_t {
    QByteArrayData data[1];
    char stringdata0[11];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SetCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SetCommand_t qt_meta_stringdata_SetCommand = {
    {
QT_MOC_LITERAL(0, 0, 10) // "SetCommand"

    },
    "SetCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SetCommand[] = {

 // 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 SetCommand::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 SetCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_SetCommand.data,
      qt_meta_data_SetCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *SetCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_SetCommand.stringdata0))
        return static_cast<void*>(const_cast< SetCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int SetCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_RevertCommand_t {
    QByteArrayData data[1];
    char stringdata0[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RevertCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RevertCommand_t qt_meta_stringdata_RevertCommand = {
    {
QT_MOC_LITERAL(0, 0, 13) // "RevertCommand"

    },
    "RevertCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RevertCommand[] = {

 // 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 RevertCommand::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 RevertCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RevertCommand.data,
      qt_meta_data_RevertCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *RevertCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_RevertCommand.stringdata0))
        return static_cast<void*>(const_cast< RevertCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RevertCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_ImportCommand_t {
    QByteArrayData data[1];
    char stringdata0[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ImportCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ImportCommand_t qt_meta_stringdata_ImportCommand = {
    {
QT_MOC_LITERAL(0, 0, 13) // "ImportCommand"

    },
    "ImportCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ImportCommand[] = {

 // 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 ImportCommand::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 ImportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ImportCommand.data,
      qt_meta_data_ImportCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ImportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ImportCommand.stringdata0))
        return static_cast<void*>(const_cast< ImportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_BatchImportCommand_t {
    QByteArrayData data[5];
    char stringdata0[50];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_BatchImportCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_BatchImportCommand_t qt_meta_stringdata_BatchImportCommand = {
    {
QT_MOC_LITERAL(0, 0, 18), // "BatchImportCommand"
QT_MOC_LITERAL(1, 19, 19), // "onReportImportEvent"
QT_MOC_LITERAL(2, 39, 0), // ""
QT_MOC_LITERAL(3, 40, 4), // "type"
QT_MOC_LITERAL(4, 45, 4) // "text"

    },
    "BatchImportCommand\0onReportImportEvent\0"
    "\0type\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_BatchImportCommand[] = {

 // 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,    2,   19,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int, QMetaType::QString,    3,    4,

       0        // eod
};

void BatchImportCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        BatchImportCommand *_t = static_cast<BatchImportCommand *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->onReportImportEvent((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObject BatchImportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_BatchImportCommand.data,
      qt_meta_data_BatchImportCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *BatchImportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_BatchImportCommand.stringdata0))
        return static_cast<void*>(const_cast< BatchImportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int BatchImportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_AlbumArtCommand_t {
    QByteArrayData data[6];
    char stringdata0[54];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_AlbumArtCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_AlbumArtCommand_t qt_meta_stringdata_AlbumArtCommand = {
    {
QT_MOC_LITERAL(0, 0, 15), // "AlbumArtCommand"
QT_MOC_LITERAL(1, 16, 18), // "onDownloadFinished"
QT_MOC_LITERAL(2, 35, 0), // ""
QT_MOC_LITERAL(3, 36, 4), // "data"
QT_MOC_LITERAL(4, 41, 8), // "mimeType"
QT_MOC_LITERAL(5, 50, 3) // "url"

    },
    "AlbumArtCommand\0onDownloadFinished\0\0"
    "data\0mimeType\0url"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_AlbumArtCommand[] = {

 // 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,    3,   19,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void, QMetaType::QByteArray, QMetaType::QString, QMetaType::QString,    3,    4,    5,

       0        // eod
};

void AlbumArtCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        AlbumArtCommand *_t = static_cast<AlbumArtCommand *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->onDownloadFinished((*reinterpret_cast< const QByteArray(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3]))); break;
        default: ;
        }
    }
}

const QMetaObject AlbumArtCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_AlbumArtCommand.data,
      qt_meta_data_AlbumArtCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *AlbumArtCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_AlbumArtCommand.stringdata0))
        return static_cast<void*>(const_cast< AlbumArtCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int AlbumArtCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_ExportCommand_t {
    QByteArrayData data[1];
    char stringdata0[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ExportCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ExportCommand_t qt_meta_stringdata_ExportCommand = {
    {
QT_MOC_LITERAL(0, 0, 13) // "ExportCommand"

    },
    "ExportCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ExportCommand[] = {

 // 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 ExportCommand::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 ExportCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ExportCommand.data,
      qt_meta_data_ExportCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ExportCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ExportCommand.stringdata0))
        return static_cast<void*>(const_cast< ExportCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ExportCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_PlaylistCommand_t {
    QByteArrayData data[1];
    char stringdata0[16];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PlaylistCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PlaylistCommand_t qt_meta_stringdata_PlaylistCommand = {
    {
QT_MOC_LITERAL(0, 0, 15) // "PlaylistCommand"

    },
    "PlaylistCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PlaylistCommand[] = {

 // 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 PlaylistCommand::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 PlaylistCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PlaylistCommand.data,
      qt_meta_data_PlaylistCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *PlaylistCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_PlaylistCommand.stringdata0))
        return static_cast<void*>(const_cast< PlaylistCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PlaylistCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_FilenameFormatCommand_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_FilenameFormatCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FilenameFormatCommand_t qt_meta_stringdata_FilenameFormatCommand = {
    {
QT_MOC_LITERAL(0, 0, 21) // "FilenameFormatCommand"

    },
    "FilenameFormatCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FilenameFormatCommand[] = {

 // 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 FilenameFormatCommand::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 FilenameFormatCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilenameFormatCommand.data,
      qt_meta_data_FilenameFormatCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *FilenameFormatCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_FilenameFormatCommand.stringdata0))
        return static_cast<void*>(const_cast< FilenameFormatCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilenameFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TagFormatCommand_t {
    QByteArrayData data[1];
    char stringdata0[17];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TagFormatCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TagFormatCommand_t qt_meta_stringdata_TagFormatCommand = {
    {
QT_MOC_LITERAL(0, 0, 16) // "TagFormatCommand"

    },
    "TagFormatCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TagFormatCommand[] = {

 // 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 TagFormatCommand::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 TagFormatCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagFormatCommand.data,
      qt_meta_data_TagFormatCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TagFormatCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TagFormatCommand.stringdata0))
        return static_cast<void*>(const_cast< TagFormatCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagFormatCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TextEncodingCommand_t {
    QByteArrayData data[1];
    char stringdata0[20];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TextEncodingCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TextEncodingCommand_t qt_meta_stringdata_TextEncodingCommand = {
    {
QT_MOC_LITERAL(0, 0, 19) // "TextEncodingCommand"

    },
    "TextEncodingCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TextEncodingCommand[] = {

 // 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 TextEncodingCommand::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 TextEncodingCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TextEncodingCommand.data,
      qt_meta_data_TextEncodingCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TextEncodingCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TextEncodingCommand.stringdata0))
        return static_cast<void*>(const_cast< TextEncodingCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TextEncodingCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_RenameDirectoryCommand_t {
    QByteArrayData data[5];
    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_RenameDirectoryCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RenameDirectoryCommand_t qt_meta_stringdata_RenameDirectoryCommand = {
    {
QT_MOC_LITERAL(0, 0, 22), // "RenameDirectoryCommand"
QT_MOC_LITERAL(1, 23, 17), // "onActionScheduled"
QT_MOC_LITERAL(2, 41, 0), // ""
QT_MOC_LITERAL(3, 42, 10), // "actionStrs"
QT_MOC_LITERAL(4, 53, 24) // "onRenameActionsScheduled"

    },
    "RenameDirectoryCommand\0onActionScheduled\0"
    "\0actionStrs\0onRenameActionsScheduled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RenameDirectoryCommand[] = {

 // 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,    1,   24,    2, 0x08 /* Private */,
       4,    0,   27,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void, QMetaType::QStringList,    3,
    QMetaType::Void,

       0        // eod
};

void RenameDirectoryCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        RenameDirectoryCommand *_t = static_cast<RenameDirectoryCommand *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->onActionScheduled((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
        case 1: _t->onRenameActionsScheduled(); break;
        default: ;
        }
    }
}

const QMetaObject RenameDirectoryCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RenameDirectoryCommand.data,
      qt_meta_data_RenameDirectoryCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *RenameDirectoryCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_RenameDirectoryCommand.stringdata0))
        return static_cast<void*>(const_cast< RenameDirectoryCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RenameDirectoryCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_NumberTracksCommand_t {
    QByteArrayData data[1];
    char stringdata0[20];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_NumberTracksCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_NumberTracksCommand_t qt_meta_stringdata_NumberTracksCommand = {
    {
QT_MOC_LITERAL(0, 0, 19) // "NumberTracksCommand"

    },
    "NumberTracksCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_NumberTracksCommand[] = {

 // 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 NumberTracksCommand::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 NumberTracksCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_NumberTracksCommand.data,
      qt_meta_data_NumberTracksCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *NumberTracksCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_NumberTracksCommand.stringdata0))
        return static_cast<void*>(const_cast< NumberTracksCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int NumberTracksCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_FilterCommand_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_FilterCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FilterCommand_t qt_meta_stringdata_FilterCommand = {
    {
QT_MOC_LITERAL(0, 0, 13), // "FilterCommand"
QT_MOC_LITERAL(1, 14, 14), // "onFileFiltered"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 4), // "type"
QT_MOC_LITERAL(4, 35, 8) // "fileName"

    },
    "FilterCommand\0onFileFiltered\0\0type\0"
    "fileName"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FilterCommand[] = {

 // 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,    2,   19,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int, QMetaType::QString,    3,    4,

       0        // eod
};

void FilterCommand::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        FilterCommand *_t = static_cast<FilterCommand *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->onFileFiltered((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        default: ;
        }
    }
}

const QMetaObject FilterCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilterCommand.data,
      qt_meta_data_FilterCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *FilterCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_FilterCommand.stringdata0))
        return static_cast<void*>(const_cast< FilterCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilterCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::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_ToId3v24Command_t {
    QByteArrayData data[1];
    char stringdata0[16];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ToId3v24Command_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ToId3v24Command_t qt_meta_stringdata_ToId3v24Command = {
    {
QT_MOC_LITERAL(0, 0, 15) // "ToId3v24Command"

    },
    "ToId3v24Command"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ToId3v24Command[] = {

 // 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 ToId3v24Command::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 ToId3v24Command::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ToId3v24Command.data,
      qt_meta_data_ToId3v24Command,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ToId3v24Command::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ToId3v24Command.stringdata0))
        return static_cast<void*>(const_cast< ToId3v24Command*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ToId3v24Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_ToId3v23Command_t {
    QByteArrayData data[1];
    char stringdata0[16];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ToId3v23Command_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ToId3v23Command_t qt_meta_stringdata_ToId3v23Command = {
    {
QT_MOC_LITERAL(0, 0, 15) // "ToId3v23Command"

    },
    "ToId3v23Command"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ToId3v23Command[] = {

 // 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 ToId3v23Command::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 ToId3v23Command::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_ToId3v23Command.data,
      qt_meta_data_ToId3v23Command,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ToId3v23Command::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ToId3v23Command.stringdata0))
        return static_cast<void*>(const_cast< ToId3v23Command*>(this));
    return CliCommand::qt_metacast(_clname);
}

int ToId3v23Command::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TagToFilenameCommand_t {
    QByteArrayData data[1];
    char stringdata0[21];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TagToFilenameCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TagToFilenameCommand_t qt_meta_stringdata_TagToFilenameCommand = {
    {
QT_MOC_LITERAL(0, 0, 20) // "TagToFilenameCommand"

    },
    "TagToFilenameCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TagToFilenameCommand[] = {

 // 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 TagToFilenameCommand::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 TagToFilenameCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagToFilenameCommand.data,
      qt_meta_data_TagToFilenameCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TagToFilenameCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TagToFilenameCommand.stringdata0))
        return static_cast<void*>(const_cast< TagToFilenameCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagToFilenameCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_FilenameToTagCommand_t {
    QByteArrayData data[1];
    char stringdata0[21];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FilenameToTagCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FilenameToTagCommand_t qt_meta_stringdata_FilenameToTagCommand = {
    {
QT_MOC_LITERAL(0, 0, 20) // "FilenameToTagCommand"

    },
    "FilenameToTagCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FilenameToTagCommand[] = {

 // 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 FilenameToTagCommand::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 FilenameToTagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_FilenameToTagCommand.data,
      qt_meta_data_FilenameToTagCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *FilenameToTagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_FilenameToTagCommand.stringdata0))
        return static_cast<void*>(const_cast< FilenameToTagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int FilenameToTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TagToOtherTagCommand_t {
    QByteArrayData data[1];
    char stringdata0[21];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TagToOtherTagCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TagToOtherTagCommand_t qt_meta_stringdata_TagToOtherTagCommand = {
    {
QT_MOC_LITERAL(0, 0, 20) // "TagToOtherTagCommand"

    },
    "TagToOtherTagCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TagToOtherTagCommand[] = {

 // 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 TagToOtherTagCommand::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 TagToOtherTagCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_TagToOtherTagCommand.data,
      qt_meta_data_TagToOtherTagCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TagToOtherTagCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TagToOtherTagCommand.stringdata0))
        return static_cast<void*>(const_cast< TagToOtherTagCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int TagToOtherTagCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_CopyCommand_t {
    QByteArrayData data[1];
    char stringdata0[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_CopyCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_CopyCommand_t qt_meta_stringdata_CopyCommand = {
    {
QT_MOC_LITERAL(0, 0, 11) // "CopyCommand"

    },
    "CopyCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_CopyCommand[] = {

 // 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 CopyCommand::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 CopyCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_CopyCommand.data,
      qt_meta_data_CopyCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *CopyCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_CopyCommand.stringdata0))
        return static_cast<void*>(const_cast< CopyCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int CopyCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_PasteCommand_t {
    QByteArrayData data[1];
    char stringdata0[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PasteCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PasteCommand_t qt_meta_stringdata_PasteCommand = {
    {
QT_MOC_LITERAL(0, 0, 12) // "PasteCommand"

    },
    "PasteCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PasteCommand[] = {

 // 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 PasteCommand::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 PasteCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PasteCommand.data,
      qt_meta_data_PasteCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *PasteCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_PasteCommand.stringdata0))
        return static_cast<void*>(const_cast< PasteCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PasteCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_RemoveCommand_t {
    QByteArrayData data[1];
    char stringdata0[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RemoveCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RemoveCommand_t qt_meta_stringdata_RemoveCommand = {
    {
QT_MOC_LITERAL(0, 0, 13) // "RemoveCommand"

    },
    "RemoveCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RemoveCommand[] = {

 // 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 RemoveCommand::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 RemoveCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_RemoveCommand.data,
      qt_meta_data_RemoveCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *RemoveCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_RemoveCommand.stringdata0))
        return static_cast<void*>(const_cast< RemoveCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int RemoveCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_PlayCommand_t {
    QByteArrayData data[1];
    char stringdata0[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PlayCommand_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PlayCommand_t qt_meta_stringdata_PlayCommand = {
    {
QT_MOC_LITERAL(0, 0, 11) // "PlayCommand"

    },
    "PlayCommand"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PlayCommand[] = {

 // 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 PlayCommand::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 PlayCommand::staticMetaObject = {
    { &CliCommand::staticMetaObject, qt_meta_stringdata_PlayCommand.data,
      qt_meta_data_PlayCommand,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *PlayCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_PlayCommand.stringdata0))
        return static_cast<void*>(const_cast< PlayCommand*>(this));
    return CliCommand::qt_metacast(_clname);
}

int PlayCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CliCommand::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
QT_END_MOC_NAMESPACE
