/****************************************************************************
** Meta object code from reading C++ file 'uri.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 "../../../libQuotient/Quotient/uri.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'uri.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_ZN8Quotient3UriE_t {};
} // unnamed namespace

template <> constexpr inline auto Quotient::Uri::qt_create_metaobjectdata<qt_meta_tag_ZN8Quotient3UriE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Quotient::Uri",
        "type",
        "Type",
        "",
        "secondaryType",
        "SecondaryType",
        "toUrl",
        "QUrl",
        "UriForm",
        "form",
        "primaryId",
        "secondaryId",
        "action",
        "setAction",
        "newAction",
        "viaServers",
        "isValid",
        "Invalid",
        "Empty",
        "UserId",
        "RoomId",
        "RoomAlias",
        "Group",
        "BareEventId",
        "NonMatrix",
        "NoSecondaryId",
        "EventId",
        "CanonicalUri",
        "MatrixToUri"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'type'
        QtMocHelpers::MethodData<enum Type() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
        // Method 'secondaryType'
        QtMocHelpers::MethodData<enum SecondaryType() const>(4, 3, QMC::AccessPublic, 0x80000000 | 5),
        // Method 'toUrl'
        QtMocHelpers::MethodData<QUrl(enum UriForm) const>(6, 3, QMC::AccessPublic, 0x80000000 | 7, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Method 'toUrl'
        QtMocHelpers::MethodData<QUrl() const>(6, 3, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 7),
        // Method 'primaryId'
        QtMocHelpers::MethodData<QString() const>(10, 3, QMC::AccessPublic, QMetaType::QString),
        // Method 'secondaryId'
        QtMocHelpers::MethodData<QString() const>(11, 3, QMC::AccessPublic, QMetaType::QString),
        // Method 'action'
        QtMocHelpers::MethodData<QString() const>(12, 3, QMC::AccessPublic, QMetaType::QString),
        // Method 'setAction'
        QtMocHelpers::MethodData<void(const QString &)>(13, 3, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Method 'viaServers'
        QtMocHelpers::MethodData<QStringList() const>(15, 3, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'isValid'
        QtMocHelpers::MethodData<bool() const>(16, 3, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Type'
        QtMocHelpers::EnumData<enum Type>(2, 2, QMC::EnumFlags{}).add({
            {   17, Type::Invalid },
            {   18, Type::Empty },
            {   19, Type::UserId },
            {   20, Type::RoomId },
            {   21, Type::RoomAlias },
            {   22, Type::Group },
            {   23, Type::BareEventId },
            {   24, Type::NonMatrix },
        }),
        // enum 'SecondaryType'
        QtMocHelpers::EnumData<enum SecondaryType>(5, 5, QMC::EnumFlags{}).add({
            {   25, SecondaryType::NoSecondaryId },
            {   26, SecondaryType::EventId },
        }),
        // enum 'UriForm'
        QtMocHelpers::EnumData<enum UriForm>(8, 8, QMC::EnumFlags{}).add({
            {   27, UriForm::CanonicalUri },
            {   28, UriForm::MatrixToUri },
        }),
    };
    return QtMocHelpers::metaObjectData<Uri, qt_meta_tag_ZN8Quotient3UriE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Quotient::Uri::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QUrl>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Quotient3UriE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Quotient3UriE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Quotient3UriE_t>.metaTypes,
    nullptr
} };

void Quotient::Uri::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<Uri *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { enum Type _r = _t->type();
            if (_a[0]) *reinterpret_cast<enum Type*>(_a[0]) = std::move(_r); }  break;
        case 1: { enum SecondaryType _r = _t->secondaryType();
            if (_a[0]) *reinterpret_cast<enum SecondaryType*>(_a[0]) = std::move(_r); }  break;
        case 2: { QUrl _r = _t->toUrl((*reinterpret_cast<std::add_pointer_t<enum UriForm>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 3: { QUrl _r = _t->toUrl();
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 4: { QString _r = _t->primaryId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 5: { QString _r = _t->secondaryId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 6: { QString _r = _t->action();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setAction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: { QStringList _r = _t->viaServers();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 9: { bool _r = _t->isValid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}
QT_WARNING_POP
