/****************************************************************************
** Meta object code from reading C++ file 'qdocumentcursor.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 "../../../texstudio-4.9.5/src/qcodeedit/lib/document/qdocumentcursor.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 'qdocumentcursor.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_ZN15QDocumentCursorE_t {};
} // unnamed namespace

template <> constexpr inline auto QDocumentCursor::qt_create_metaobjectdata<qt_meta_tag_ZN15QDocumentCursorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QDocumentCursor",
        "beginBoundaryLarger",
        "",
        "c",
        "endBoundaryLarger",
        "equalBoundaries",
        "equal",
        "isNull",
        "isValid",
        "atEnd",
        "atStart",
        "atBlockEnd",
        "atBlockStart",
        "atLineEnd",
        "atLineStart",
        "hasSelection",
        "isForwardSelection",
        "isSilent",
        "isAutoUpdated",
        "isAutoErasable",
        "lineNumber",
        "columnNumber",
        "anchorLineNumber",
        "anchorColumnNumber",
        "startLineNumber",
        "startColumnNumber",
        "endLineNumber",
        "endColumnNumber",
        "visualColumnNumber",
        "setLineNumber",
        "MoveMode",
        "m",
        "setColumnNumber",
        "setAnchorLineNumber",
        "setAnchorColumnNumber",
        "wrappedLineOffset",
        "anchorWrappedLineOffset",
        "documentPosition",
        "QPointF",
        "anchorDocumentPosition",
        "shift",
        "offset",
        "setPosition",
        "pos",
        "movePosition",
        "MoveOperation",
        "op",
        "moveTo",
        "line",
        "column",
        "eraseLine",
        "insertLine",
        "keepAnchor",
        "insertText",
        "s",
        "selectedText",
        "clearSelection",
        "flipSelection",
        "removeSelectedText",
        "replaceSelectedText",
        "text",
        "select",
        "SelectionType",
        "t",
        "expandSelect",
        "setSelectionBoundary",
        "lineTo",
        "columnTo",
        "selectColumns",
        "isWithinSelection",
        "intersect",
        "nextChar",
        "previousChar",
        "deleteChar",
        "deletePreviousChar",
        "beginEditBlock",
        "endEditBlock",
        "QDocument*",
        "doc",
        "cursor",
        "MoveFlag",
        "MoveAnchor",
        "KeepAnchor",
        "ThroughWrap",
        "ThroughFolding",
        "NoMove",
        "Up",
        "Down",
        "Left",
        "PreviousCharacter",
        "Right",
        "NextCharacter",
        "Start",
        "StartOfLine",
        "StartOfBlock",
        "StartOfWord",
        "StartOfWordOrCommand",
        "StartOfParenthesis",
        "StartOfLineText",
        "PreviousBlock",
        "PreviousLine",
        "PreviousWord",
        "WordLeft",
        "WordRight",
        "End",
        "EndOfLine",
        "EndOfBlock",
        "EndOfWord",
        "EndOfWordOrCommand",
        "NextWord",
        "NextBlock",
        "NextLine",
        "WordUnderCursor",
        "WordOrCommandUnderCursor",
        "LineUnderCursor",
        "ParenthesesInner",
        "ParenthesesOuter"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'beginBoundaryLarger'
        QtMocHelpers::MethodData<bool(const QDocumentCursor &) const>(1, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'endBoundaryLarger'
        QtMocHelpers::MethodData<bool(const QDocumentCursor &) const>(4, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'equalBoundaries'
        QtMocHelpers::MethodData<bool(const QDocumentCursor &) const>(5, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'equal'
        QtMocHelpers::MethodData<bool(const QDocumentCursor &) const>(6, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'isNull'
        QtMocHelpers::MethodData<bool() const>(7, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isValid'
        QtMocHelpers::MethodData<bool() const>(8, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atEnd'
        QtMocHelpers::MethodData<bool() const>(9, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atStart'
        QtMocHelpers::MethodData<bool() const>(10, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atBlockEnd'
        QtMocHelpers::MethodData<bool() const>(11, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atBlockStart'
        QtMocHelpers::MethodData<bool() const>(12, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atLineEnd'
        QtMocHelpers::MethodData<bool() const>(13, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'atLineStart'
        QtMocHelpers::MethodData<bool() const>(14, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'hasSelection'
        QtMocHelpers::MethodData<bool() const>(15, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isForwardSelection'
        QtMocHelpers::MethodData<bool() const>(16, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isSilent'
        QtMocHelpers::MethodData<bool() const>(17, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isAutoUpdated'
        QtMocHelpers::MethodData<bool() const>(18, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isAutoErasable'
        QtMocHelpers::MethodData<bool() const>(19, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'lineNumber'
        QtMocHelpers::MethodData<int() const>(20, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'columnNumber'
        QtMocHelpers::MethodData<int() const>(21, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'anchorLineNumber'
        QtMocHelpers::MethodData<int() const>(22, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'anchorColumnNumber'
        QtMocHelpers::MethodData<int() const>(23, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'startLineNumber'
        QtMocHelpers::MethodData<int() const>(24, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'startColumnNumber'
        QtMocHelpers::MethodData<int() const>(25, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'endLineNumber'
        QtMocHelpers::MethodData<int() const>(26, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'endColumnNumber'
        QtMocHelpers::MethodData<int() const>(27, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'visualColumnNumber'
        QtMocHelpers::MethodData<int() const>(28, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'setLineNumber'
        QtMocHelpers::MethodData<void(int, MoveMode)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { 0x80000000 | 30, 31 },
        }}),
        // Method 'setLineNumber'
        QtMocHelpers::MethodData<void(int)>(29, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Method 'setColumnNumber'
        QtMocHelpers::MethodData<void(int, MoveMode)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { 0x80000000 | 30, 31 },
        }}),
        // Method 'setColumnNumber'
        QtMocHelpers::MethodData<void(int)>(32, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Method 'setAnchorLineNumber'
        QtMocHelpers::MethodData<void(int) const>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Method 'setAnchorColumnNumber'
        QtMocHelpers::MethodData<void(int) const>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Method 'wrappedLineOffset'
        QtMocHelpers::MethodData<int() const>(35, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'anchorWrappedLineOffset'
        QtMocHelpers::MethodData<int() const>(36, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'documentPosition'
        QtMocHelpers::MethodData<QPointF() const>(37, 2, QMC::AccessPublic, 0x80000000 | 38),
        // Method 'anchorDocumentPosition'
        QtMocHelpers::MethodData<QPointF() const>(39, 2, QMC::AccessPublic, 0x80000000 | 38),
        // Method 'shift'
        QtMocHelpers::MethodData<void(int)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 41 },
        }}),
        // Method 'setPosition'
        QtMocHelpers::MethodData<void(int, MoveMode)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 43 }, { 0x80000000 | 30, 31 },
        }}),
        // Method 'setPosition'
        QtMocHelpers::MethodData<void(int)>(42, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 43 },
        }}),
        // Method 'movePosition'
        QtMocHelpers::MethodData<bool(int, enum MoveOperation, MoveMode)>(44, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 41 }, { 0x80000000 | 45, 46 }, { 0x80000000 | 30, 31 },
        }}),
        // Method 'movePosition'
        QtMocHelpers::MethodData<bool(int, enum MoveOperation)>(44, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 41 }, { 0x80000000 | 45, 46 },
        }}),
        // Method 'movePosition'
        QtMocHelpers::MethodData<bool(int)>(44, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Int, 41 },
        }}),
        // Method 'moveTo'
        QtMocHelpers::MethodData<void(int, int, MoveMode)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 49 }, { 0x80000000 | 30, 31 },
        }}),
        // Method 'moveTo'
        QtMocHelpers::MethodData<void(int, int)>(47, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 49 },
        }}),
        // Method 'eraseLine'
        QtMocHelpers::MethodData<void()>(50, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'insertLine'
        QtMocHelpers::MethodData<void(bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Method 'insertLine'
        QtMocHelpers::MethodData<void()>(51, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'insertText'
        QtMocHelpers::MethodData<void(const QString &, bool)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 }, { QMetaType::Bool, 52 },
        }}),
        // Method 'insertText'
        QtMocHelpers::MethodData<void(const QString &)>(53, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Method 'selectedText'
        QtMocHelpers::MethodData<QString() const>(55, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'clearSelection'
        QtMocHelpers::MethodData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'flipSelection'
        QtMocHelpers::MethodData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'removeSelectedText'
        QtMocHelpers::MethodData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'replaceSelectedText'
        QtMocHelpers::MethodData<void(const QString &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 60 },
        }}),
        // Method 'select'
        QtMocHelpers::MethodData<void(enum SelectionType)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 },
        }}),
        // Method 'expandSelect'
        QtMocHelpers::MethodData<void(enum SelectionType)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 },
        }}),
        // Method 'setSelectionBoundary'
        QtMocHelpers::MethodData<void(const QDocumentCursor &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'select'
        QtMocHelpers::MethodData<void(int, int, int, int)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 49 }, { QMetaType::Int, 66 }, { QMetaType::Int, 67 },
        }}),
        // Method 'select'
        QtMocHelpers::MethodData<void(int, int, int)>(61, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 49 }, { QMetaType::Int, 66 },
        }}),
        // Method 'select'
        QtMocHelpers::MethodData<void(int, int)>(61, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 49 },
        }}),
        // Method 'selectColumns'
        QtMocHelpers::MethodData<void(int, int)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 49 }, { QMetaType::Int, 67 },
        }}),
        // Method 'selectColumns'
        QtMocHelpers::MethodData<void(int)>(68, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 49 },
        }}),
        // Method 'isWithinSelection'
        QtMocHelpers::MethodData<bool(const QDocumentCursor &) const>(69, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'intersect'
        QtMocHelpers::MethodData<QDocumentCursor(const QDocumentCursor &) const>(70, 2, QMC::AccessPublic, 0x80000000 | 0, {{
            { 0x80000000 | 0, 3 },
        }}),
        // Method 'nextChar'
        QtMocHelpers::MethodData<QChar() const>(71, 2, QMC::AccessPublic, QMetaType::QChar),
        // Method 'previousChar'
        QtMocHelpers::MethodData<QChar() const>(72, 2, QMC::AccessPublic, QMetaType::QChar),
        // Method 'deleteChar'
        QtMocHelpers::MethodData<void()>(73, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'deletePreviousChar'
        QtMocHelpers::MethodData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'beginEditBlock'
        QtMocHelpers::MethodData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'endEditBlock'
        QtMocHelpers::MethodData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'MoveFlag'
        QtMocHelpers::EnumData<enum MoveFlag>(80, 80, QMC::EnumFlags{}).add({
            {   81, MoveFlag::MoveAnchor },
            {   82, MoveFlag::KeepAnchor },
            {   83, MoveFlag::ThroughWrap },
            {   84, MoveFlag::ThroughFolding },
        }),
        // enum 'MoveMode'
        QtMocHelpers::EnumData<MoveMode>(30, 80, QMC::EnumFlags{}).add({
            {   81, MoveFlag::MoveAnchor },
            {   82, MoveFlag::KeepAnchor },
            {   83, MoveFlag::ThroughWrap },
            {   84, MoveFlag::ThroughFolding },
        }),
        // enum 'MoveOperation'
        QtMocHelpers::EnumData<enum MoveOperation>(45, 45, QMC::EnumFlags{}).add({
            {   85, MoveOperation::NoMove },
            {   86, MoveOperation::Up },
            {   87, MoveOperation::Down },
            {   88, MoveOperation::Left },
            {   89, MoveOperation::PreviousCharacter },
            {   90, MoveOperation::Right },
            {   91, MoveOperation::NextCharacter },
            {   92, MoveOperation::Start },
            {   93, MoveOperation::StartOfLine },
            {   94, MoveOperation::StartOfBlock },
            {   95, MoveOperation::StartOfWord },
            {   96, MoveOperation::StartOfWordOrCommand },
            {   97, MoveOperation::StartOfParenthesis },
            {   98, MoveOperation::StartOfLineText },
            {   99, MoveOperation::PreviousBlock },
            {  100, MoveOperation::PreviousLine },
            {  101, MoveOperation::PreviousWord },
            {  102, MoveOperation::WordLeft },
            {  103, MoveOperation::WordRight },
            {  104, MoveOperation::End },
            {  105, MoveOperation::EndOfLine },
            {  106, MoveOperation::EndOfBlock },
            {  107, MoveOperation::EndOfWord },
            {  108, MoveOperation::EndOfWordOrCommand },
            {  109, MoveOperation::NextWord },
            {  110, MoveOperation::NextBlock },
            {  111, MoveOperation::NextLine },
        }),
        // enum 'SelectionType'
        QtMocHelpers::EnumData<enum SelectionType>(62, 62, QMC::EnumFlags{}).add({
            {  112, SelectionType::WordUnderCursor },
            {  113, SelectionType::WordOrCommandUnderCursor },
            {  114, SelectionType::LineUnderCursor },
            {  115, SelectionType::ParenthesesInner },
            {  116, SelectionType::ParenthesesOuter },
        }),
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(QDocument *)>(2, QMC::AccessPublic, {{
            { 0x80000000 | 77, 78 },
        }}),
        QtMocHelpers::ConstructorData<Constructor(const QDocumentCursor &)>(2, QMC::AccessPublic, {{
            { 0x80000000 | 0, 79 },
        }}),
        QtMocHelpers::ConstructorData<Constructor(QDocument *, int, int, int, int)>(2, QMC::AccessPublic, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 48 }, { QMetaType::Int, 49 }, { QMetaType::Int, 66 },
            { QMetaType::Int, 67 },
        }}),
        QtMocHelpers::ConstructorData<Constructor(QDocument *, int, int, int)>(2, QMC::AccessPublic | QMC::MethodCloned, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 48 }, { QMetaType::Int, 49 }, { QMetaType::Int, 66 },
        }}),
        QtMocHelpers::ConstructorData<Constructor(QDocument *, int, int)>(2, QMC::AccessPublic | QMC::MethodCloned, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 48 }, { QMetaType::Int, 49 },
        }}),
        QtMocHelpers::ConstructorData<Constructor(QDocument *, int)>(2, QMC::AccessPublic | QMC::MethodCloned, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 48 },
        }}),
    };
    return QtMocHelpers::metaObjectData<QDocumentCursor, qt_meta_tag_ZN15QDocumentCursorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors);
}
Q_CONSTINIT const QMetaObject QDocumentCursor::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QDocumentCursorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QDocumentCursorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QDocumentCursorE_t>.metaTypes,
    nullptr
} };

void QDocumentCursor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QDocumentCursor *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 1: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 2: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 3: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 4: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        case 5: { QDocumentCursor *_r = new QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1]))); } break;
        case 1: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); } break;
        case 2: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); } break;
        case 3: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); } break;
        case 4: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); } break;
        case 5: { new (_a[0]) QDocumentCursor((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { bool _r = _t->beginBoundaryLarger((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 1: { bool _r = _t->endBoundaryLarger((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 2: { bool _r = _t->equalBoundaries((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 3: { bool _r = _t->equal((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 4: { bool _r = _t->isNull();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 5: { bool _r = _t->isValid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 6: { bool _r = _t->atEnd();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 7: { bool _r = _t->atStart();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 8: { bool _r = _t->atBlockEnd();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 9: { bool _r = _t->atBlockStart();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 10: { bool _r = _t->atLineEnd();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 11: { bool _r = _t->atLineStart();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 12: { bool _r = _t->hasSelection();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 13: { bool _r = _t->isForwardSelection();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 14: { bool _r = _t->isSilent();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 15: { bool _r = _t->isAutoUpdated();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 16: { bool _r = _t->isAutoErasable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 17: { int _r = _t->lineNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 18: { int _r = _t->columnNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 19: { int _r = _t->anchorLineNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 20: { int _r = _t->anchorColumnNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 21: { int _r = _t->startLineNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 22: { int _r = _t->startColumnNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 23: { int _r = _t->endLineNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 24: { int _r = _t->endColumnNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 25: { int _r = _t->visualColumnNumber();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 26: _t->setLineNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MoveMode>>(_a[2]))); break;
        case 27: _t->setLineNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->setColumnNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MoveMode>>(_a[2]))); break;
        case 29: _t->setColumnNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 30: _t->setAnchorLineNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 31: _t->setAnchorColumnNumber((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 32: { int _r = _t->wrappedLineOffset();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 33: { int _r = _t->anchorWrappedLineOffset();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 34: { QPointF _r = _t->documentPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 35: { QPointF _r = _t->anchorDocumentPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 36: _t->shift((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 37: _t->setPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MoveMode>>(_a[2]))); break;
        case 38: _t->setPosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 39: { bool _r = _t->movePosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum MoveOperation>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<MoveMode>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 40: { bool _r = _t->movePosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum MoveOperation>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 41: { bool _r = _t->movePosition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 42: _t->moveTo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<MoveMode>>(_a[3]))); break;
        case 43: _t->moveTo((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 44: _t->eraseLine(); break;
        case 45: _t->insertLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 46: _t->insertLine(); break;
        case 47: _t->insertText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 48: _t->insertText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 49: { QString _r = _t->selectedText();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->clearSelection(); break;
        case 51: _t->flipSelection(); break;
        case 52: _t->removeSelectedText(); break;
        case 53: _t->replaceSelectedText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 54: _t->select((*reinterpret_cast<std::add_pointer_t<enum SelectionType>>(_a[1]))); break;
        case 55: _t->expandSelect((*reinterpret_cast<std::add_pointer_t<enum SelectionType>>(_a[1]))); break;
        case 56: _t->setSelectionBoundary((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 57: _t->select((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 58: _t->select((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 59: _t->select((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 60: _t->selectColumns((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 61: _t->selectColumns((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 62: { bool _r = _t->isWithinSelection((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: { QDocumentCursor _r = _t->intersect((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDocumentCursor*>(_a[0]) = std::move(_r); }  break;
        case 64: { QChar _r = _t->nextChar();
            if (_a[0]) *reinterpret_cast<QChar*>(_a[0]) = std::move(_r); }  break;
        case 65: { QChar _r = _t->previousChar();
            if (_a[0]) *reinterpret_cast<QChar*>(_a[0]) = std::move(_r); }  break;
        case 66: _t->deleteChar(); break;
        case 67: _t->deletePreviousChar(); break;
        case 68: _t->beginEditBlock(); break;
        case 69: _t->endEditBlock(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 56:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 62:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 63:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        }
    }
}

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

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

int QDocumentCursor::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 < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    return _id;
}
QT_WARNING_POP
