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

template <> constexpr inline auto DeviceUtils::qt_create_metaobjectdata<qt_meta_tag_ZN11DeviceUtilsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceUtils",
        "BluetoothMode",
        "DEVICE_BLE_UNKNOWN",
        "DEVICE_BLE_CONNECTION",
        "DEVICE_BLE_ADVERTISEMENT",
        "BluetoothAdvertisementMode",
        "BLE_ADV_SERVICEDATA",
        "BLE_ADV_MANUFACTURERDATA",
        "DeviceType",
        "DEVICE_UNKNOWN",
        "DEVICE_PLANTSENSOR",
        "DEVICE_THERMOMETER",
        "DEVICE_ENVIRONMENTAL",
        "DEVICE_LIGHT",
        "DEVICE_BEACON",
        "DEVICE_REMOTE",
        "DEVICE_PBP",
        "DEVICE_PGP",
        "DeviceCapabilities",
        "DEVICE_REALTIME",
        "DEVICE_HISTORY",
        "DEVICE_BATTERY",
        "DEVICE_CLOCK",
        "DEVICE_LED_STATUS",
        "DEVICE_LED_RGB",
        "DEVICE_BUTTONS",
        "DEVICE_LAST_MOVE",
        "DEVICE_WATER_TANK",
        "DEVICE_CALIBRATION",
        "DEVICE_REBOOT",
        "DeviceSensors",
        "SENSOR_SOIL_MOISTURE",
        "SENSOR_SOIL_CONDUCTIVITY",
        "SENSOR_SOIL_TEMPERATURE",
        "SENSOR_SOIL_PH",
        "SENSOR_TEMPERATURE",
        "SENSOR_HUMIDITY",
        "SENSOR_PRESSURE",
        "SENSOR_LUMINOSITY",
        "SENSOR_UV",
        "SENSOR_SOUND",
        "SENSOR_WATER_LEVEL",
        "SENSOR_WIND_DIRECTION",
        "SENSOR_WIND_SPEED",
        "SENSOR_PM1",
        "SENSOR_PM25",
        "SENSOR_PM10",
        "SENSOR_O2",
        "SENSOR_O3",
        "SENSOR_CO",
        "SENSOR_CO2",
        "SENSOR_eCO2",
        "SENSOR_NO2",
        "SENSOR_SO2",
        "SENSOR_VOC",
        "SENSOR_HCHO",
        "SENSOR_GEIGER",
        "DeviceStatus",
        "DEVICE_OFFLINE",
        "DEVICE_AVAILABLE",
        "DEVICE_DISCONNECTING",
        "DEVICE_CONNECTING",
        "DEVICE_CONNECTED",
        "DEVICE_WORKING",
        "DEVICE_UPDATING",
        "DEVICE_UPDATING_REALTIME",
        "DEVICE_UPDATING_HISTORY",
        "DeviceActions",
        "ACTION_IDLE",
        "ACTION_CONNECT",
        "ACTION_RECONNECT",
        "ACTION_DISCONNECT",
        "ACTION_DISCONNECT_FORNOW",
        "ACTION_SCAN",
        "ACTION_SCAN_WITH_VALUES",
        "ACTION_SCAN_WITHOUT_VALUES",
        "ACTION_REBOOT",
        "ACTION_SHUTDOWN",
        "ACTION_FACTORYRESET",
        "ACTION_UPDATE",
        "ACTION_UPDATE_REALTIME",
        "ACTION_UPDATE_HISTORY"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'BluetoothMode'
        QtMocHelpers::EnumData<enum BluetoothMode>(1, 1, QMC::EnumFlags{}).add({
            {    2, BluetoothMode::DEVICE_BLE_UNKNOWN },
            {    3, BluetoothMode::DEVICE_BLE_CONNECTION },
            {    4, BluetoothMode::DEVICE_BLE_ADVERTISEMENT },
        }),
        // enum 'BluetoothAdvertisementMode'
        QtMocHelpers::EnumData<enum BluetoothAdvertisementMode>(5, 5, QMC::EnumFlags{}).add({
            {    6, BluetoothAdvertisementMode::BLE_ADV_SERVICEDATA },
            {    7, BluetoothAdvertisementMode::BLE_ADV_MANUFACTURERDATA },
        }),
        // enum 'DeviceType'
        QtMocHelpers::EnumData<enum DeviceType>(8, 8, QMC::EnumFlags{}).add({
            {    9, DeviceType::DEVICE_UNKNOWN },
            {   10, DeviceType::DEVICE_PLANTSENSOR },
            {   11, DeviceType::DEVICE_THERMOMETER },
            {   12, DeviceType::DEVICE_ENVIRONMENTAL },
            {   13, DeviceType::DEVICE_LIGHT },
            {   14, DeviceType::DEVICE_BEACON },
            {   15, DeviceType::DEVICE_REMOTE },
            {   16, DeviceType::DEVICE_PBP },
            {   17, DeviceType::DEVICE_PGP },
        }),
        // enum 'DeviceCapabilities'
        QtMocHelpers::EnumData<enum DeviceCapabilities>(18, 18, QMC::EnumFlags{}).add({
            {   19, DeviceCapabilities::DEVICE_REALTIME },
            {   20, DeviceCapabilities::DEVICE_HISTORY },
            {   21, DeviceCapabilities::DEVICE_BATTERY },
            {   22, DeviceCapabilities::DEVICE_CLOCK },
            {   23, DeviceCapabilities::DEVICE_LED_STATUS },
            {   24, DeviceCapabilities::DEVICE_LED_RGB },
            {   25, DeviceCapabilities::DEVICE_BUTTONS },
            {   26, DeviceCapabilities::DEVICE_LAST_MOVE },
            {   27, DeviceCapabilities::DEVICE_WATER_TANK },
            {   28, DeviceCapabilities::DEVICE_CALIBRATION },
            {   29, DeviceCapabilities::DEVICE_REBOOT },
        }),
        // enum 'DeviceSensors'
        QtMocHelpers::EnumData<enum DeviceSensors>(30, 30, QMC::EnumFlags{}).add({
            {   31, DeviceSensors::SENSOR_SOIL_MOISTURE },
            {   32, DeviceSensors::SENSOR_SOIL_CONDUCTIVITY },
            {   33, DeviceSensors::SENSOR_SOIL_TEMPERATURE },
            {   34, DeviceSensors::SENSOR_SOIL_PH },
            {   35, DeviceSensors::SENSOR_TEMPERATURE },
            {   36, DeviceSensors::SENSOR_HUMIDITY },
            {   37, DeviceSensors::SENSOR_PRESSURE },
            {   38, DeviceSensors::SENSOR_LUMINOSITY },
            {   39, DeviceSensors::SENSOR_UV },
            {   40, DeviceSensors::SENSOR_SOUND },
            {   41, DeviceSensors::SENSOR_WATER_LEVEL },
            {   42, DeviceSensors::SENSOR_WIND_DIRECTION },
            {   43, DeviceSensors::SENSOR_WIND_SPEED },
            {   44, DeviceSensors::SENSOR_PM1 },
            {   45, DeviceSensors::SENSOR_PM25 },
            {   46, DeviceSensors::SENSOR_PM10 },
            {   47, DeviceSensors::SENSOR_O2 },
            {   48, DeviceSensors::SENSOR_O3 },
            {   49, DeviceSensors::SENSOR_CO },
            {   50, DeviceSensors::SENSOR_CO2 },
            {   51, DeviceSensors::SENSOR_eCO2 },
            {   52, DeviceSensors::SENSOR_NO2 },
            {   53, DeviceSensors::SENSOR_SO2 },
            {   54, DeviceSensors::SENSOR_VOC },
            {   55, DeviceSensors::SENSOR_HCHO },
            {   56, DeviceSensors::SENSOR_GEIGER },
        }),
        // enum 'DeviceStatus'
        QtMocHelpers::EnumData<enum DeviceStatus>(57, 57, QMC::EnumFlags{}).add({
            {   58, DeviceStatus::DEVICE_OFFLINE },
            {   59, DeviceStatus::DEVICE_AVAILABLE },
            {   60, DeviceStatus::DEVICE_DISCONNECTING },
            {   61, DeviceStatus::DEVICE_CONNECTING },
            {   62, DeviceStatus::DEVICE_CONNECTED },
            {   63, DeviceStatus::DEVICE_WORKING },
            {   64, DeviceStatus::DEVICE_UPDATING },
            {   65, DeviceStatus::DEVICE_UPDATING_REALTIME },
            {   66, DeviceStatus::DEVICE_UPDATING_HISTORY },
        }),
        // enum 'DeviceActions'
        QtMocHelpers::EnumData<enum DeviceActions>(67, 67, QMC::EnumFlags{}).add({
            {   68, DeviceActions::ACTION_IDLE },
            {   69, DeviceActions::ACTION_CONNECT },
            {   70, DeviceActions::ACTION_RECONNECT },
            {   71, DeviceActions::ACTION_DISCONNECT },
            {   72, DeviceActions::ACTION_DISCONNECT_FORNOW },
            {   73, DeviceActions::ACTION_SCAN },
            {   74, DeviceActions::ACTION_SCAN_WITH_VALUES },
            {   75, DeviceActions::ACTION_SCAN_WITHOUT_VALUES },
            {   76, DeviceActions::ACTION_REBOOT },
            {   77, DeviceActions::ACTION_SHUTDOWN },
            {   78, DeviceActions::ACTION_FACTORYRESET },
            {   79, DeviceActions::ACTION_UPDATE },
            {   80, DeviceActions::ACTION_UPDATE_REALTIME },
            {   81, DeviceActions::ACTION_UPDATE_HISTORY },
        }),
    };
    return QtMocHelpers::metaObjectData<DeviceUtils, qt_meta_tag_ZN11DeviceUtilsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DeviceUtils::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11DeviceUtilsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11DeviceUtilsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11DeviceUtilsE_t>.metaTypes,
    nullptr
} };

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

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

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

int DeviceUtils::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN8LogEventE_t {};
} // unnamed namespace

template <> constexpr inline auto LogEvent::qt_create_metaobjectdata<qt_meta_tag_ZN8LogEventE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LogEvent",
        "timestamp",
        "event",
        "log",
        "EventType",
        "UNKNOWN",
        "ERROR",
        "CONN",
        "STATE",
        "DATA",
        "ADV",
        "USER"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'timestamp'
        QtMocHelpers::PropertyData<QDateTime>(1, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'event'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'log'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'EventType'
        QtMocHelpers::EnumData<enum EventType>(4, 4, QMC::EnumFlags{}).add({
            {    5, EventType::UNKNOWN },
            {    6, EventType::ERROR },
            {    7, EventType::CONN },
            {    8, EventType::STATE },
            {    9, EventType::DATA },
            {   10, EventType::ADV },
            {   11, EventType::USER },
        }),
    };
    return QtMocHelpers::metaObjectData<LogEvent, qt_meta_tag_ZN8LogEventE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LogEvent::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8LogEventE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8LogEventE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8LogEventE_t>.metaTypes,
    nullptr
} };

void LogEvent::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LogEvent *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDateTime*>(_v) = _t->getTimestamp(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->getEvent(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->getLog(); break;
        default: break;
        }
    }
}

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

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

int LogEvent::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN16ChartDataHistoryE_t {};
} // unnamed namespace

template <> constexpr inline auto ChartDataHistory::qt_create_metaobjectdata<qt_meta_tag_ZN16ChartDataHistoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ChartDataHistory",
        "today",
        "day",
        "hour",
        "datetime",
        "soilMoisture",
        "soilConductivity",
        "soilTemperature",
        "soilPH",
        "temperature",
        "humidity",
        "luminosityLux",
        "luminosityMmol",
        "temperatureMax",
        "luminosityLuxMax"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'today'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'day'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hour'
        QtMocHelpers::PropertyData<int>(3, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'datetime'
        QtMocHelpers::PropertyData<QDateTime>(4, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'soilMoisture'
        QtMocHelpers::PropertyData<float>(5, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'soilConductivity'
        QtMocHelpers::PropertyData<float>(6, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'soilTemperature'
        QtMocHelpers::PropertyData<float>(7, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'soilPH'
        QtMocHelpers::PropertyData<float>(8, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'temperature'
        QtMocHelpers::PropertyData<float>(9, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'humidity'
        QtMocHelpers::PropertyData<float>(10, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'luminosityLux'
        QtMocHelpers::PropertyData<float>(11, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'luminosityMmol'
        QtMocHelpers::PropertyData<float>(12, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'temperatureMax'
        QtMocHelpers::PropertyData<float>(13, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'luminosityLuxMax'
        QtMocHelpers::PropertyData<float>(14, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ChartDataHistory, qt_meta_tag_ZN16ChartDataHistoryE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ChartDataHistory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ChartDataHistoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ChartDataHistoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16ChartDataHistoryE_t>.metaTypes,
    nullptr
} };

void ChartDataHistory::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ChartDataHistory *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isToday(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->getDay(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getHour(); break;
        case 3: *reinterpret_cast<QDateTime*>(_v) = _t->getDateTime(); break;
        case 4: *reinterpret_cast<float*>(_v) = _t->getSoilMoisture(); break;
        case 5: *reinterpret_cast<float*>(_v) = _t->getSoilCondu(); break;
        case 6: *reinterpret_cast<float*>(_v) = _t->getSoilTemperature(); break;
        case 7: *reinterpret_cast<float*>(_v) = _t->getSoilPH(); break;
        case 8: *reinterpret_cast<float*>(_v) = _t->getTemperature(); break;
        case 9: *reinterpret_cast<float*>(_v) = _t->getHumidity(); break;
        case 10: *reinterpret_cast<float*>(_v) = _t->getLuminosityLux(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->getLuminosityMmol(); break;
        case 12: *reinterpret_cast<float*>(_v) = _t->getTemperatureMax(); break;
        case 13: *reinterpret_cast<float*>(_v) = _t->getLuminosityLuxMax(); break;
        default: break;
        }
    }
}

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

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

int ChartDataHistory::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 14;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN15ChartDataMinMaxE_t {};
} // unnamed namespace

template <> constexpr inline auto ChartDataMinMax::qt_create_metaobjectdata<qt_meta_tag_ZN15ChartDataMinMaxE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ChartDataMinMax",
        "today",
        "day",
        "hour",
        "datetime",
        "tempMin",
        "tempMean",
        "tempMax",
        "hygroMin",
        "hygroMax"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'today'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'day'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hour'
        QtMocHelpers::PropertyData<int>(3, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'datetime'
        QtMocHelpers::PropertyData<QDateTime>(4, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'tempMin'
        QtMocHelpers::PropertyData<float>(5, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'tempMean'
        QtMocHelpers::PropertyData<float>(6, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'tempMax'
        QtMocHelpers::PropertyData<float>(7, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hygroMin'
        QtMocHelpers::PropertyData<int>(8, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hygroMax'
        QtMocHelpers::PropertyData<int>(9, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ChartDataMinMax, qt_meta_tag_ZN15ChartDataMinMaxE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ChartDataMinMax::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ChartDataMinMaxE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15ChartDataMinMaxE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15ChartDataMinMaxE_t>.metaTypes,
    nullptr
} };

void ChartDataMinMax::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ChartDataMinMax *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isToday(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->getDay(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getHour(); break;
        case 3: *reinterpret_cast<QDateTime*>(_v) = _t->getDateTime(); break;
        case 4: *reinterpret_cast<float*>(_v) = _t->getTempMin(); break;
        case 5: *reinterpret_cast<float*>(_v) = _t->getTempMean(); break;
        case 6: *reinterpret_cast<float*>(_v) = _t->getTempMax(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->getHygroMin(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->getHygroMax(); break;
        default: break;
        }
    }
}

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

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

int ChartDataMinMax::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN12ChartDataEnvE_t {};
} // unnamed namespace

template <> constexpr inline auto ChartDataEnv::qt_create_metaobjectdata<qt_meta_tag_ZN12ChartDataEnvE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ChartDataEnv",
        "today",
        "day",
        "hour",
        "datetime",
        "vocMin",
        "vocMean",
        "vocMax",
        "hchoMin",
        "hchoMean",
        "hchoMax",
        "co2Min",
        "co2Mean",
        "co2Max",
        "pm25Min",
        "pm25Mean",
        "pm25Max",
        "pm10Min",
        "pm10Mean",
        "pm10Max"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'today'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'day'
        QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hour'
        QtMocHelpers::PropertyData<int>(3, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'datetime'
        QtMocHelpers::PropertyData<QDateTime>(4, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'vocMin'
        QtMocHelpers::PropertyData<float>(5, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'vocMean'
        QtMocHelpers::PropertyData<float>(6, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'vocMax'
        QtMocHelpers::PropertyData<float>(7, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hchoMin'
        QtMocHelpers::PropertyData<float>(8, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hchoMean'
        QtMocHelpers::PropertyData<float>(9, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'hchoMax'
        QtMocHelpers::PropertyData<float>(10, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'co2Min'
        QtMocHelpers::PropertyData<float>(11, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'co2Mean'
        QtMocHelpers::PropertyData<float>(12, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'co2Max'
        QtMocHelpers::PropertyData<float>(13, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm25Min'
        QtMocHelpers::PropertyData<float>(14, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm25Mean'
        QtMocHelpers::PropertyData<float>(15, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm25Max'
        QtMocHelpers::PropertyData<float>(16, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm10Min'
        QtMocHelpers::PropertyData<float>(17, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm10Mean'
        QtMocHelpers::PropertyData<float>(18, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'pm10Max'
        QtMocHelpers::PropertyData<float>(19, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ChartDataEnv, qt_meta_tag_ZN12ChartDataEnvE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ChartDataEnv::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ChartDataEnvE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ChartDataEnvE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12ChartDataEnvE_t>.metaTypes,
    nullptr
} };

void ChartDataEnv::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ChartDataEnv *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isToday(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->getDay(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getHour(); break;
        case 3: *reinterpret_cast<QDateTime*>(_v) = _t->getDateTime(); break;
        case 4: *reinterpret_cast<float*>(_v) = _t->getVocMin(); break;
        case 5: *reinterpret_cast<float*>(_v) = _t->getVocMean(); break;
        case 6: *reinterpret_cast<float*>(_v) = _t->getVocMax(); break;
        case 7: *reinterpret_cast<float*>(_v) = _t->getHchoMin(); break;
        case 8: *reinterpret_cast<float*>(_v) = _t->getHchoMean(); break;
        case 9: *reinterpret_cast<float*>(_v) = _t->getHchoMax(); break;
        case 10: *reinterpret_cast<float*>(_v) = _t->getCo2Min(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->getCo2Mean(); break;
        case 12: *reinterpret_cast<float*>(_v) = _t->getCo2Max(); break;
        case 13: *reinterpret_cast<float*>(_v) = _t->getPM25Min(); break;
        case 14: *reinterpret_cast<float*>(_v) = _t->getPM25Mean(); break;
        case 15: *reinterpret_cast<float*>(_v) = _t->getPM25Max(); break;
        case 16: *reinterpret_cast<float*>(_v) = _t->getPM10Min(); break;
        case 17: *reinterpret_cast<float*>(_v) = _t->getPM10Mean(); break;
        case 18: *reinterpret_cast<float*>(_v) = _t->getPM10Max(); break;
        default: break;
        }
    }
}

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

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

int ChartDataEnv::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 19;
    }
    return _id;
}
QT_WARNING_POP
