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

#include "../../../../../../src/qca-2.1.1/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.5.1. 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_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:
       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 QCA::InfoContext::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 QCA::InfoContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__InfoContext.data,
      qt_meta_data_QCA__InfoContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__InfoContext.stringdata0))
        return static_cast<void*>(const_cast< InfoContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::RandomContext::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 QCA::RandomContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__RandomContext.data,
      qt_meta_data_QCA__RandomContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__RandomContext.stringdata0))
        return static_cast<void*>(const_cast< RandomContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::HashContext::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 QCA::HashContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__HashContext.data,
      qt_meta_data_QCA__HashContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__HashContext.stringdata0))
        return static_cast<void*>(const_cast< HashContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CipherContext::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 QCA::CipherContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__CipherContext.data,
      qt_meta_data_QCA__CipherContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CipherContext.stringdata0))
        return static_cast<void*>(const_cast< CipherContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::MACContext::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 QCA::MACContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__MACContext.data,
      qt_meta_data_QCA__MACContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__MACContext.stringdata0))
        return static_cast<void*>(const_cast< MACContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::KDFContext::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 QCA::KDFContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__KDFContext.data,
      qt_meta_data_QCA__KDFContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KDFContext.stringdata0))
        return static_cast<void*>(const_cast< KDFContext*>(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);
    if (_id < 0)
        return _id;
    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:
       7,       // 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) {
        DLGroupContext *_t = static_cast<DLGroupContext *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->finished(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (DLGroupContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&DLGroupContext::finished)) {
                *result = 0;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject QCA::DLGroupContext::staticMetaObject = {
    { &Provider::Context::staticMetaObject, qt_meta_stringdata_QCA__DLGroupContext.data,
      qt_meta_data_QCA__DLGroupContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DLGroupContext.stringdata0))
        return static_cast<void*>(const_cast< DLGroupContext*>(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, Q_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:
       7,       // 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) {
        PKeyBase *_t = static_cast<PKeyBase *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->finished(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (PKeyBase::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&PKeyBase::finished)) {
                *result = 0;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject QCA::PKeyBase::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__PKeyBase.data,
      qt_meta_data_QCA__PKeyBase,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKeyBase.stringdata0))
        return static_cast<void*>(const_cast< PKeyBase*>(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, Q_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:
       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 QCA::RSAContext::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 QCA::RSAContext::staticMetaObject = {
    { &PKeyBase::staticMetaObject, qt_meta_stringdata_QCA__RSAContext.data,
      qt_meta_data_QCA__RSAContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__RSAContext.stringdata0))
        return static_cast<void*>(const_cast< RSAContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::DSAContext::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 QCA::DSAContext::staticMetaObject = {
    { &PKeyBase::staticMetaObject, qt_meta_stringdata_QCA__DSAContext.data,
      qt_meta_data_QCA__DSAContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DSAContext.stringdata0))
        return static_cast<void*>(const_cast< DSAContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::DHContext::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 QCA::DHContext::staticMetaObject = {
    { &PKeyBase::staticMetaObject, qt_meta_stringdata_QCA__DHContext.data,
      qt_meta_data_QCA__DHContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__DHContext.stringdata0))
        return static_cast<void*>(const_cast< DHContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::PKeyContext::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 QCA::PKeyContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__PKeyContext.data,
      qt_meta_data_QCA__PKeyContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKeyContext.stringdata0))
        return static_cast<void*>(const_cast< PKeyContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CertBase::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 QCA::CertBase::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__CertBase.data,
      qt_meta_data_QCA__CertBase,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertBase.stringdata0))
        return static_cast<void*>(const_cast< CertBase*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CertContext::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 QCA::CertContext::staticMetaObject = {
    { &CertBase::staticMetaObject, qt_meta_stringdata_QCA__CertContext.data,
      qt_meta_data_QCA__CertContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertContext.stringdata0))
        return static_cast<void*>(const_cast< CertContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CSRContext::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 QCA::CSRContext::staticMetaObject = {
    { &CertBase::staticMetaObject, qt_meta_stringdata_QCA__CSRContext.data,
      qt_meta_data_QCA__CSRContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CSRContext.stringdata0))
        return static_cast<void*>(const_cast< CSRContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CRLContext::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 QCA::CRLContext::staticMetaObject = {
    { &CertBase::staticMetaObject, qt_meta_stringdata_QCA__CRLContext.data,
      qt_meta_data_QCA__CRLContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CRLContext.stringdata0))
        return static_cast<void*>(const_cast< CRLContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CertCollectionContext::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 QCA::CertCollectionContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__CertCollectionContext.data,
      qt_meta_data_QCA__CertCollectionContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CertCollectionContext.stringdata0))
        return static_cast<void*>(const_cast< CertCollectionContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::CAContext::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 QCA::CAContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__CAContext.data,
      qt_meta_data_QCA__CAContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__CAContext.stringdata0))
        return static_cast<void*>(const_cast< CAContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::PKCS12Context::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 QCA::PKCS12Context::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__PKCS12Context.data,
      qt_meta_data_QCA__PKCS12Context,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PKCS12Context.stringdata0))
        return static_cast<void*>(const_cast< PKCS12Context*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::PGPKeyContext::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 QCA::PGPKeyContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__PGPKeyContext.data,
      qt_meta_data_QCA__PGPKeyContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__PGPKeyContext.stringdata0))
        return static_cast<void*>(const_cast< PGPKeyContext*>(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);
    if (_id < 0)
        return _id;
    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:
       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 QCA::KeyStoreEntryContext::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 QCA::KeyStoreEntryContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__KeyStoreEntryContext.data,
      qt_meta_data_QCA__KeyStoreEntryContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KeyStoreEntryContext.stringdata0))
        return static_cast<void*>(const_cast< KeyStoreEntryContext*>(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);
    if (_id < 0)
        return _id;
    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:
       7,       // 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) {
        KeyStoreListContext *_t = static_cast<KeyStoreListContext *>(_o);
        Q_UNUSED(_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]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (KeyStoreListContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KeyStoreListContext::busyStart)) {
                *result = 0;
            }
        }
        {
            typedef void (KeyStoreListContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KeyStoreListContext::busyEnd)) {
                *result = 1;
            }
        }
        {
            typedef void (KeyStoreListContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KeyStoreListContext::updated)) {
                *result = 2;
            }
        }
        {
            typedef void (KeyStoreListContext::*_t)(const QString & );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KeyStoreListContext::diagnosticText)) {
                *result = 3;
            }
        }
        {
            typedef void (KeyStoreListContext::*_t)(int );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KeyStoreListContext::storeUpdated)) {
                *result = 4;
            }
        }
    }
}

const QMetaObject QCA::KeyStoreListContext::staticMetaObject = {
    { &Provider::Context::staticMetaObject, qt_meta_stringdata_QCA__KeyStoreListContext.data,
      qt_meta_data_QCA__KeyStoreListContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__KeyStoreListContext.stringdata0))
        return static_cast<void*>(const_cast< KeyStoreListContext*>(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, Q_NULLPTR);
}

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

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

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

// SIGNAL 4
void QCA::KeyStoreListContext::storeUpdated(int _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_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:
       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 QCA::TLSSessionContext::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 QCA::TLSSessionContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__TLSSessionContext.data,
      qt_meta_data_QCA__TLSSessionContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__TLSSessionContext.stringdata0))
        return static_cast<void*>(const_cast< TLSSessionContext*>(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);
    if (_id < 0)
        return _id;
    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:
       7,       // 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) {
        TLSContext *_t = static_cast<TLSContext *>(_o);
        Q_UNUSED(_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]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (TLSContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TLSContext::resultsReady)) {
                *result = 0;
            }
        }
        {
            typedef void (TLSContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&TLSContext::dtlsTimeout)) {
                *result = 1;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject QCA::TLSContext::staticMetaObject = {
    { &Provider::Context::staticMetaObject, qt_meta_stringdata_QCA__TLSContext.data,
      qt_meta_data_QCA__TLSContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__TLSContext.stringdata0))
        return static_cast<void*>(const_cast< TLSContext*>(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, Q_NULLPTR);
}

// SIGNAL 1
void QCA::TLSContext::dtlsTimeout()
{
    QMetaObject::activate(this, &staticMetaObject, 1, Q_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:
       7,       // 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) {
        SASLContext *_t = static_cast<SASLContext *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->resultsReady(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (SASLContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&SASLContext::resultsReady)) {
                *result = 0;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject QCA::SASLContext::staticMetaObject = {
    { &Provider::Context::staticMetaObject, qt_meta_stringdata_QCA__SASLContext.data,
      qt_meta_data_QCA__SASLContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__SASLContext.stringdata0))
        return static_cast<void*>(const_cast< SASLContext*>(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, Q_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:
       7,       // 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) {
        MessageContext *_t = static_cast<MessageContext *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->updated(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (MessageContext::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&MessageContext::updated)) {
                *result = 0;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject QCA::MessageContext::staticMetaObject = {
    { &Provider::Context::staticMetaObject, qt_meta_stringdata_QCA__MessageContext.data,
      qt_meta_data_QCA__MessageContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__MessageContext.stringdata0))
        return static_cast<void*>(const_cast< MessageContext*>(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, Q_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:
       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 QCA::SMSContext::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 QCA::SMSContext::staticMetaObject = {
    { &BasicContext::staticMetaObject, qt_meta_stringdata_QCA__SMSContext.data,
      qt_meta_data_QCA__SMSContext,  qt_static_metacall, Q_NULLPTR, Q_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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_QCA__SMSContext.stringdata0))
        return static_cast<void*>(const_cast< SMSContext*>(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);
    if (_id < 0)
        return _id;
    return _id;
}
QT_END_MOC_NAMESPACE
