rustyfit 0.10.0

// Code generated by fitgen/main.go. DO NOT EDIT.

// Copyright 2025 The RustyFIT Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use crate::profile::typedef::{self, FitBaseType};
use crate::proto::*;
use alloc::borrow::ToOwned;
use alloc::string::String;
use alloc::vec::Vec;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize, Serializer, ser::SerializeStruct};

/// Connectivity message.
#[cfg_attr(feature = "serde", derive(Deserialize), serde(from = "De"))]
#[derive(Debug, Clone)]
pub struct Connectivity {
    /// Use Bluetooth for connectivity features
    pub bluetooth_enabled: typedef::Bool,
    /// Use Bluetooth Low Energy for connectivity features
    pub bluetooth_le_enabled: typedef::Bool,
    /// Use ANT for connectivity features
    pub ant_enabled: typedef::Bool,
    pub name: String,
    pub live_tracking_enabled: typedef::Bool,
    pub weather_conditions_enabled: typedef::Bool,
    pub weather_alerts_enabled: typedef::Bool,
    pub auto_activity_upload_enabled: typedef::Bool,
    pub course_download_enabled: typedef::Bool,
    pub workout_download_enabled: typedef::Bool,
    pub gps_ephemeris_download_enabled: typedef::Bool,
    pub incident_detection_enabled: typedef::Bool,
    pub grouptrack_enabled: typedef::Bool,
    /// unknown_fields are fields that are exist but they are not defined in Profile.xlsx
    pub unknown_fields: Vec<Field>,
    /// developer_fields are custom data fields (Added since protocol version 2.0)
    pub developer_fields: Vec<DeveloperField>,
}

impl Connectivity {
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const BLUETOOTH_ENABLED: u8 = 0;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const BLUETOOTH_LE_ENABLED: u8 = 1;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const ANT_ENABLED: u8 = 2;
    /// Value's type: `String`; FitBaseType::STRING; ProfileType::String
    pub const NAME: u8 = 3;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const LIVE_TRACKING_ENABLED: u8 = 4;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const WEATHER_CONDITIONS_ENABLED: u8 = 5;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const WEATHER_ALERTS_ENABLED: u8 = 6;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const AUTO_ACTIVITY_UPLOAD_ENABLED: u8 = 7;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const COURSE_DOWNLOAD_ENABLED: u8 = 8;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const WORKOUT_DOWNLOAD_ENABLED: u8 = 9;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const GPS_EPHEMERIS_DOWNLOAD_ENABLED: u8 = 10;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const INCIDENT_DETECTION_ENABLED: u8 = 11;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const GROUPTRACK_ENABLED: u8 = 12;

    /// Create new Connectivity with all fields being set to its corresponding invalid value.
    pub const fn new() -> Self {
        Self {
            bluetooth_enabled: typedef::Bool(u8::MAX),
            bluetooth_le_enabled: typedef::Bool(u8::MAX),
            ant_enabled: typedef::Bool(u8::MAX),
            name: String::new(),
            live_tracking_enabled: typedef::Bool(u8::MAX),
            weather_conditions_enabled: typedef::Bool(u8::MAX),
            weather_alerts_enabled: typedef::Bool(u8::MAX),
            auto_activity_upload_enabled: typedef::Bool(u8::MAX),
            course_download_enabled: typedef::Bool(u8::MAX),
            workout_download_enabled: typedef::Bool(u8::MAX),
            gps_ephemeris_download_enabled: typedef::Bool(u8::MAX),
            incident_detection_enabled: typedef::Bool(u8::MAX),
            grouptrack_enabled: typedef::Bool(u8::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }

    fn count_valid_fields(&self) -> usize {
        (self.bluetooth_enabled.0 != u8::MAX) as usize
            + (self.bluetooth_le_enabled.0 != u8::MAX) as usize
            + (self.ant_enabled.0 != u8::MAX) as usize
            + (!self.name.is_empty()) as usize
            + (self.live_tracking_enabled.0 != u8::MAX) as usize
            + (self.weather_conditions_enabled.0 != u8::MAX) as usize
            + (self.weather_alerts_enabled.0 != u8::MAX) as usize
            + (self.auto_activity_upload_enabled.0 != u8::MAX) as usize
            + (self.course_download_enabled.0 != u8::MAX) as usize
            + (self.workout_download_enabled.0 != u8::MAX) as usize
            + (self.gps_ephemeris_download_enabled.0 != u8::MAX) as usize
            + (self.incident_detection_enabled.0 != u8::MAX) as usize
            + (self.grouptrack_enabled.0 != u8::MAX) as usize
    }
}

impl Default for Connectivity {
    fn default() -> Self {
        Self::new()
    }
}

impl From<&Message> for Connectivity {
    /// from creates new Connectivity struct based on given mesg.
    fn from(mesg: &Message) -> Self {
        const KNOWN_NUMS: [u64; 4] = [8191, 0, 0, 0];
        let mut n = 0u64;
        for field in &mesg.fields {
            n += (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 ^ 1
        }

        let mut v = Self::new();
        v.unknown_fields = Vec::<Field>::with_capacity(n as usize);
        v.developer_fields = mesg.developer_fields.clone();

        for field in &mesg.fields {
            match field.num {
                0 => v.bluetooth_enabled = typedef::Bool(field.value.as_u8()),
                1 => v.bluetooth_le_enabled = typedef::Bool(field.value.as_u8()),
                2 => v.ant_enabled = typedef::Bool(field.value.as_u8()),
                3 => v.name = field.value.as_str().to_owned(),
                4 => v.live_tracking_enabled = typedef::Bool(field.value.as_u8()),
                5 => v.weather_conditions_enabled = typedef::Bool(field.value.as_u8()),
                6 => v.weather_alerts_enabled = typedef::Bool(field.value.as_u8()),
                7 => v.auto_activity_upload_enabled = typedef::Bool(field.value.as_u8()),
                8 => v.course_download_enabled = typedef::Bool(field.value.as_u8()),
                9 => v.workout_download_enabled = typedef::Bool(field.value.as_u8()),
                10 => v.gps_ephemeris_download_enabled = typedef::Bool(field.value.as_u8()),
                11 => v.incident_detection_enabled = typedef::Bool(field.value.as_u8()),
                12 => v.grouptrack_enabled = typedef::Bool(field.value.as_u8()),
                _ => v.unknown_fields.push(field.clone()),
            };
        }

        v
    }
}

impl From<Connectivity> for Message {
    fn from(m: Connectivity) -> Self {
        let mut fields =
            Vec::<Field>::with_capacity(m.count_valid_fields() + m.unknown_fields.len());

        if m.bluetooth_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 0,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.bluetooth_enabled.0),
                is_expanded: false,
            });
        };
        if m.bluetooth_le_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 1,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.bluetooth_le_enabled.0),
                is_expanded: false,
            });
        };
        if m.ant_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 2,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.ant_enabled.0),
                is_expanded: false,
            });
        };
        if !m.name.is_empty() {
            fields.push(Field {
                num: 3,
                base_type: FitBaseType::STRING,
                value: Value::String(m.name),
                is_expanded: false,
            });
        };
        if m.live_tracking_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 4,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.live_tracking_enabled.0),
                is_expanded: false,
            });
        };
        if m.weather_conditions_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 5,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.weather_conditions_enabled.0),
                is_expanded: false,
            });
        };
        if m.weather_alerts_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 6,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.weather_alerts_enabled.0),
                is_expanded: false,
            });
        };
        if m.auto_activity_upload_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 7,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.auto_activity_upload_enabled.0),
                is_expanded: false,
            });
        };
        if m.course_download_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 8,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.course_download_enabled.0),
                is_expanded: false,
            });
        };
        if m.workout_download_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 9,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.workout_download_enabled.0),
                is_expanded: false,
            });
        };
        if m.gps_ephemeris_download_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 10,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.gps_ephemeris_download_enabled.0),
                is_expanded: false,
            });
        };
        if m.incident_detection_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 11,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.incident_detection_enabled.0),
                is_expanded: false,
            });
        };
        if m.grouptrack_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 12,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.grouptrack_enabled.0),
                is_expanded: false,
            });
        };

        fields.extend_from_slice(&m.unknown_fields);

        Self {
            header: 0,
            num: typedef::MesgNum::CONNECTIVITY,
            fields,
            developer_fields: m.developer_fields,
        }
    }
}

#[cfg(feature = "serde")]
impl Serialize for Connectivity {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let n = self.count_valid_fields() + 2;
        let mut state = serializer.serialize_struct("Connectivity", n)?;
        if self.bluetooth_enabled.0 != u8::MAX {
            state.serialize_field("bluetooth_enabled", &self.bluetooth_enabled)?;
        }
        if self.bluetooth_le_enabled.0 != u8::MAX {
            state.serialize_field("bluetooth_le_enabled", &self.bluetooth_le_enabled)?;
        }
        if self.ant_enabled.0 != u8::MAX {
            state.serialize_field("ant_enabled", &self.ant_enabled)?;
        }
        if !self.name.is_empty() {
            state.serialize_field("name", &self.name)?;
        }
        if self.live_tracking_enabled.0 != u8::MAX {
            state.serialize_field("live_tracking_enabled", &self.live_tracking_enabled)?;
        }
        if self.weather_conditions_enabled.0 != u8::MAX {
            state.serialize_field(
                "weather_conditions_enabled",
                &self.weather_conditions_enabled,
            )?;
        }
        if self.weather_alerts_enabled.0 != u8::MAX {
            state.serialize_field("weather_alerts_enabled", &self.weather_alerts_enabled)?;
        }
        if self.auto_activity_upload_enabled.0 != u8::MAX {
            state.serialize_field(
                "auto_activity_upload_enabled",
                &self.auto_activity_upload_enabled,
            )?;
        }
        if self.course_download_enabled.0 != u8::MAX {
            state.serialize_field("course_download_enabled", &self.course_download_enabled)?;
        }
        if self.workout_download_enabled.0 != u8::MAX {
            state.serialize_field("workout_download_enabled", &self.workout_download_enabled)?;
        }
        if self.gps_ephemeris_download_enabled.0 != u8::MAX {
            state.serialize_field(
                "gps_ephemeris_download_enabled",
                &self.gps_ephemeris_download_enabled,
            )?;
        }
        if self.incident_detection_enabled.0 != u8::MAX {
            state.serialize_field(
                "incident_detection_enabled",
                &self.incident_detection_enabled,
            )?;
        }
        if self.grouptrack_enabled.0 != u8::MAX {
            state.serialize_field("grouptrack_enabled", &self.grouptrack_enabled)?;
        }
        if !self.unknown_fields.is_empty() {
            state.serialize_field("unknown_fields", &self.unknown_fields)?;
        }
        if !self.developer_fields.is_empty() {
            state.serialize_field("developer_fields", &self.developer_fields)?;
        }
        state.end()
    }
}

#[cfg(feature = "serde")]
#[cfg_attr(feature = "serde", derive(Deserialize), serde(default))]
struct De {
    bluetooth_enabled: typedef::Bool,
    bluetooth_le_enabled: typedef::Bool,
    ant_enabled: typedef::Bool,
    name: String,
    live_tracking_enabled: typedef::Bool,
    weather_conditions_enabled: typedef::Bool,
    weather_alerts_enabled: typedef::Bool,
    auto_activity_upload_enabled: typedef::Bool,
    course_download_enabled: typedef::Bool,
    workout_download_enabled: typedef::Bool,
    gps_ephemeris_download_enabled: typedef::Bool,
    incident_detection_enabled: typedef::Bool,
    grouptrack_enabled: typedef::Bool,
    unknown_fields: Vec<Field>,
    developer_fields: Vec<DeveloperField>,
}

#[cfg(feature = "serde")]
impl From<De> for Connectivity {
    fn from(m: De) -> Self {
        Self {
            bluetooth_enabled: m.bluetooth_enabled,
            bluetooth_le_enabled: m.bluetooth_le_enabled,
            ant_enabled: m.ant_enabled,
            name: m.name,
            live_tracking_enabled: m.live_tracking_enabled,
            weather_conditions_enabled: m.weather_conditions_enabled,
            weather_alerts_enabled: m.weather_alerts_enabled,
            auto_activity_upload_enabled: m.auto_activity_upload_enabled,
            course_download_enabled: m.course_download_enabled,
            workout_download_enabled: m.workout_download_enabled,
            gps_ephemeris_download_enabled: m.gps_ephemeris_download_enabled,
            incident_detection_enabled: m.incident_detection_enabled,
            grouptrack_enabled: m.grouptrack_enabled,
            unknown_fields: m.unknown_fields,
            developer_fields: m.developer_fields,
        }
    }
}

#[cfg(feature = "serde")]
impl Default for De {
    fn default() -> Self {
        Self {
            bluetooth_enabled: typedef::Bool(u8::MAX),
            bluetooth_le_enabled: typedef::Bool(u8::MAX),
            ant_enabled: typedef::Bool(u8::MAX),
            name: String::new(),
            live_tracking_enabled: typedef::Bool(u8::MAX),
            weather_conditions_enabled: typedef::Bool(u8::MAX),
            weather_alerts_enabled: typedef::Bool(u8::MAX),
            auto_activity_upload_enabled: typedef::Bool(u8::MAX),
            course_download_enabled: typedef::Bool(u8::MAX),
            workout_download_enabled: typedef::Bool(u8::MAX),
            gps_ephemeris_download_enabled: typedef::Bool(u8::MAX),
            incident_detection_enabled: typedef::Bool(u8::MAX),
            grouptrack_enabled: typedef::Bool(u8::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }
}