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

#include "../../../../../zxing-cpp/core/src/ZXingQt.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ZXingQt.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN7ZXingQt5ErrorE_t {};
} // unnamed namespace

template <> constexpr inline auto ZXingQt::Error::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQt5ErrorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ZXingQt::Error",
        "type",
        "Type",
        "message",
        "location",
        "None",
        "Format",
        "Checksum",
        "Unsupported"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'type'
        QtMocHelpers::PropertyData<enum Type>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'message'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'location'
        QtMocHelpers::PropertyData<QString>(4, QMetaType::QString, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Type'
        QtMocHelpers::EnumData<enum Type>(2, 2, QMC::EnumIsScoped).add({
            {    5, Type::None },
            {    6, Type::Format },
            {    7, Type::Checksum },
            {    8, Type::Unsupported },
        }),
    };
    return QtMocHelpers::metaObjectData<Error, qt_meta_tag_ZN7ZXingQt5ErrorE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ZXingQt::Error::staticMetaObject = { {
    QtPrivate::MetaObjectForType<ZXing::Error>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt5ErrorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt5ErrorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7ZXingQt5ErrorE_t>.metaTypes,
    nullptr
} };

void ZXingQt::Error::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<Error *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum Type*>(_v) = _t->type(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->message(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->location(); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN7ZXingQt8PositionE_t {};
} // unnamed namespace

template <> constexpr inline auto ZXingQt::Position::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQt8PositionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ZXingQt::Position",
        "topLeft",
        "QPoint",
        "topRight",
        "bottomRight",
        "bottomLeft",
        "center"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'topLeft'
        QtMocHelpers::PropertyData<QPoint>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'topRight'
        QtMocHelpers::PropertyData<QPoint>(3, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'bottomRight'
        QtMocHelpers::PropertyData<QPoint>(4, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'bottomLeft'
        QtMocHelpers::PropertyData<QPoint>(5, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'center'
        QtMocHelpers::PropertyData<QPoint>(6, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Position, qt_meta_tag_ZN7ZXingQt8PositionE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ZXingQt::Position::staticMetaObject = { {
    QtPrivate::MetaObjectForType<ZXing::Quadrilateral<QPoint>>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt8PositionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt8PositionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7ZXingQt8PositionE_t>.metaTypes,
    nullptr
} };

void ZXingQt::Position::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<Position *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QPoint*>(_v) = _t->topLeft(); break;
        case 1: *reinterpret_cast<QPoint*>(_v) = _t->topRight(); break;
        case 2: *reinterpret_cast<QPoint*>(_v) = _t->bottomRight(); break;
        case 3: *reinterpret_cast<QPoint*>(_v) = _t->bottomLeft(); break;
        case 4: *reinterpret_cast<QPoint*>(_v) = _t->center(); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN7ZXingQt7BarcodeE_t {};
} // unnamed namespace

template <> constexpr inline auto ZXingQt::Barcode::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQt7BarcodeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ZXingQt::Barcode",
        "format",
        "BarcodeFormat",
        "symbology",
        "text",
        "bytes",
        "bytesECI",
        "isValid",
        "error",
        "Error",
        "contentType",
        "ContentType",
        "hasECI",
        "position",
        "Position",
        "orientation",
        "isMirrored",
        "isInverted",
        "symbologyIdentifier",
        "sequenceSize",
        "sequenceIndex",
        "sequenceId",
        "isLastInSequence",
        "isPartOfSequence",
        "lineCount"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'format'
        QtMocHelpers::PropertyData<BarcodeFormat>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'symbology'
        QtMocHelpers::PropertyData<BarcodeFormat>(3, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'text'
        QtMocHelpers::PropertyData<QString>(4, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'bytes'
        QtMocHelpers::PropertyData<QByteArray>(5, QMetaType::QByteArray, QMC::DefaultPropertyFlags),
        // property 'bytesECI'
        QtMocHelpers::PropertyData<QByteArray>(6, QMetaType::QByteArray, QMC::DefaultPropertyFlags),
        // property 'isValid'
        QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'error'
        QtMocHelpers::PropertyData<Error>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'contentType'
        QtMocHelpers::PropertyData<ContentType>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'hasECI'
        QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'position'
        QtMocHelpers::PropertyData<Position>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'orientation'
        QtMocHelpers::PropertyData<int>(15, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'isMirrored'
        QtMocHelpers::PropertyData<bool>(16, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'isInverted'
        QtMocHelpers::PropertyData<bool>(17, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'symbologyIdentifier'
        QtMocHelpers::PropertyData<QString>(18, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'sequenceSize'
        QtMocHelpers::PropertyData<int>(19, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'sequenceIndex'
        QtMocHelpers::PropertyData<int>(20, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'sequenceId'
        QtMocHelpers::PropertyData<QString>(21, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'isLastInSequence'
        QtMocHelpers::PropertyData<bool>(22, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'isPartOfSequence'
        QtMocHelpers::PropertyData<bool>(23, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'lineCount'
        QtMocHelpers::PropertyData<int>(24, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Barcode, qt_meta_tag_ZN7ZXingQt7BarcodeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ZXingQt::Barcode::staticMetaObject = { {
    QtPrivate::MetaObjectForType<ZXing::Barcode>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt7BarcodeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt7BarcodeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7ZXingQt7BarcodeE_t>.metaTypes,
    nullptr
} };

void ZXingQt::Barcode::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<Barcode *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<BarcodeFormat*>(_v) = _t->format(); break;
        case 1: *reinterpret_cast<BarcodeFormat*>(_v) = _t->symbology(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->text(); break;
        case 3: *reinterpret_cast<QByteArray*>(_v) = _t->bytes(); break;
        case 4: *reinterpret_cast<QByteArray*>(_v) = _t->bytesECI(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isValid(); break;
        case 6: *reinterpret_cast<Error*>(_v) = _t->error(); break;
        case 7: *reinterpret_cast<ContentType*>(_v) = _t->contentType(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->hasECI(); break;
        case 9: *reinterpret_cast<Position*>(_v) = _t->position(); break;
        case 10: *reinterpret_cast<int*>(_v) = _t->orientation(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isMirrored(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->isInverted(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->symbologyIdentifier(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->sequenceSize(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->sequenceIndex(); break;
        case 16: *reinterpret_cast<QString*>(_v) = _t->sequenceId(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->isLastInSequence(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->isPartOfSequence(); break;
        case 19: *reinterpret_cast<int*>(_v) = _t->lineCount(); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t {};
} // unnamed namespace

template <> constexpr inline auto ZXingQt::BarcodeReader::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ZXingQt::BarcodeReader",
        "maxThreadCountChanged",
        "",
        "formatsChanged",
        "textModeChanged",
        "tryRotateChanged",
        "tryHarderChanged",
        "tryInvertChanged",
        "tryDownscaleChanged",
        "isPureChanged",
        "returnErrorsChanged",
        "foundNoBarcodes",
        "foundBarcodes",
        "QList<Barcode>",
        "barcodes",
        "setMaxThreadCount",
        "maxThreadCount",
        "setFormats",
        "BarcodeFormats",
        "newVal",
        "setTextMode",
        "TextMode",
        "setTryRotate",
        "setTryHarder",
        "setTryInvert",
        "setTryDownscale",
        "setIsPure",
        "setReturnErrors",
        "read",
        "QImage",
        "image",
        "readAsync",
        "QVideoFrame",
        "tryReadAsync",
        "frame",
        "formats",
        "textMode",
        "tryRotate",
        "tryHarder",
        "tryInvert",
        "tryDownscale",
        "isPure",
        "returnErrors",
        "runTime",
        "videoSink",
        "QVideoSink*"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'maxThreadCountChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'formatsChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'textModeChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tryRotateChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tryHarderChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tryInvertChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'tryDownscaleChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isPureChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'returnErrorsChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'foundNoBarcodes'
        QtMocHelpers::SignalData<void() const>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'foundBarcodes'
        QtMocHelpers::SignalData<void(const QList<Barcode> &) const>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
        // Slot 'setMaxThreadCount'
        QtMocHelpers::SlotData<void(int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Slot 'setFormats'
        QtMocHelpers::SlotData<void(const BarcodeFormats &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Slot 'setTextMode'
        QtMocHelpers::SlotData<void(TextMode)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 19 },
        }}),
        // Slot 'setTryRotate'
        QtMocHelpers::SlotData<void(const bool &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setTryHarder'
        QtMocHelpers::SlotData<void(const bool &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setTryInvert'
        QtMocHelpers::SlotData<void(const bool &)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setTryDownscale'
        QtMocHelpers::SlotData<void(const bool &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setIsPure'
        QtMocHelpers::SlotData<void(const bool &)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setReturnErrors'
        QtMocHelpers::SlotData<void(const bool &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'read'
        QtMocHelpers::SlotData<QList<Barcode>(const QImage &) const>(28, 2, QMC::AccessPublic, 0x80000000 | 13, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Slot 'readAsync'
        QtMocHelpers::SlotData<void(const QImage &) const>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Slot 'read'
        QtMocHelpers::SlotData<QList<Barcode>(const QVideoFrame &) const>(28, 2, QMC::AccessPublic, 0x80000000 | 13, {{
            { 0x80000000 | 32, 30 },
        }}),
        // Slot 'tryReadAsync'
        QtMocHelpers::SlotData<bool(const QVideoFrame &) const>(33, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 32, 34 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'formats'
        QtMocHelpers::PropertyData<BarcodeFormats>(35, 0x80000000 | 18, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
        // property 'textMode'
        QtMocHelpers::PropertyData<TextMode>(36, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
        // property 'maxThreadCount'
        QtMocHelpers::PropertyData<int>(16, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'tryRotate'
        QtMocHelpers::PropertyData<bool>(37, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'tryHarder'
        QtMocHelpers::PropertyData<bool>(38, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'tryInvert'
        QtMocHelpers::PropertyData<bool>(39, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'tryDownscale'
        QtMocHelpers::PropertyData<bool>(40, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'isPure'
        QtMocHelpers::PropertyData<bool>(41, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'returnErrors'
        QtMocHelpers::PropertyData<bool>(42, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'runTime'
        QtMocHelpers::PropertyData<int>(43, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'videoSink'
        QtMocHelpers::PropertyData<QVideoSink*>(44, 0x80000000 | 45, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<BarcodeReader, qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ZXingQt::BarcodeReader::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>.metaTypes,
    nullptr
} };

void ZXingQt::BarcodeReader::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<BarcodeReader *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->maxThreadCountChanged(); break;
        case 1: _t->formatsChanged(); break;
        case 2: _t->textModeChanged(); break;
        case 3: _t->tryRotateChanged(); break;
        case 4: _t->tryHarderChanged(); break;
        case 5: _t->tryInvertChanged(); break;
        case 6: _t->tryDownscaleChanged(); break;
        case 7: _t->isPureChanged(); break;
        case 8: _t->returnErrorsChanged(); break;
        case 9: _t->foundNoBarcodes(); break;
        case 10: _t->foundBarcodes((*reinterpret_cast<std::add_pointer_t<QList<Barcode>>>(_a[1]))); break;
        case 11: _t->setMaxThreadCount((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->setFormats((*reinterpret_cast<std::add_pointer_t<BarcodeFormats>>(_a[1]))); break;
        case 13: _t->setTextMode((*reinterpret_cast<std::add_pointer_t<TextMode>>(_a[1]))); break;
        case 14: _t->setTryRotate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->setTryHarder((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->setTryInvert((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->setTryDownscale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->setIsPure((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->setReturnErrors((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: { QList<Barcode> _r = _t->read((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<Barcode>*>(_a[0]) = std::move(_r); }  break;
        case 21: _t->readAsync((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        case 22: { QList<Barcode> _r = _t->read((*reinterpret_cast<std::add_pointer_t<QVideoFrame>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<Barcode>*>(_a[0]) = std::move(_r); }  break;
        case 23: { bool _r = _t->tryReadAsync((*reinterpret_cast<std::add_pointer_t<QVideoFrame>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QVideoFrame >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QVideoFrame >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::maxThreadCountChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::formatsChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::textModeChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::tryRotateChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::tryHarderChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::tryInvertChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::tryDownscaleChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::isPureChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)()>(_a, &BarcodeReader::returnErrorsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)() const>(_a, &BarcodeReader::foundNoBarcodes, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (BarcodeReader::*)(const QList<Barcode> & ) const>(_a, &BarcodeReader::foundBarcodes, 10))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 10:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QVideoSink* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<BarcodeFormats*>(_v) = _t->formats(); break;
        case 1: *reinterpret_cast<TextMode*>(_v) = _t->textMode(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->maxThreadCount(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->tryRotate(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->tryHarder(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->tryInvert(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->tryDownscale(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isPure(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->returnErrors(); break;
        case 9: *reinterpret_cast<int*>(_v) = _t->runTime; break;
        case 10: *reinterpret_cast<QVideoSink**>(_v) = _t->_sink; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFormats(*reinterpret_cast<BarcodeFormats*>(_v)); break;
        case 1: _t->setTextMode(*reinterpret_cast<TextMode*>(_v)); break;
        case 2: _t->setMaxThreadCount(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setTryRotate(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setTryHarder(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setTryInvert(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setTryDownscale(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setIsPure(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setReturnErrors(*reinterpret_cast<bool*>(_v)); break;
        case 9: QtMocHelpers::setProperty(_t->runTime, *reinterpret_cast<int*>(_v)); break;
        case 10: _t->setVideoSink(*reinterpret_cast<QVideoSink**>(_v)); break;
        default: break;
        }
    }
}

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

void *ZXingQt::BarcodeReader::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ZXingQt13BarcodeReaderE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int ZXingQt::BarcodeReader::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 24)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 24;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 24)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 24;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    return _id;
}

// SIGNAL 0
void ZXingQt::BarcodeReader::maxThreadCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void ZXingQt::BarcodeReader::formatsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void ZXingQt::BarcodeReader::textModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ZXingQt::BarcodeReader::tryRotateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void ZXingQt::BarcodeReader::tryHarderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void ZXingQt::BarcodeReader::tryInvertChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void ZXingQt::BarcodeReader::tryDownscaleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void ZXingQt::BarcodeReader::isPureChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void ZXingQt::BarcodeReader::returnErrorsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void ZXingQt::BarcodeReader::foundNoBarcodes()const
{
    QMetaObject::activate(const_cast< ZXingQt::BarcodeReader *>(this), &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void ZXingQt::BarcodeReader::foundBarcodes(const QList<Barcode> & _t1)const
{
    QMetaObject::activate<void>(const_cast< ZXingQt::BarcodeReader *>(this), &staticMetaObject, 10, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN7ZXingQtE_t {};
} // unnamed namespace

template <> constexpr inline auto ZXingQt::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQtE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ZXingQt",
        "BarcodeFormat",
        "None",
        "All",
        "AllReadable",
        "AllCreatable",
        "AllLinear",
        "AllMatrix",
        "AllGS1",
        "AllRetail",
        "AllIndustrial",
        "Codabar",
        "Code39",
        "Code39Std",
        "Code39Ext",
        "Code32",
        "PZN",
        "Code93",
        "Code128",
        "ITF",
        "ITF14",
        "DataBar",
        "DataBarOmni",
        "DataBarStk",
        "DataBarStkOmni",
        "DataBarLtd",
        "DataBarExp",
        "DataBarExpStk",
        "EANUPC",
        "EAN13",
        "EAN8",
        "EAN5",
        "EAN2",
        "ISBN",
        "UPCA",
        "UPCE",
        "Telepen",
        "TelepenAlpha",
        "TelepenNumeric",
        "OtherBarcode",
        "DXFilmEdge",
        "PDF417",
        "CompactPDF417",
        "MicroPDF417",
        "Aztec",
        "AztecCode",
        "AztecRune",
        "QRCode",
        "QRCodeModel1",
        "QRCodeModel2",
        "MicroQRCode",
        "RMQRCode",
        "DataMatrix",
        "MaxiCode",
        "ContentType",
        "Text",
        "Binary",
        "Mixed",
        "GS1",
        "ISO15434",
        "UnknownECI",
        "TextMode",
        "Plain",
        "ECI",
        "HRI",
        "Escaped",
        "Hex",
        "HexECI",
        "Binarizer",
        "LocalAverage",
        "GlobalHistogram",
        "FixedThreshold",
        "BoolCast"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'BarcodeFormat'
        QtMocHelpers::EnumData<BarcodeFormat>(1, 1, QMC::EnumIsScoped).add({
            {    2, BarcodeFormat::None },
            {    3, BarcodeFormat::All },
            {    4, BarcodeFormat::AllReadable },
            {    5, BarcodeFormat::AllCreatable },
            {    6, BarcodeFormat::AllLinear },
            {    7, BarcodeFormat::AllMatrix },
            {    8, BarcodeFormat::AllGS1 },
            {    9, BarcodeFormat::AllRetail },
            {   10, BarcodeFormat::AllIndustrial },
            {   11, BarcodeFormat::Codabar },
            {   12, BarcodeFormat::Code39 },
            {   13, BarcodeFormat::Code39Std },
            {   14, BarcodeFormat::Code39Ext },
            {   15, BarcodeFormat::Code32 },
            {   16, BarcodeFormat::PZN },
            {   17, BarcodeFormat::Code93 },
            {   18, BarcodeFormat::Code128 },
            {   19, BarcodeFormat::ITF },
            {   20, BarcodeFormat::ITF14 },
            {   21, BarcodeFormat::DataBar },
            {   22, BarcodeFormat::DataBarOmni },
            {   23, BarcodeFormat::DataBarStk },
            {   24, BarcodeFormat::DataBarStkOmni },
            {   25, BarcodeFormat::DataBarLtd },
            {   26, BarcodeFormat::DataBarExp },
            {   27, BarcodeFormat::DataBarExpStk },
            {   28, BarcodeFormat::EANUPC },
            {   29, BarcodeFormat::EAN13 },
            {   30, BarcodeFormat::EAN8 },
            {   31, BarcodeFormat::EAN5 },
            {   32, BarcodeFormat::EAN2 },
            {   33, BarcodeFormat::ISBN },
            {   34, BarcodeFormat::UPCA },
            {   35, BarcodeFormat::UPCE },
            {   36, BarcodeFormat::Telepen },
            {   37, BarcodeFormat::TelepenAlpha },
            {   38, BarcodeFormat::TelepenNumeric },
            {   39, BarcodeFormat::OtherBarcode },
            {   40, BarcodeFormat::DXFilmEdge },
            {   41, BarcodeFormat::PDF417 },
            {   42, BarcodeFormat::CompactPDF417 },
            {   43, BarcodeFormat::MicroPDF417 },
            {   44, BarcodeFormat::Aztec },
            {   45, BarcodeFormat::AztecCode },
            {   46, BarcodeFormat::AztecRune },
            {   47, BarcodeFormat::QRCode },
            {   48, BarcodeFormat::QRCodeModel1 },
            {   49, BarcodeFormat::QRCodeModel2 },
            {   50, BarcodeFormat::MicroQRCode },
            {   51, BarcodeFormat::RMQRCode },
            {   52, BarcodeFormat::DataMatrix },
            {   53, BarcodeFormat::MaxiCode },
        }),
        // enum 'ContentType'
        QtMocHelpers::EnumData<ContentType>(54, 54, QMC::EnumIsScoped).add({
            {   55, ContentType::Text },
            {   56, ContentType::Binary },
            {   57, ContentType::Mixed },
            {   58, ContentType::GS1 },
            {   59, ContentType::ISO15434 },
            {   60, ContentType::UnknownECI },
        }),
        // enum 'TextMode'
        QtMocHelpers::EnumData<TextMode>(61, 61, QMC::EnumIsScoped).add({
            {   62, TextMode::Plain },
            {   63, TextMode::ECI },
            {   64, TextMode::HRI },
            {   65, TextMode::Escaped },
            {   66, TextMode::Hex },
            {   67, TextMode::HexECI },
        }),
        // enum 'Binarizer'
        QtMocHelpers::EnumData<Binarizer>(68, 68, QMC::EnumIsScoped).add({
            {   69, Binarizer::LocalAverage },
            {   70, Binarizer::GlobalHistogram },
            {   71, Binarizer::FixedThreshold },
            {   72, Binarizer::BoolCast },
        }),
    };
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN7ZXingQtE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}

static constexpr auto qt_staticMetaObjectContent_ZN7ZXingQtE =
    ZXingQt::qt_create_metaobjectdata<qt_meta_tag_ZN7ZXingQtE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN7ZXingQtE =
    qt_staticMetaObjectContent_ZN7ZXingQtE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN7ZXingQtE =
    qt_staticMetaObjectContent_ZN7ZXingQtE.relocatingData;

Q_CONSTINIT const QMetaObject ZXingQt::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN7ZXingQtE.stringdata,
    qt_staticMetaObjectStaticContent_ZN7ZXingQtE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN7ZXingQtE.metaTypes,
    nullptr
} };

QT_WARNING_POP
