/****************************************************************************
** Meta object code from reading C++ file 'MessageModel.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 "../../../../kaidan-0.16.0/src/MessageModel.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 'MessageModel.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_ZN24DisplayedMessageReactionE_t {};
} // unnamed namespace

template <> constexpr inline auto DisplayedMessageReaction::qt_create_metaobjectdata<qt_meta_tag_ZN24DisplayedMessageReactionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DisplayedMessageReaction",
        "emoji",
        "count",
        "ownReactionIncluded",
        "deliveryState",
        "MessageReactionDeliveryState::Enum"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'emoji'
        QtMocHelpers::PropertyData<QString>(1, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'count'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'ownReactionIncluded'
        QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'deliveryState'
        QtMocHelpers::PropertyData<MessageReactionDeliveryState::Enum>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DisplayedMessageReaction, qt_meta_tag_ZN24DisplayedMessageReactionE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN24DisplayedMessageReactionE[] = {
    QMetaObject::SuperData::link<MessageReactionDeliveryState::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject DisplayedMessageReaction::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DisplayedMessageReactionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DisplayedMessageReactionE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN24DisplayedMessageReactionE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24DisplayedMessageReactionE_t>.metaTypes,
    nullptr
} };

void DisplayedMessageReaction::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<DisplayedMessageReaction *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->emoji; break;
        case 1: *reinterpret_cast<int*>(_v) = _t->count; break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->ownReactionIncluded; break;
        case 3: *reinterpret_cast<MessageReactionDeliveryState::Enum*>(_v) = _t->deliveryState; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->emoji, *reinterpret_cast<QString*>(_v)); break;
        case 1: QtMocHelpers::setProperty(_t->count, *reinterpret_cast<int*>(_v)); break;
        case 2: QtMocHelpers::setProperty(_t->ownReactionIncluded, *reinterpret_cast<bool*>(_v)); break;
        case 3: QtMocHelpers::setProperty(_t->deliveryState, *reinterpret_cast<MessageReactionDeliveryState::Enum*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN12MessageModelE_t {};
} // unnamed namespace

template <> constexpr inline auto MessageModel::qt_create_metaobjectdata<qt_meta_tag_ZN12MessageModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MessageModel",
        "messageFetchingFinished",
        "",
        "messageSearchByIdInDbFinished",
        "foundMessageIndex",
        "messageSearchFinished",
        "queryStringMessageIndex",
        "mamLoadingChanged",
        "fetchMore",
        "QModelIndex",
        "parent",
        "canFetchMore",
        "resendMessage",
        "index",
        "handleMessageRead",
        "readMessageIndex",
        "firstUnreadContactMessageIndex",
        "setMessageMarked",
        "marked",
        "addMessageReaction",
        "messageId",
        "emoji",
        "removeMessageReaction",
        "resendMessageReactions",
        "nextCorrectableMessageIndex",
        "indexOffset",
        "previousCorrectableMessageIndex",
        "canCorrectMessage",
        "deleteFile",
        "File",
        "file",
        "removeMessage",
        "searchMessageById",
        "searchForMessageFromNewToOld",
        "searchString",
        "startIndex",
        "searchForMessageFromOldToNew",
        "mamLoading",
        "MessageRoles",
        "SenderJid",
        "GroupChatSenderId",
        "SenderName",
        "Id",
        "IsLastReadOwnMessage",
        "IsLatestOldMessage",
        "IsEdited",
        "ReplyToJid",
        "ReplyToGroupChatParticipantId",
        "ReplyToName",
        "ReplyId",
        "ReplyQuote",
        "Date",
        "NextDate",
        "Time",
        "Body",
        "Encryption",
        "TrustLevel",
        "DeliveryState",
        "DeliveryStateIcon",
        "DeliveryStateName",
        "IsSpoiler",
        "SpoilerHint",
        "IsOwn",
        "Files",
        "DisplayedReactions",
        "DetailedReactions",
        "OwnReactionsFailed",
        "GroupChatInvitationJid",
        "GeoCoordinate",
        "Marked",
        "ErrorText"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'messageFetchingFinished'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'messageSearchByIdInDbFinished'
        QtMocHelpers::SignalData<void(int)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 },
        }}),
        // Signal 'messageSearchFinished'
        QtMocHelpers::SignalData<void(int)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Signal 'mamLoadingChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'fetchMore'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Method 'canFetchMore'
        QtMocHelpers::MethodData<bool(const QModelIndex &) const>(11, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Method 'resendMessage'
        QtMocHelpers::MethodData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Method 'handleMessageRead'
        QtMocHelpers::MethodData<void(int)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 15 },
        }}),
        // Method 'firstUnreadContactMessageIndex'
        QtMocHelpers::MethodData<int() const>(16, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'setMessageMarked'
        QtMocHelpers::MethodData<void(int, bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 }, { QMetaType::Bool, 18 },
        }}),
        // Method 'addMessageReaction'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 }, { QMetaType::QString, 21 },
        }}),
        // Method 'removeMessageReaction'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 }, { QMetaType::QString, 21 },
        }}),
        // Method 'resendMessageReactions'
        QtMocHelpers::MethodData<void(const QString &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Method 'nextCorrectableMessageIndex'
        QtMocHelpers::MethodData<int(int) const>(24, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 25 },
        }}),
        // Method 'previousCorrectableMessageIndex'
        QtMocHelpers::MethodData<int(int) const>(26, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 25 },
        }}),
        // Method 'canCorrectMessage'
        QtMocHelpers::MethodData<bool(int) const>(27, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 13 },
        }}),
        // Method 'deleteFile'
        QtMocHelpers::MethodData<void(const QString &, const File &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 }, { 0x80000000 | 29, 30 },
        }}),
        // Method 'removeMessage'
        QtMocHelpers::MethodData<void(const QString &)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Method 'searchMessageById'
        QtMocHelpers::MethodData<int(const QString &)>(32, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 20 },
        }}),
        // Method 'searchForMessageFromNewToOld'
        QtMocHelpers::MethodData<int(const QString &, int)>(33, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 34 }, { QMetaType::Int, 35 },
        }}),
        // Method 'searchForMessageFromNewToOld'
        QtMocHelpers::MethodData<int(const QString &)>(33, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::QString, 34 },
        }}),
        // Method 'searchForMessageFromOldToNew'
        QtMocHelpers::MethodData<int(const QString &, int)>(36, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 34 }, { QMetaType::Int, 35 },
        }}),
        // Method 'searchForMessageFromOldToNew'
        QtMocHelpers::MethodData<int(const QString &)>(36, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { QMetaType::QString, 34 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'mamLoading'
        QtMocHelpers::PropertyData<bool>(37, QMetaType::Bool, QMC::DefaultPropertyFlags, 3),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'MessageRoles'
        QtMocHelpers::EnumData<enum MessageRoles>(38, 38, QMC::EnumFlags{}).add({
            {   39, MessageRoles::SenderJid },
            {   40, MessageRoles::GroupChatSenderId },
            {   41, MessageRoles::SenderName },
            {   42, MessageRoles::Id },
            {   43, MessageRoles::IsLastReadOwnMessage },
            {   44, MessageRoles::IsLatestOldMessage },
            {   45, MessageRoles::IsEdited },
            {   46, MessageRoles::ReplyToJid },
            {   47, MessageRoles::ReplyToGroupChatParticipantId },
            {   48, MessageRoles::ReplyToName },
            {   49, MessageRoles::ReplyId },
            {   50, MessageRoles::ReplyQuote },
            {   51, MessageRoles::Date },
            {   52, MessageRoles::NextDate },
            {   53, MessageRoles::Time },
            {   54, MessageRoles::Body },
            {   55, MessageRoles::Encryption },
            {   56, MessageRoles::TrustLevel },
            {   57, MessageRoles::DeliveryState },
            {   58, MessageRoles::DeliveryStateIcon },
            {   59, MessageRoles::DeliveryStateName },
            {   60, MessageRoles::IsSpoiler },
            {   61, MessageRoles::SpoilerHint },
            {   62, MessageRoles::IsOwn },
            {   63, MessageRoles::Files },
            {   64, MessageRoles::DisplayedReactions },
            {   65, MessageRoles::DetailedReactions },
            {   66, MessageRoles::OwnReactionsFailed },
            {   67, MessageRoles::GroupChatInvitationJid },
            {   68, MessageRoles::GeoCoordinate },
            {   69, MessageRoles::Marked },
            {   70, MessageRoles::ErrorText },
        }),
    };
    return QtMocHelpers::metaObjectData<MessageModel, qt_meta_tag_ZN12MessageModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject MessageModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12MessageModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12MessageModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12MessageModelE_t>.metaTypes,
    nullptr
} };

void MessageModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MessageModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->messageFetchingFinished(); break;
        case 1: _t->messageSearchByIdInDbFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->messageSearchFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->mamLoadingChanged(); break;
        case 4: _t->fetchMore((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 5: { bool _r = _t->canFetchMore((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 6: _t->resendMessage((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->handleMessageRead((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: { int _r = _t->firstUnreadContactMessageIndex();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 9: _t->setMessageMarked((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 10: _t->addMessageReaction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 11: _t->removeMessageReaction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 12: _t->resendMessageReactions((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: { int _r = _t->nextCorrectableMessageIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 14: { int _r = _t->previousCorrectableMessageIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 15: { bool _r = _t->canCorrectMessage((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 16: _t->deleteFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<File>>(_a[2]))); break;
        case 17: _t->removeMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: { int _r = _t->searchMessageById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 19: { int _r = _t->searchForMessageFromNewToOld((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 20: { int _r = _t->searchForMessageFromNewToOld((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 21: { int _r = _t->searchForMessageFromOldToNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 22: { int _r = _t->searchForMessageFromOldToNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (MessageModel::*)()>(_a, &MessageModel::messageFetchingFinished, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (MessageModel::*)(int )>(_a, &MessageModel::messageSearchByIdInDbFinished, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (MessageModel::*)(int )>(_a, &MessageModel::messageSearchFinished, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (MessageModel::*)()>(_a, &MessageModel::mamLoadingChanged, 3))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->mamLoading(); break;
        default: break;
        }
    }
}

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

void *MessageModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12MessageModelE_t>.strings))
        return static_cast<void*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int MessageModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 23)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 23;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 23)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 23;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void MessageModel::messageFetchingFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void MessageModel::messageSearchByIdInDbFinished(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void MessageModel::messageSearchFinished(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void MessageModel::mamLoadingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}
QT_WARNING_POP
