/****************************************************************************
** Meta object code from reading C++ file 'performancestats.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.0)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../rpi-imager/src/performancestats.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 'performancestats.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. 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_ZN16PerformanceStatsE_t {};
} // unnamed namespace

template <> constexpr inline auto PerformanceStats::qt_create_metaobjectdata<qt_meta_tag_ZN16PerformanceStatsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PerformanceStats",
        "EventType",
        "OsListFetch",
        "OsListParse",
        "SublistFetch",
        "NetworkLatency",
        "NetworkRetry",
        "NetworkConnectionStats",
        "DriveListPoll",
        "DriveOpen",
        "DriveAuthorization",
        "DriveMbrZeroing",
        "DirectIOAttempt",
        "DriveUnmount",
        "DriveUnmountVolumes",
        "DriveDiskClean",
        "DriveRescan",
        "DriveFormat",
        "CacheLookup",
        "CacheVerification",
        "CacheWrite",
        "CacheFlush",
        "MemoryAllocation",
        "BufferResize",
        "PeriodicSync",
        "RingBufferStarvation",
        "ImageDecompressInit",
        "ImageExtraction",
        "HashComputation",
        "PipelineDecompressionTime",
        "PipelineWriteWaitTime",
        "PipelineRingBufferWaitTime",
        "WriteRingBufferStats",
        "WriteTimingBreakdown",
        "WriteSizeDistribution",
        "WriteAfterSyncImpact",
        "AsyncIOConfig",
        "AsyncIOTiming",
        "CycleStart",
        "CycleEnd",
        "ProgressStall",
        "MemoryAllocationFailure",
        "DeviceIOTimeout",
        "QueueDepthReduction",
        "SyncFallbackActivated",
        "DrainAndHotSwap",
        "WatchdogRecovery",
        "Customisation",
        "CloudInitGeneration",
        "FirstRunGeneration",
        "SecureBootSetup",
        "PartitionTableWrite",
        "FatPartitionSetup",
        "FinalSync",
        "DeviceClose",
        "FileDialogOpen",
        "RpibootFirmwareSetup",
        "RpibootProtocol",
        "RpibootFastbootWait",
        "FastbootDeviceOpen",
        "_Count",
        "Phase",
        "Idle",
        "Downloading",
        "Decompressing",
        "Writing",
        "Verifying",
        "Finalising",
        "SessionState",
        "NeverStarted",
        "InProgress",
        "Succeeded",
        "Failed",
        "Cancelled"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'EventType'
        QtMocHelpers::EnumData<enum EventType>(1, 1, QMC::EnumIsScoped).add({
            {    2, EventType::OsListFetch },
            {    3, EventType::OsListParse },
            {    4, EventType::SublistFetch },
            {    5, EventType::NetworkLatency },
            {    6, EventType::NetworkRetry },
            {    7, EventType::NetworkConnectionStats },
            {    8, EventType::DriveListPoll },
            {    9, EventType::DriveOpen },
            {   10, EventType::DriveAuthorization },
            {   11, EventType::DriveMbrZeroing },
            {   12, EventType::DirectIOAttempt },
            {   13, EventType::DriveUnmount },
            {   14, EventType::DriveUnmountVolumes },
            {   15, EventType::DriveDiskClean },
            {   16, EventType::DriveRescan },
            {   17, EventType::DriveFormat },
            {   18, EventType::CacheLookup },
            {   19, EventType::CacheVerification },
            {   20, EventType::CacheWrite },
            {   21, EventType::CacheFlush },
            {   22, EventType::MemoryAllocation },
            {   23, EventType::BufferResize },
            {   24, EventType::PeriodicSync },
            {   25, EventType::RingBufferStarvation },
            {   26, EventType::ImageDecompressInit },
            {   27, EventType::ImageExtraction },
            {   28, EventType::HashComputation },
            {   29, EventType::PipelineDecompressionTime },
            {   30, EventType::PipelineWriteWaitTime },
            {   31, EventType::PipelineRingBufferWaitTime },
            {   32, EventType::WriteRingBufferStats },
            {   33, EventType::WriteTimingBreakdown },
            {   34, EventType::WriteSizeDistribution },
            {   35, EventType::WriteAfterSyncImpact },
            {   36, EventType::AsyncIOConfig },
            {   37, EventType::AsyncIOTiming },
            {   38, EventType::CycleStart },
            {   39, EventType::CycleEnd },
            {   40, EventType::ProgressStall },
            {   41, EventType::MemoryAllocationFailure },
            {   42, EventType::DeviceIOTimeout },
            {   43, EventType::QueueDepthReduction },
            {   44, EventType::SyncFallbackActivated },
            {   45, EventType::DrainAndHotSwap },
            {   46, EventType::WatchdogRecovery },
            {   47, EventType::Customisation },
            {   48, EventType::CloudInitGeneration },
            {   49, EventType::FirstRunGeneration },
            {   50, EventType::SecureBootSetup },
            {   51, EventType::PartitionTableWrite },
            {   52, EventType::FatPartitionSetup },
            {   53, EventType::FinalSync },
            {   54, EventType::DeviceClose },
            {   55, EventType::FileDialogOpen },
            {   56, EventType::RpibootFirmwareSetup },
            {   57, EventType::RpibootProtocol },
            {   58, EventType::RpibootFastbootWait },
            {   59, EventType::FastbootDeviceOpen },
            {   60, EventType::_Count },
        }),
        // enum 'Phase'
        QtMocHelpers::EnumData<enum Phase>(61, 61, QMC::EnumIsScoped).add({
            {   62, Phase::Idle },
            {   63, Phase::Downloading },
            {   64, Phase::Decompressing },
            {   65, Phase::Writing },
            {   66, Phase::Verifying },
            {   67, Phase::Finalising },
        }),
        // enum 'SessionState'
        QtMocHelpers::EnumData<enum SessionState>(68, 68, QMC::EnumIsScoped).add({
            {   69, SessionState::NeverStarted },
            {   70, SessionState::InProgress },
            {   71, SessionState::Succeeded },
            {   72, SessionState::Failed },
            {   73, SessionState::Cancelled },
        }),
    };
    return QtMocHelpers::metaObjectData<PerformanceStats, qt_meta_tag_ZN16PerformanceStatsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject PerformanceStats::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16PerformanceStatsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16PerformanceStatsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16PerformanceStatsE_t>.metaTypes,
    nullptr
} };

void PerformanceStats::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PerformanceStats *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

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

int PerformanceStats::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
