/****************************************************************************
** Meta object code from reading C++ file 'devicemanagerdbus.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 "../../../../../../../dde-file-manager/src/plugins/daemon/core/devicemanagerdbus.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 'devicemanagerdbus.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_ZN17DeviceManagerDBusE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceManagerDBus::qt_create_metaobjectdata<qt_meta_tag_ZN17DeviceManagerDBusE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceManagerDBus",
        "D-Bus Interface",
        "org.deepin.Filemanager.Daemon.DeviceManager",
        "SizeUsedChanged",
        "",
        "id",
        "total",
        "free",
        "NotifyDeviceBusy",
        "action",
        "BlockDriveAdded",
        "BlockDriveRemoved",
        "BlockDeviceAdded",
        "BlockDeviceRemoved",
        "oldMpt",
        "BlockDeviceFilesystemAdded",
        "BlockDeviceFilesystemRemoved",
        "BlockDeviceMounted",
        "mountPoint",
        "BlockDeviceUnmounted",
        "BlockDevicePropertyChanged",
        "property",
        "QDBusVariant",
        "value",
        "BlockDeviceUnlocked",
        "clearDeviceId",
        "BlockDeviceLocked",
        "ProtocolDeviceAdded",
        "ProtocolDeviceRemoved",
        "ProtocolDeviceMounted",
        "ProtocolDeviceUnmounted",
        "IsMonotorWorking",
        "DetachBlockDevice",
        "DetachProtocolDevice",
        "DetachAllMountedDevices",
        "GetBlockDevicesIdList",
        "opts",
        "QueryBlockDeviceInfo",
        "QVariantMap",
        "reload",
        "GetProtocolDevicesIdList",
        "QueryProtocolDeviceInfo"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'SizeUsedChanged'
        QtMocHelpers::SignalData<void(QString, qint64, qint64)>(3, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::LongLong, 6 }, { QMetaType::LongLong, 7 },
        }}),
        // Signal 'NotifyDeviceBusy'
        QtMocHelpers::SignalData<void(QString, QString)>(8, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 9 },
        }}),
        // Signal 'BlockDriveAdded'
        QtMocHelpers::SignalData<void()>(10, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'BlockDriveRemoved'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'BlockDeviceAdded'
        QtMocHelpers::SignalData<void(QString)>(12, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'BlockDeviceRemoved'
        QtMocHelpers::SignalData<void(QString, const QString &)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 14 },
        }}),
        // Signal 'BlockDeviceFilesystemAdded'
        QtMocHelpers::SignalData<void(QString)>(15, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'BlockDeviceFilesystemRemoved'
        QtMocHelpers::SignalData<void(QString)>(16, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'BlockDeviceMounted'
        QtMocHelpers::SignalData<void(QString, QString)>(17, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 18 },
        }}),
        // Signal 'BlockDeviceUnmounted'
        QtMocHelpers::SignalData<void(QString, const QString &)>(19, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 14 },
        }}),
        // Signal 'BlockDevicePropertyChanged'
        QtMocHelpers::SignalData<void(QString, QString, QDBusVariant)>(20, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 21 }, { 0x80000000 | 22, 23 },
        }}),
        // Signal 'BlockDeviceUnlocked'
        QtMocHelpers::SignalData<void(QString, QString)>(24, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 25 },
        }}),
        // Signal 'BlockDeviceLocked'
        QtMocHelpers::SignalData<void(QString)>(26, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'ProtocolDeviceAdded'
        QtMocHelpers::SignalData<void(QString)>(27, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'ProtocolDeviceRemoved'
        QtMocHelpers::SignalData<void(QString, const QString &)>(28, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 14 },
        }}),
        // Signal 'ProtocolDeviceMounted'
        QtMocHelpers::SignalData<void(QString, QString)>(29, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 18 },
        }}),
        // Signal 'ProtocolDeviceUnmounted'
        QtMocHelpers::SignalData<void(QString, const QString &)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::QString, 14 },
        }}),
        // Slot 'IsMonotorWorking'
        QtMocHelpers::SlotData<bool()>(31, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'DetachBlockDevice'
        QtMocHelpers::SlotData<void(QString)>(32, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'DetachProtocolDevice'
        QtMocHelpers::SlotData<void(QString)>(33, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'DetachAllMountedDevices'
        QtMocHelpers::SlotData<void()>(34, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'GetBlockDevicesIdList'
        QtMocHelpers::SlotData<QStringList(int)>(35, 4, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::Int, 36 },
        }}),
        // Slot 'QueryBlockDeviceInfo'
        QtMocHelpers::SlotData<QVariantMap(QString, bool)>(37, 4, QMC::AccessPublic, 0x80000000 | 38, {{
            { QMetaType::QString, 5 }, { QMetaType::Bool, 39 },
        }}),
        // Slot 'GetProtocolDevicesIdList'
        QtMocHelpers::SlotData<QStringList()>(40, 4, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'QueryProtocolDeviceInfo'
        QtMocHelpers::SlotData<QVariantMap(QString, bool)>(41, 4, QMC::AccessPublic, 0x80000000 | 38, {{
            { QMetaType::QString, 5 }, { QMetaType::Bool, 39 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<DeviceManagerDBus, qt_meta_tag_ZN17DeviceManagerDBusE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DeviceManagerDBus::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17DeviceManagerDBusE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17DeviceManagerDBusE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17DeviceManagerDBusE_t>.metaTypes,
    nullptr
} };

void DeviceManagerDBus::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DeviceManagerDBus *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->SizeUsedChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[3]))); break;
        case 1: _t->NotifyDeviceBusy((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 2: _t->BlockDriveAdded(); break;
        case 3: _t->BlockDriveRemoved(); break;
        case 4: _t->BlockDeviceAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->BlockDeviceRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 6: _t->BlockDeviceFilesystemAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->BlockDeviceFilesystemRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: _t->BlockDeviceMounted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 9: _t->BlockDeviceUnmounted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 10: _t->BlockDevicePropertyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QDBusVariant>>(_a[3]))); break;
        case 11: _t->BlockDeviceUnlocked((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 12: _t->BlockDeviceLocked((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: _t->ProtocolDeviceAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->ProtocolDeviceRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 15: _t->ProtocolDeviceMounted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 16: _t->ProtocolDeviceUnmounted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 17: { bool _r = _t->IsMonotorWorking();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 18: _t->DetachBlockDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->DetachProtocolDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->DetachAllMountedDevices(); break;
        case 21: { QStringList _r = _t->GetBlockDevicesIdList((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 22: { QVariantMap _r = _t->QueryBlockDeviceInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 23: { QStringList _r = _t->GetProtocolDevicesIdList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 24: { QVariantMap _r = _t->QueryProtocolDeviceInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusVariant >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , qint64 , qint64 )>(_a, &DeviceManagerDBus::SizeUsedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , QString )>(_a, &DeviceManagerDBus::NotifyDeviceBusy, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)()>(_a, &DeviceManagerDBus::BlockDriveAdded, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)()>(_a, &DeviceManagerDBus::BlockDriveRemoved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString )>(_a, &DeviceManagerDBus::BlockDeviceAdded, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , const QString & )>(_a, &DeviceManagerDBus::BlockDeviceRemoved, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString )>(_a, &DeviceManagerDBus::BlockDeviceFilesystemAdded, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString )>(_a, &DeviceManagerDBus::BlockDeviceFilesystemRemoved, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , QString )>(_a, &DeviceManagerDBus::BlockDeviceMounted, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , const QString & )>(_a, &DeviceManagerDBus::BlockDeviceUnmounted, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , QString , QDBusVariant )>(_a, &DeviceManagerDBus::BlockDevicePropertyChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , QString )>(_a, &DeviceManagerDBus::BlockDeviceUnlocked, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString )>(_a, &DeviceManagerDBus::BlockDeviceLocked, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString )>(_a, &DeviceManagerDBus::ProtocolDeviceAdded, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , const QString & )>(_a, &DeviceManagerDBus::ProtocolDeviceRemoved, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , QString )>(_a, &DeviceManagerDBus::ProtocolDeviceMounted, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceManagerDBus::*)(QString , const QString & )>(_a, &DeviceManagerDBus::ProtocolDeviceUnmounted, 16))
            return;
    }
}

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

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

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

// SIGNAL 0
void DeviceManagerDBus::SizeUsedChanged(QString _t1, qint64 _t2, qint64 _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2, _t3);
}

// SIGNAL 1
void DeviceManagerDBus::NotifyDeviceBusy(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void DeviceManagerDBus::BlockDriveAdded()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void DeviceManagerDBus::BlockDriveRemoved()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void DeviceManagerDBus::BlockDeviceAdded(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void DeviceManagerDBus::BlockDeviceRemoved(QString _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void DeviceManagerDBus::BlockDeviceFilesystemAdded(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void DeviceManagerDBus::BlockDeviceFilesystemRemoved(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void DeviceManagerDBus::BlockDeviceMounted(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2);
}

// SIGNAL 9
void DeviceManagerDBus::BlockDeviceUnmounted(QString _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2);
}

// SIGNAL 10
void DeviceManagerDBus::BlockDevicePropertyChanged(QString _t1, QString _t2, QDBusVariant _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3);
}

// SIGNAL 11
void DeviceManagerDBus::BlockDeviceUnlocked(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void DeviceManagerDBus::BlockDeviceLocked(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void DeviceManagerDBus::ProtocolDeviceAdded(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void DeviceManagerDBus::ProtocolDeviceRemoved(QString _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1, _t2);
}

// SIGNAL 15
void DeviceManagerDBus::ProtocolDeviceMounted(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void DeviceManagerDBus::ProtocolDeviceUnmounted(QString _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2);
}
QT_WARNING_POP
