/****************************************************************************
** Meta object code from reading C++ file 'guideadaptor.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 "guideadaptor.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 'guideadaptor.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_ZN12GuideAdaptorE_t {};
} // unnamed namespace

template <> constexpr inline auto GuideAdaptor::qt_create_metaobjectdata<qt_meta_tag_ZN12GuideAdaptorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "GuideAdaptor",
        "D-Bus Interface",
        "org.kde.kstars.Ekos.Guide",
        "D-Bus Introspection",
        "  <interface name=\"org.kde.kstars.Ekos.Guide\">\n    <property ac"
        "cess=\"readwrite\" type=\"s\" name=\"opticalTrain\"/>\n    <proper"
        "ty access=\"read\" type=\"s\" name=\"camera\"/>\n    <property acc"
        "ess=\"read\" type=\"s\" name=\"guider\"/>\n    <property access=\""
        "read\" type=\"as\" name=\"logText\"/>\n    <property access=\"read"
        "write\" type=\"d\" name=\"exposure\"/>\n    <property access=\"rea"
        "d\" type=\"i\" name=\"status\">\n      <annotation value=\"Ekos::G"
        "uideState\" name=\"org.qtproject.QtDBus.QtTypeName\"/>\n    </prop"
        "erty>\n    <property access=\"read\" type=\"ad\" name=\"axisDelta\""
        ">\n      <annotation value=\"QList&lt;double&gt;\" name=\"org.qtpr"
        "oject.QtDBus.QtTypeName\"/>\n    </property>\n    <property access"
        "=\"read\" type=\"ad\" name=\"axisSigma\">\n      <annotation value"
        "=\"QList&lt;double&gt;\" name=\"org.qtproject.QtDBus.QtTypeName\"/"
        ">\n    </property>\n    <method name=\"connectGuider\">\n      <ar"
        "g direction=\"out\" type=\"b\"/>\n    </method>\n    <method name="
        "\"disconnectGuider\">\n      <arg direction=\"out\" type=\"b\"/>\n"
        "    </method>\n    <method name=\"guide\">\n      <arg direction=\""
        "out\" type=\"b\"/>\n    </method>\n    <method name=\"abort\">\n  "
        "    <arg direction=\"out\" type=\"b\"/>\n    </method>\n    <metho"
        "d name=\"calibrate\">\n      <arg direction=\"out\" type=\"b\"/>\n"
        "    </method>\n    <method name=\"capture\">\n      <arg direction"
        "=\"out\" type=\"b\"/>\n    </method>\n    <method name=\"loop\">\n"
        "      <annotation value=\"true\" name=\"org.freedesktop.DBus.Metho"
        "d.NoReply\"/>\n    </method>\n    <method name=\"dither\">\n      "
        "<arg direction=\"out\" type=\"b\"/>\n    </method>\n    <method na"
        "me=\"suspend\">\n      <arg direction=\"out\" type=\"b\"/>\n    </"
        "method>\n    <method name=\"resume\">\n      <arg direction=\"out\""
        " type=\"b\"/>\n    </method>\n    <method name=\"clearCalibration\""
        ">\n      <annotation value=\"true\" name=\"org.freedesktop.DBus.Me"
        "thod.NoReply\"/>\n    </method>\n    <method name=\"reloadAIWeight"
        "s\">\n      <annotation value=\"true\" name=\"org.freedesktop.DBus"
        ".Method.NoReply\"/>\n    </method>\n    <method name=\"setDarkFram"
        "eEnabled\">\n      <arg direction=\"in\" type=\"b\" name=\"enable\""
        "/>\n      <annotation value=\"true\" name=\"org.freedesktop.DBus.M"
        "ethod.NoReply\"/>\n    </method>\n    <method name=\"setSubFrameEn"
        "abled\">\n      <arg direction=\"in\" type=\"b\" name=\"enable\"/>"
        "\n      <annotation value=\"true\" name=\"org.freedesktop.DBus.Met"
        "hod.NoReply\"/>\n    </method>\n    <method name=\"setAutoStarEnab"
        "led\">\n      <arg direction=\"in\" type=\"b\" name=\"enable\"/>\n"
        "      <annotation value=\"true\" name=\"org.freedesktop.DBus.Metho"
        "d.NoReply\"/>\n    </method>\n    <method name=\"setGuiderType\">\n"
        "      <arg direction=\"in\" type=\"i\" name=\"guideType\"/>\n     "
        " <arg direction=\"out\" type=\"b\"/>\n    </method>\n    <signal n"
        "ame=\"newStatus\">\n      <arg direction=\"out\" type=\"(i)\" name"
        "=\"status\"/>\n      <annotation value=\"Ekos::GuideState\" name=\""
        "org.qtproject.QtDBus.QtTypeName.In0\"/>\n      <annotation value=\""
        "Ekos::GuideState\" name=\"org.qtproject.QtDBus.QtTypeName.Out0\"/>"
        "\n    </signal>\n    <signal name=\"newAxisDelta\">\n      <arg di"
        "rection=\"out\" type=\"d\" name=\"ra\"/>\n      <arg direction=\"o"
        "ut\" type=\"d\" name=\"de\"/>\n    </signal>\n    <signal name=\"n"
        "ewAxisSigma\">\n      <arg direction=\"out\" type=\"d\" name=\"ra\""
        "/>\n      <arg direction=\"out\" type=\"d\" name=\"de\"/>\n    </s"
        "ignal>\n    <signal name=\"newLog\">\n      <arg direction=\"out\""
        " type=\"s\" name=\"text\"/>\n    </signal>\n  </interface>\n",
        "newAxisDelta",
        "",
        "ra",
        "de",
        "newAxisSigma",
        "newLog",
        "text",
        "newStatus",
        "Ekos::GuideState",
        "status",
        "abort",
        "calibrate",
        "capture",
        "clearCalibration",
        "Q_NOREPLY",
        "connectGuider",
        "disconnectGuider",
        "dither",
        "guide",
        "loop",
        "reloadAIWeights",
        "resume",
        "setAutoStarEnabled",
        "enable",
        "setDarkFrameEnabled",
        "setGuiderType",
        "guideType",
        "setSubFrameEnabled",
        "suspend",
        "axisDelta",
        "QList<double>",
        "axisSigma",
        "camera",
        "exposure",
        "guider",
        "logText",
        "opticalTrain"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'newAxisDelta'
        QtMocHelpers::SignalData<void(double, double)>(5, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 7 }, { QMetaType::Double, 8 },
        }}),
        // Signal 'newAxisSigma'
        QtMocHelpers::SignalData<void(double, double)>(9, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 7 }, { QMetaType::Double, 8 },
        }}),
        // Signal 'newLog'
        QtMocHelpers::SignalData<void(const QString &)>(10, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Signal 'newStatus'
        QtMocHelpers::SignalData<void(Ekos::GuideState)>(12, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
        // Slot 'abort'
        QtMocHelpers::SlotData<bool()>(15, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'calibrate'
        QtMocHelpers::SlotData<bool()>(16, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'capture'
        QtMocHelpers::SlotData<bool()>(17, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'clearCalibration'
        QtMocHelpers::SlotData<void()>(18, 19, QMC::AccessPublic, QMetaType::Void),
        // Slot 'connectGuider'
        QtMocHelpers::SlotData<bool()>(20, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'disconnectGuider'
        QtMocHelpers::SlotData<bool()>(21, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'dither'
        QtMocHelpers::SlotData<bool()>(22, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'guide'
        QtMocHelpers::SlotData<bool()>(23, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'loop'
        QtMocHelpers::SlotData<void()>(24, 19, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reloadAIWeights'
        QtMocHelpers::SlotData<void()>(25, 19, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resume'
        QtMocHelpers::SlotData<bool()>(26, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAutoStarEnabled'
        QtMocHelpers::SlotData<void(bool)>(27, 19, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 28 },
        }}),
        // Slot 'setDarkFrameEnabled'
        QtMocHelpers::SlotData<void(bool)>(29, 19, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 28 },
        }}),
        // Slot 'setGuiderType'
        QtMocHelpers::SlotData<bool(int)>(30, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'setSubFrameEnabled'
        QtMocHelpers::SlotData<void(bool)>(32, 19, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 28 },
        }}),
        // Slot 'suspend'
        QtMocHelpers::SlotData<bool()>(33, 6, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'axisDelta'
        QtMocHelpers::PropertyData<QList<double>>(34, 0x80000000 | 35, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'axisSigma'
        QtMocHelpers::PropertyData<QList<double>>(36, 0x80000000 | 35, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'camera'
        QtMocHelpers::PropertyData<QString>(37, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'exposure'
        QtMocHelpers::PropertyData<double>(38, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'guider'
        QtMocHelpers::PropertyData<QString>(39, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'logText'
        QtMocHelpers::PropertyData<QStringList>(40, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'opticalTrain'
        QtMocHelpers::PropertyData<QString>(41, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'status'
        QtMocHelpers::PropertyData<int>(14, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<GuideAdaptor, qt_meta_tag_ZN12GuideAdaptorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject GuideAdaptor::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractAdaptor::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12GuideAdaptorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12GuideAdaptorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12GuideAdaptorE_t>.metaTypes,
    nullptr
} };

void GuideAdaptor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<GuideAdaptor *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->newAxisDelta((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 1: _t->newAxisSigma((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 2: _t->newLog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->newStatus((*reinterpret_cast<std::add_pointer_t<Ekos::GuideState>>(_a[1]))); break;
        case 4: { bool _r = _t->abort();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 5: { bool _r = _t->calibrate();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 6: { bool _r = _t->capture();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->clearCalibration(); break;
        case 8: { bool _r = _t->connectGuider();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 9: { bool _r = _t->disconnectGuider();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 10: { bool _r = _t->dither();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 11: { bool _r = _t->guide();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 12: _t->loop(); break;
        case 13: _t->reloadAIWeights(); break;
        case 14: { bool _r = _t->resume();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 15: _t->setAutoStarEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->setDarkFrameEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: { bool _r = _t->setGuiderType((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 18: _t->setSubFrameEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: { bool _r = _t->suspend();
            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 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::GuideState >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (GuideAdaptor::*)(double , double )>(_a, &GuideAdaptor::newAxisDelta, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (GuideAdaptor::*)(double , double )>(_a, &GuideAdaptor::newAxisSigma, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (GuideAdaptor::*)(const QString & )>(_a, &GuideAdaptor::newLog, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (GuideAdaptor::*)(Ekos::GuideState )>(_a, &GuideAdaptor::newStatus, 3))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QList<double>*>(_v) = _t->axisDelta(); break;
        case 1: *reinterpret_cast<QList<double>*>(_v) = _t->axisSigma(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->camera(); break;
        case 3: *reinterpret_cast<double*>(_v) = _t->exposure(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->guider(); break;
        case 5: *reinterpret_cast<QStringList*>(_v) = _t->logText(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->opticalTrain(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->status(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 3: _t->setExposure(*reinterpret_cast<double*>(_v)); break;
        case 6: _t->setOpticalTrain(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

int GuideAdaptor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractAdaptor::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 20)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 20;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 20)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 20;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void GuideAdaptor::newAxisDelta(double _t1, double _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void GuideAdaptor::newAxisSigma(double _t1, double _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void GuideAdaptor::newLog(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void GuideAdaptor::newStatus(Ekos::GuideState _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
QT_WARNING_POP
