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

#include <memory>
#include "../../../../qca-2.3.12/include/QtCrypto/qcaprovider.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qcaprovider.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.19. 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
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_QCA__InfoContext_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_QCA__InfoContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__InfoContext_t qt_meta_stringdata_QCA__InfoContext = {
    {
QT_MOC_LITERAL(0, 0, 16) // "QCA::InfoContext"

    },
    "QCA::InfoContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__InfoContext[] = {

 // content:
       8,       // 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 QCA::InfoContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::InfoContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__InfoContext.data,
    qt_meta_data_QCA__InfoContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::InfoContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__InfoContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::InfoContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__RandomContext_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_QCA__RandomContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__RandomContext_t qt_meta_stringdata_QCA__RandomContext = {
    {
QT_MOC_LITERAL(0, 0, 18) // "QCA::RandomContext"

    },
    "QCA::RandomContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__RandomContext[] = {

 // content:
       8,       // 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 QCA::RandomContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::RandomContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__RandomContext.data,
    qt_meta_data_QCA__RandomContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::RandomContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__RandomContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::RandomContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__HashContext_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_QCA__HashContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__HashContext_t qt_meta_stringdata_QCA__HashContext = {
    {
QT_MOC_LITERAL(0, 0, 16) // "QCA::HashContext"

    },
    "QCA::HashContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__HashContext[] = {

 // content:
       8,       // 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 QCA::HashContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::HashContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__HashContext.data,
    qt_meta_data_QCA__HashContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::HashContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__HashContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::HashContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CipherContext_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_QCA__CipherContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CipherContext_t qt_meta_stringdata_QCA__CipherContext = {
    {
QT_MOC_LITERAL(0, 0, 18) // "QCA::CipherContext"

    },
    "QCA::CipherContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CipherContext[] = {

 // content:
       8,       // 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 QCA::CipherContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CipherContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__CipherContext.data,
    qt_meta_data_QCA__CipherContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CipherContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CipherContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CipherContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__MACContext_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_QCA__MACContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__MACContext_t qt_meta_stringdata_QCA__MACContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::MACContext"

    },
    "QCA::MACContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__MACContext[] = {

 // content:
       8,       // 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 QCA::MACContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::MACContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__MACContext.data,
    qt_meta_data_QCA__MACContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::MACContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__MACContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::MACContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__KDFContext_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_QCA__KDFContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__KDFContext_t qt_meta_stringdata_QCA__KDFContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::KDFContext"

    },
    "QCA::KDFContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__KDFContext[] = {

 // content:
       8,       // 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 QCA::KDFContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::KDFContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__KDFContext.data,
    qt_meta_data_QCA__KDFContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::KDFContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KDFContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::KDFContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__HKDFContext_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_QCA__HKDFContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__HKDFContext_t qt_meta_stringdata_QCA__HKDFContext = {
    {
QT_MOC_LITERAL(0, 0, 16) // "QCA::HKDFContext"

    },
    "QCA::HKDFContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__HKDFContext[] = {

 // content:
       8,       // 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 QCA::HKDFContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::HKDFContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__HKDFContext.data,
    qt_meta_data_QCA__HKDFContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::HKDFContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__HKDFContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::HKDFContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__DLGroupContext_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_QCA__DLGroupContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__DLGroupContext_t qt_meta_stringdata_QCA__DLGroupContext = {
    {
QT_MOC_LITERAL(0, 0, 19), // "QCA::DLGroupContext"
QT_MOC_LITERAL(1, 20, 8), // "finished"
QT_MOC_LITERAL(2, 29, 0) // ""

    },
    "QCA::DLGroupContext\0finished\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__DLGroupContext[] = {

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

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject QCA::DLGroupContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_meta_stringdata_QCA__DLGroupContext.data,
    qt_meta_data_QCA__DLGroupContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::DLGroupContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DLGroupContext.stringdata0))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

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

// SIGNAL 0
void QCA::DLGroupContext::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_QCA__PKeyBase_t {
    QByteArrayData data[3];
    char stringdata0[24];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QCA__PKeyBase_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__PKeyBase_t qt_meta_stringdata_QCA__PKeyBase = {
    {
QT_MOC_LITERAL(0, 0, 13), // "QCA::PKeyBase"
QT_MOC_LITERAL(1, 14, 8), // "finished"
QT_MOC_LITERAL(2, 23, 0) // ""

    },
    "QCA::PKeyBase\0finished\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__PKeyBase[] = {

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

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject QCA::PKeyBase::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__PKeyBase.data,
    qt_meta_data_QCA__PKeyBase,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::PKeyBase::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKeyBase.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

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

// SIGNAL 0
void QCA::PKeyBase::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_QCA__RSAContext_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_QCA__RSAContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__RSAContext_t qt_meta_stringdata_QCA__RSAContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::RSAContext"

    },
    "QCA::RSAContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__RSAContext[] = {

 // content:
       8,       // 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 QCA::RSAContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::RSAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__RSAContext.data,
    qt_meta_data_QCA__RSAContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::RSAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__RSAContext.stringdata0))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::RSAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__DSAContext_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_QCA__DSAContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__DSAContext_t qt_meta_stringdata_QCA__DSAContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::DSAContext"

    },
    "QCA::DSAContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__DSAContext[] = {

 // content:
       8,       // 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 QCA::DSAContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::DSAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__DSAContext.data,
    qt_meta_data_QCA__DSAContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::DSAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DSAContext.stringdata0))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::DSAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__DHContext_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_QCA__DHContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__DHContext_t qt_meta_stringdata_QCA__DHContext = {
    {
QT_MOC_LITERAL(0, 0, 14) // "QCA::DHContext"

    },
    "QCA::DHContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__DHContext[] = {

 // content:
       8,       // 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 QCA::DHContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::DHContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__DHContext.data,
    qt_meta_data_QCA__DHContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::DHContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DHContext.stringdata0))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::DHContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__PKeyContext_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_QCA__PKeyContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__PKeyContext_t qt_meta_stringdata_QCA__PKeyContext = {
    {
QT_MOC_LITERAL(0, 0, 16) // "QCA::PKeyContext"

    },
    "QCA::PKeyContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__PKeyContext[] = {

 // content:
       8,       // 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 QCA::PKeyContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::PKeyContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__PKeyContext.data,
    qt_meta_data_QCA__PKeyContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::PKeyContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKeyContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PKeyContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CertBase_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_QCA__CertBase_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CertBase_t qt_meta_stringdata_QCA__CertBase = {
    {
QT_MOC_LITERAL(0, 0, 13) // "QCA::CertBase"

    },
    "QCA::CertBase"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CertBase[] = {

 // content:
       8,       // 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 QCA::CertBase::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CertBase::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__CertBase.data,
    qt_meta_data_QCA__CertBase,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CertBase::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertBase.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CertBase::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CertContext_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_QCA__CertContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CertContext_t qt_meta_stringdata_QCA__CertContext = {
    {
QT_MOC_LITERAL(0, 0, 16) // "QCA::CertContext"

    },
    "QCA::CertContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CertContext[] = {

 // content:
       8,       // 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 QCA::CertContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CertContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__CertContext.data,
    qt_meta_data_QCA__CertContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CertContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertContext.stringdata0))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CertContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CSRContext_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_QCA__CSRContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CSRContext_t qt_meta_stringdata_QCA__CSRContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::CSRContext"

    },
    "QCA::CSRContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CSRContext[] = {

 // content:
       8,       // 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 QCA::CSRContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CSRContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__CSRContext.data,
    qt_meta_data_QCA__CSRContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CSRContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CSRContext.stringdata0))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CSRContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CRLContext_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_QCA__CRLContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CRLContext_t qt_meta_stringdata_QCA__CRLContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::CRLContext"

    },
    "QCA::CRLContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CRLContext[] = {

 // content:
       8,       // 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 QCA::CRLContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CRLContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_meta_stringdata_QCA__CRLContext.data,
    qt_meta_data_QCA__CRLContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CRLContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CRLContext.stringdata0))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CRLContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CertCollectionContext_t {
    QByteArrayData data[1];
    char stringdata0[27];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QCA__CertCollectionContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CertCollectionContext_t qt_meta_stringdata_QCA__CertCollectionContext = {
    {
QT_MOC_LITERAL(0, 0, 26) // "QCA::CertCollectionContext"

    },
    "QCA::CertCollectionContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CertCollectionContext[] = {

 // content:
       8,       // 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 QCA::CertCollectionContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CertCollectionContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__CertCollectionContext.data,
    qt_meta_data_QCA__CertCollectionContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CertCollectionContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertCollectionContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CertCollectionContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__CAContext_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_QCA__CAContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__CAContext_t qt_meta_stringdata_QCA__CAContext = {
    {
QT_MOC_LITERAL(0, 0, 14) // "QCA::CAContext"

    },
    "QCA::CAContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__CAContext[] = {

 // content:
       8,       // 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 QCA::CAContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::CAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__CAContext.data,
    qt_meta_data_QCA__CAContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::CAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CAContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__PKCS12Context_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_QCA__PKCS12Context_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__PKCS12Context_t qt_meta_stringdata_QCA__PKCS12Context = {
    {
QT_MOC_LITERAL(0, 0, 18) // "QCA::PKCS12Context"

    },
    "QCA::PKCS12Context"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__PKCS12Context[] = {

 // content:
       8,       // 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 QCA::PKCS12Context::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::PKCS12Context::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__PKCS12Context.data,
    qt_meta_data_QCA__PKCS12Context,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::PKCS12Context::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKCS12Context.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PKCS12Context::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__PGPKeyContext_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_QCA__PGPKeyContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__PGPKeyContext_t qt_meta_stringdata_QCA__PGPKeyContext = {
    {
QT_MOC_LITERAL(0, 0, 18) // "QCA::PGPKeyContext"

    },
    "QCA::PGPKeyContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__PGPKeyContext[] = {

 // content:
       8,       // 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 QCA::PGPKeyContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::PGPKeyContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__PGPKeyContext.data,
    qt_meta_data_QCA__PGPKeyContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::PGPKeyContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PGPKeyContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PGPKeyContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__KeyStoreEntryContext_t {
    QByteArrayData data[1];
    char stringdata0[26];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QCA__KeyStoreEntryContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__KeyStoreEntryContext_t qt_meta_stringdata_QCA__KeyStoreEntryContext = {
    {
QT_MOC_LITERAL(0, 0, 25) // "QCA::KeyStoreEntryContext"

    },
    "QCA::KeyStoreEntryContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__KeyStoreEntryContext[] = {

 // content:
       8,       // 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 QCA::KeyStoreEntryContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::KeyStoreEntryContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__KeyStoreEntryContext.data,
    qt_meta_data_QCA__KeyStoreEntryContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::KeyStoreEntryContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KeyStoreEntryContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::KeyStoreEntryContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__KeyStoreListContext_t {
    QByteArrayData data[9];
    char stringdata0[87];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QCA__KeyStoreListContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__KeyStoreListContext_t qt_meta_stringdata_QCA__KeyStoreListContext = {
    {
QT_MOC_LITERAL(0, 0, 24), // "QCA::KeyStoreListContext"
QT_MOC_LITERAL(1, 25, 9), // "busyStart"
QT_MOC_LITERAL(2, 35, 0), // ""
QT_MOC_LITERAL(3, 36, 7), // "busyEnd"
QT_MOC_LITERAL(4, 44, 7), // "updated"
QT_MOC_LITERAL(5, 52, 14), // "diagnosticText"
QT_MOC_LITERAL(6, 67, 3), // "str"
QT_MOC_LITERAL(7, 71, 12), // "storeUpdated"
QT_MOC_LITERAL(8, 84, 2) // "id"

    },
    "QCA::KeyStoreListContext\0busyStart\0\0"
    "busyEnd\0updated\0diagnosticText\0str\0"
    "storeUpdated\0id"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__KeyStoreListContext[] = {

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

 // signals: name, argc, parameters, tag, flags
       1,    0,   39,    2, 0x06 /* Public */,
       3,    0,   40,    2, 0x06 /* Public */,
       4,    0,   41,    2, 0x06 /* Public */,
       5,    1,   42,    2, 0x06 /* Public */,
       7,    1,   45,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString,    6,
    QMetaType::Void, QMetaType::Int,    8,

       0        // eod
};

void QCA::KeyStoreListContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<KeyStoreListContext *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->busyStart(); break;
        case 1: _t->busyEnd(); break;
        case 2: _t->updated(); break;
        case 3: _t->diagnosticText((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 4: _t->storeUpdated((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (KeyStoreListContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&KeyStoreListContext::busyStart)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (KeyStoreListContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&KeyStoreListContext::busyEnd)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (KeyStoreListContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&KeyStoreListContext::updated)) {
                *result = 2;
                return;
            }
        }
        {
            using _t = void (KeyStoreListContext::*)(const QString & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&KeyStoreListContext::diagnosticText)) {
                *result = 3;
                return;
            }
        }
        {
            using _t = void (KeyStoreListContext::*)(int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&KeyStoreListContext::storeUpdated)) {
                *result = 4;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject QCA::KeyStoreListContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_meta_stringdata_QCA__KeyStoreListContext.data,
    qt_meta_data_QCA__KeyStoreListContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::KeyStoreListContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KeyStoreListContext.stringdata0))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::KeyStoreListContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void QCA::KeyStoreListContext::busyStart()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void QCA::KeyStoreListContext::busyEnd()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void QCA::KeyStoreListContext::updated()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void QCA::KeyStoreListContext::diagnosticText(const QString & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void QCA::KeyStoreListContext::storeUpdated(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}
struct qt_meta_stringdata_QCA__TLSSessionContext_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_QCA__TLSSessionContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__TLSSessionContext_t qt_meta_stringdata_QCA__TLSSessionContext = {
    {
QT_MOC_LITERAL(0, 0, 22) // "QCA::TLSSessionContext"

    },
    "QCA::TLSSessionContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__TLSSessionContext[] = {

 // content:
       8,       // 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 QCA::TLSSessionContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::TLSSessionContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__TLSSessionContext.data,
    qt_meta_data_QCA__TLSSessionContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::TLSSessionContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__TLSSessionContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::TLSSessionContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_QCA__TLSContext_t {
    QByteArrayData data[4];
    char stringdata0[42];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_QCA__TLSContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__TLSContext_t qt_meta_stringdata_QCA__TLSContext = {
    {
QT_MOC_LITERAL(0, 0, 15), // "QCA::TLSContext"
QT_MOC_LITERAL(1, 16, 12), // "resultsReady"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 11) // "dtlsTimeout"

    },
    "QCA::TLSContext\0resultsReady\0\0dtlsTimeout"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__TLSContext[] = {

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

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

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void QCA::TLSContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<TLSContext *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->resultsReady(); break;
        case 1: _t->dtlsTimeout(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (TLSContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TLSContext::resultsReady)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (TLSContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TLSContext::dtlsTimeout)) {
                *result = 1;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::TLSContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_meta_stringdata_QCA__TLSContext.data,
    qt_meta_data_QCA__TLSContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::TLSContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__TLSContext.stringdata0))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::TLSContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::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 QCA::TLSContext::resultsReady()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void QCA::TLSContext::dtlsTimeout()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
struct qt_meta_stringdata_QCA__SASLContext_t {
    QByteArrayData data[3];
    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_QCA__SASLContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__SASLContext_t qt_meta_stringdata_QCA__SASLContext = {
    {
QT_MOC_LITERAL(0, 0, 16), // "QCA::SASLContext"
QT_MOC_LITERAL(1, 17, 12), // "resultsReady"
QT_MOC_LITERAL(2, 30, 0) // ""

    },
    "QCA::SASLContext\0resultsReady\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__SASLContext[] = {

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

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

void QCA::SASLContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<SASLContext *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->resultsReady(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (SASLContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&SASLContext::resultsReady)) {
                *result = 0;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::SASLContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_meta_stringdata_QCA__SASLContext.data,
    qt_meta_data_QCA__SASLContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::SASLContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__SASLContext.stringdata0))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

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

// SIGNAL 0
void QCA::SASLContext::resultsReady()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_QCA__MessageContext_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_QCA__MessageContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__MessageContext_t qt_meta_stringdata_QCA__MessageContext = {
    {
QT_MOC_LITERAL(0, 0, 19), // "QCA::MessageContext"
QT_MOC_LITERAL(1, 20, 7), // "updated"
QT_MOC_LITERAL(2, 28, 0) // ""

    },
    "QCA::MessageContext\0updated\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__MessageContext[] = {

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

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

void QCA::MessageContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<MessageContext *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->updated(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (MessageContext::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MessageContext::updated)) {
                *result = 0;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::MessageContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_meta_stringdata_QCA__MessageContext.data,
    qt_meta_data_QCA__MessageContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::MessageContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__MessageContext.stringdata0))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

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

// SIGNAL 0
void QCA::MessageContext::updated()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_QCA__SMSContext_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_QCA__SMSContext_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_QCA__SMSContext_t qt_meta_stringdata_QCA__SMSContext = {
    {
QT_MOC_LITERAL(0, 0, 15) // "QCA::SMSContext"

    },
    "QCA::SMSContext"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_QCA__SMSContext[] = {

 // content:
       8,       // 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 QCA::SMSContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject QCA::SMSContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_meta_stringdata_QCA__SMSContext.data,
    qt_meta_data_QCA__SMSContext,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *QCA::SMSContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__SMSContext.stringdata0))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::SMSContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
