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};

/// Dive Settings message.
#[cfg_attr(feature = "serde", derive(Deserialize), serde(from = "De"))]
#[derive(Debug, Clone)]
pub struct DiveSettings {
    pub timestamp: typedef::DateTime,
    pub message_index: typedef::MessageIndex,
    pub name: String,
    pub model: typedef::TissueModelType,
    /// Units: percent
    pub gf_low: u8,
    /// Units: percent
    pub gf_high: u8,
    pub water_type: typedef::WaterType,
    /// Units: kg/m^3; Fresh water is usually 1000; salt water is usually 1025
    pub water_density: f32,
    /// Scale: 100; Units: percent; Typically 1.40
    pub po2_warn: u8,
    /// Scale: 100; Units: percent; Typically 1.60
    pub po2_critical: u8,
    /// Scale: 100; Units: percent
    pub po2_deco: u8,
    pub safety_stop_enabled: typedef::Bool,
    pub bottom_depth: f32,
    pub bottom_time: u32,
    pub apnea_countdown_enabled: typedef::Bool,
    pub apnea_countdown_time: u32,
    pub backlight_mode: typedef::DiveBacklightMode,
    pub backlight_brightness: u8,
    pub backlight_timeout: typedef::BacklightTimeout,
    /// Units: s; Time between surfacing and ending the activity
    pub repeat_dive_interval: u16,
    /// Units: s; Time at safety stop (if enabled)
    pub safety_stop_time: u16,
    pub heart_rate_source_type: typedef::SourceType,
    pub heart_rate_source: u8,
    /// Index of travel dive_gas message
    pub travel_gas: typedef::MessageIndex,
    /// If low PO2 should be switched to automatically
    pub ccr_low_setpoint_switch_mode: typedef::CcrSetpointSwitchMode,
    /// Scale: 100; Units: percent; Target PO2 when using low setpoint
    pub ccr_low_setpoint: u8,
    /// Scale: 1000; Units: m; Depth to switch to low setpoint in automatic mode
    pub ccr_low_setpoint_depth: u32,
    /// If high PO2 should be switched to automatically
    pub ccr_high_setpoint_switch_mode: typedef::CcrSetpointSwitchMode,
    /// Scale: 100; Units: percent; Target PO2 when using high setpoint
    pub ccr_high_setpoint: u8,
    /// Scale: 1000; Units: m; Depth to switch to high setpoint in automatic mode
    pub ccr_high_setpoint_depth: u32,
    /// Type of gas consumption rate to display. Some values are only valid if tank volume is known.
    pub gas_consumption_display: typedef::GasConsumptionRateType,
    /// Indicates whether the up key is enabled during dives
    pub up_key_enabled: typedef::Bool,
    /// Sounds and vibration enabled or disabled in-dive
    pub dive_sounds: typedef::Tone,
    /// Scale: 10; Usually 1.0/1.5/2.0 representing 3/4.5/6m or 10/15/20ft
    pub last_stop_multiple: u8,
    /// Indicates which guidelines to use for no-fly surface interval.
    pub no_fly_time_mode: typedef::NoFlyTimeMode,
    /// 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 DiveSettings {
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::DateTime
    pub const TIMESTAMP: u8 = 253;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::MessageIndex
    pub const MESSAGE_INDEX: u8 = 254;
    /// Value's type: `String`; FitBaseType::STRING; ProfileType::String
    pub const NAME: u8 = 0;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::TissueModelType
    pub const MODEL: u8 = 1;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const GF_LOW: u8 = 2;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Units: `percent`
    pub const GF_HIGH: u8 = 3;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::WaterType
    pub const WATER_TYPE: u8 = 4;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32; Units: `kg/m^3`
    pub const WATER_DENSITY: u8 = 5;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `percent`
    pub const PO2_WARN: u8 = 6;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `percent`
    pub const PO2_CRITICAL: u8 = 7;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `percent`
    pub const PO2_DECO: u8 = 8;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const SAFETY_STOP_ENABLED: u8 = 9;
    /// Value's type: `f32`; FitBaseType::FLOAT32; ProfileType::Float32
    pub const BOTTOM_DEPTH: u8 = 10;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32
    pub const BOTTOM_TIME: u8 = 11;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const APNEA_COUNTDOWN_ENABLED: u8 = 12;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32
    pub const APNEA_COUNTDOWN_TIME: u8 = 13;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::DiveBacklightMode
    pub const BACKLIGHT_MODE: u8 = 14;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const BACKLIGHT_BRIGHTNESS: u8 = 15;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::BacklightTimeout
    pub const BACKLIGHT_TIMEOUT: u8 = 16;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `s`
    pub const REPEAT_DIVE_INTERVAL: u8 = 17;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::Uint16; Units: `s`
    pub const SAFETY_STOP_TIME: u8 = 18;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::SourceType
    pub const HEART_RATE_SOURCE_TYPE: u8 = 19;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8
    pub const HEART_RATE_SOURCE: u8 = 20;
    /// Value's type: `u16`; FitBaseType::UINT16; ProfileType::MessageIndex
    pub const TRAVEL_GAS: u8 = 21;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::CcrSetpointSwitchMode
    pub const CCR_LOW_SETPOINT_SWITCH_MODE: u8 = 22;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `percent`
    pub const CCR_LOW_SETPOINT: u8 = 23;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m`
    pub const CCR_LOW_SETPOINT_DEPTH: u8 = 24;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::CcrSetpointSwitchMode
    pub const CCR_HIGH_SETPOINT_SWITCH_MODE: u8 = 25;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `100`; Units: `percent`
    pub const CCR_HIGH_SETPOINT: u8 = 26;
    /// Value's type: `u32`; FitBaseType::UINT32; ProfileType::Uint32; Scale: `1000`; Units: `m`
    pub const CCR_HIGH_SETPOINT_DEPTH: u8 = 27;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::GasConsumptionRateType
    pub const GAS_CONSUMPTION_DISPLAY: u8 = 29;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Bool
    pub const UP_KEY_ENABLED: u8 = 30;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::Tone
    pub const DIVE_SOUNDS: u8 = 35;
    /// Value's type: `u8`; FitBaseType::UINT8; ProfileType::Uint8; Scale: `10`
    pub const LAST_STOP_MULTIPLE: u8 = 36;
    /// Value's type: `u8`; FitBaseType::ENUM; ProfileType::NoFlyTimeMode
    pub const NO_FLY_TIME_MODE: u8 = 37;

    /// Create new DiveSettings with all fields being set to its corresponding invalid value.
    pub const fn new() -> Self {
        Self {
            timestamp: typedef::DateTime(u32::MAX),
            message_index: typedef::MessageIndex(u16::MAX),
            name: String::new(),
            model: typedef::TissueModelType(u8::MAX),
            gf_low: u8::MAX,
            gf_high: u8::MAX,
            water_type: typedef::WaterType(u8::MAX),
            water_density: f32::from_bits(u32::MAX),
            po2_warn: u8::MAX,
            po2_critical: u8::MAX,
            po2_deco: u8::MAX,
            safety_stop_enabled: typedef::Bool(u8::MAX),
            bottom_depth: f32::from_bits(u32::MAX),
            bottom_time: u32::MAX,
            apnea_countdown_enabled: typedef::Bool(u8::MAX),
            apnea_countdown_time: u32::MAX,
            backlight_mode: typedef::DiveBacklightMode(u8::MAX),
            backlight_brightness: u8::MAX,
            backlight_timeout: typedef::BacklightTimeout(u8::MAX),
            repeat_dive_interval: u16::MAX,
            safety_stop_time: u16::MAX,
            heart_rate_source_type: typedef::SourceType(u8::MAX),
            heart_rate_source: u8::MAX,
            travel_gas: typedef::MessageIndex(u16::MAX),
            ccr_low_setpoint_switch_mode: typedef::CcrSetpointSwitchMode(u8::MAX),
            ccr_low_setpoint: u8::MAX,
            ccr_low_setpoint_depth: u32::MAX,
            ccr_high_setpoint_switch_mode: typedef::CcrSetpointSwitchMode(u8::MAX),
            ccr_high_setpoint: u8::MAX,
            ccr_high_setpoint_depth: u32::MAX,
            gas_consumption_display: typedef::GasConsumptionRateType(u8::MAX),
            up_key_enabled: typedef::Bool(u8::MAX),
            dive_sounds: typedef::Tone(u8::MAX),
            last_stop_multiple: u8::MAX,
            no_fly_time_mode: typedef::NoFlyTimeMode(u8::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }

    /// Returns `po2_warn` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn po2_warn_scaled(&self) -> Option<f64> {
        if self.po2_warn == u8::MAX {
            return None;
        }
        Some(self.po2_warn as f64 / 100.0 - 0.0)
    }

    /// Set `po2_warn` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_po2_warn_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.po2_warn = u8::MAX;
            return self;
        }
        self.po2_warn = unscaled as u8;
        self
    }

    /// Returns `po2_critical` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn po2_critical_scaled(&self) -> Option<f64> {
        if self.po2_critical == u8::MAX {
            return None;
        }
        Some(self.po2_critical as f64 / 100.0 - 0.0)
    }

    /// Set `po2_critical` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_po2_critical_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.po2_critical = u8::MAX;
            return self;
        }
        self.po2_critical = unscaled as u8;
        self
    }

    /// Returns `po2_deco` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn po2_deco_scaled(&self) -> Option<f64> {
        if self.po2_deco == u8::MAX {
            return None;
        }
        Some(self.po2_deco as f64 / 100.0 - 0.0)
    }

    /// Set `po2_deco` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_po2_deco_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.po2_deco = u8::MAX;
            return self;
        }
        self.po2_deco = unscaled as u8;
        self
    }

    /// Returns `ccr_low_setpoint` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn ccr_low_setpoint_scaled(&self) -> Option<f64> {
        if self.ccr_low_setpoint == u8::MAX {
            return None;
        }
        Some(self.ccr_low_setpoint as f64 / 100.0 - 0.0)
    }

    /// Set `ccr_low_setpoint` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_ccr_low_setpoint_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.ccr_low_setpoint = u8::MAX;
            return self;
        }
        self.ccr_low_setpoint = unscaled as u8;
        self
    }

    /// Returns `ccr_low_setpoint_depth` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn ccr_low_setpoint_depth_scaled(&self) -> Option<f64> {
        if self.ccr_low_setpoint_depth == u32::MAX {
            return None;
        }
        Some(self.ccr_low_setpoint_depth as f64 / 1000.0 - 0.0)
    }

    /// Set `ccr_low_setpoint_depth` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_ccr_low_setpoint_depth_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.ccr_low_setpoint_depth = u32::MAX;
            return self;
        }
        self.ccr_low_setpoint_depth = unscaled as u32;
        self
    }

    /// Returns `ccr_high_setpoint` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: percent
    pub fn ccr_high_setpoint_scaled(&self) -> Option<f64> {
        if self.ccr_high_setpoint == u8::MAX {
            return None;
        }
        Some(self.ccr_high_setpoint as f64 / 100.0 - 0.0)
    }

    /// Set `ccr_high_setpoint` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_ccr_high_setpoint_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 100.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.ccr_high_setpoint = u8::MAX;
            return self;
        }
        self.ccr_high_setpoint = unscaled as u8;
        self
    }

    /// Returns `ccr_high_setpoint_depth` in its scaled value. It returns `None` when value is invalid.
    ///
    /// Units: m
    pub fn ccr_high_setpoint_depth_scaled(&self) -> Option<f64> {
        if self.ccr_high_setpoint_depth == u32::MAX {
            return None;
        }
        Some(self.ccr_high_setpoint_depth as f64 / 1000.0 - 0.0)
    }

    /// Set `ccr_high_setpoint_depth` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_ccr_high_setpoint_depth_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 1000.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
            self.ccr_high_setpoint_depth = u32::MAX;
            return self;
        }
        self.ccr_high_setpoint_depth = unscaled as u32;
        self
    }

    /// Returns `last_stop_multiple` in its scaled value. It returns `None` when value is invalid.
    pub fn last_stop_multiple_scaled(&self) -> Option<f64> {
        if self.last_stop_multiple == u8::MAX {
            return None;
        }
        Some(self.last_stop_multiple as f64 / 10.0 - 0.0)
    }

    /// Set `last_stop_multiple` with scaled value, it will automatically be converted to its corresponding integer value.
    pub fn set_last_stop_multiple_scaled(&mut self, v: f64) -> &mut Self {
        let unscaled = (v + 0.0) * 10.0;
        if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
            self.last_stop_multiple = u8::MAX;
            return self;
        }
        self.last_stop_multiple = unscaled as u8;
        self
    }

    fn count_valid_fields(&self) -> usize {
        (self.timestamp.0 != u32::MAX) as usize
            + (self.message_index.0 != u16::MAX) as usize
            + (!self.name.is_empty()) as usize
            + (self.model.0 != u8::MAX) as usize
            + (self.gf_low != u8::MAX) as usize
            + (self.gf_high != u8::MAX) as usize
            + (self.water_type.0 != u8::MAX) as usize
            + (self.water_density.to_bits() != u32::MAX) as usize
            + (self.po2_warn != u8::MAX) as usize
            + (self.po2_critical != u8::MAX) as usize
            + (self.po2_deco != u8::MAX) as usize
            + (self.safety_stop_enabled.0 != u8::MAX) as usize
            + (self.bottom_depth.to_bits() != u32::MAX) as usize
            + (self.bottom_time != u32::MAX) as usize
            + (self.apnea_countdown_enabled.0 != u8::MAX) as usize
            + (self.apnea_countdown_time != u32::MAX) as usize
            + (self.backlight_mode.0 != u8::MAX) as usize
            + (self.backlight_brightness != u8::MAX) as usize
            + (self.backlight_timeout.0 != u8::MAX) as usize
            + (self.repeat_dive_interval != u16::MAX) as usize
            + (self.safety_stop_time != u16::MAX) as usize
            + (self.heart_rate_source_type.0 != u8::MAX) as usize
            + (self.heart_rate_source != u8::MAX) as usize
            + (self.travel_gas.0 != u16::MAX) as usize
            + (self.ccr_low_setpoint_switch_mode.0 != u8::MAX) as usize
            + (self.ccr_low_setpoint != u8::MAX) as usize
            + (self.ccr_low_setpoint_depth != u32::MAX) as usize
            + (self.ccr_high_setpoint_switch_mode.0 != u8::MAX) as usize
            + (self.ccr_high_setpoint != u8::MAX) as usize
            + (self.ccr_high_setpoint_depth != u32::MAX) as usize
            + (self.gas_consumption_display.0 != u8::MAX) as usize
            + (self.up_key_enabled.0 != u8::MAX) as usize
            + (self.dive_sounds.0 != u8::MAX) as usize
            + (self.last_stop_multiple != u8::MAX) as usize
            + (self.no_fly_time_mode.0 != u8::MAX) as usize
    }
}

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

impl From<&Message> for DiveSettings {
    /// from creates new DiveSettings struct based on given mesg.
    fn from(mesg: &Message) -> Self {
        const KNOWN_NUMS: [u64; 4] = [242397216767, 0, 0, 6917529027641081856];
        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 {
                253 => v.timestamp = typedef::DateTime(field.value.as_u32()),
                254 => v.message_index = typedef::MessageIndex(field.value.as_u16()),
                0 => v.name = field.value.as_str().to_owned(),
                1 => v.model = typedef::TissueModelType(field.value.as_u8()),
                2 => v.gf_low = field.value.as_u8(),
                3 => v.gf_high = field.value.as_u8(),
                4 => v.water_type = typedef::WaterType(field.value.as_u8()),
                5 => v.water_density = field.value.as_f32(),
                6 => v.po2_warn = field.value.as_u8(),
                7 => v.po2_critical = field.value.as_u8(),
                8 => v.po2_deco = field.value.as_u8(),
                9 => v.safety_stop_enabled = typedef::Bool(field.value.as_u8()),
                10 => v.bottom_depth = field.value.as_f32(),
                11 => v.bottom_time = field.value.as_u32(),
                12 => v.apnea_countdown_enabled = typedef::Bool(field.value.as_u8()),
                13 => v.apnea_countdown_time = field.value.as_u32(),
                14 => v.backlight_mode = typedef::DiveBacklightMode(field.value.as_u8()),
                15 => v.backlight_brightness = field.value.as_u8(),
                16 => v.backlight_timeout = typedef::BacklightTimeout(field.value.as_u8()),
                17 => v.repeat_dive_interval = field.value.as_u16(),
                18 => v.safety_stop_time = field.value.as_u16(),
                19 => v.heart_rate_source_type = typedef::SourceType(field.value.as_u8()),
                20 => v.heart_rate_source = field.value.as_u8(),
                21 => v.travel_gas = typedef::MessageIndex(field.value.as_u16()),
                22 => {
                    v.ccr_low_setpoint_switch_mode =
                        typedef::CcrSetpointSwitchMode(field.value.as_u8())
                }
                23 => v.ccr_low_setpoint = field.value.as_u8(),
                24 => v.ccr_low_setpoint_depth = field.value.as_u32(),
                25 => {
                    v.ccr_high_setpoint_switch_mode =
                        typedef::CcrSetpointSwitchMode(field.value.as_u8())
                }
                26 => v.ccr_high_setpoint = field.value.as_u8(),
                27 => v.ccr_high_setpoint_depth = field.value.as_u32(),
                29 => {
                    v.gas_consumption_display = typedef::GasConsumptionRateType(field.value.as_u8())
                }
                30 => v.up_key_enabled = typedef::Bool(field.value.as_u8()),
                35 => v.dive_sounds = typedef::Tone(field.value.as_u8()),
                36 => v.last_stop_multiple = field.value.as_u8(),
                37 => v.no_fly_time_mode = typedef::NoFlyTimeMode(field.value.as_u8()),
                _ => v.unknown_fields.push(field.clone()),
            };
        }

        v
    }
}

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

        if m.timestamp.0 != u32::MAX {
            fields.push(Field {
                num: 253,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.timestamp.0),
                is_expanded: false,
            });
        };
        if m.message_index.0 != u16::MAX {
            fields.push(Field {
                num: 254,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.message_index.0),
                is_expanded: false,
            });
        };
        if !m.name.is_empty() {
            fields.push(Field {
                num: 0,
                base_type: FitBaseType::STRING,
                value: Value::String(m.name),
                is_expanded: false,
            });
        };
        if m.model.0 != u8::MAX {
            fields.push(Field {
                num: 1,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.model.0),
                is_expanded: false,
            });
        };
        if m.gf_low != u8::MAX {
            fields.push(Field {
                num: 2,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.gf_low),
                is_expanded: false,
            });
        };
        if m.gf_high != u8::MAX {
            fields.push(Field {
                num: 3,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.gf_high),
                is_expanded: false,
            });
        };
        if m.water_type.0 != u8::MAX {
            fields.push(Field {
                num: 4,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.water_type.0),
                is_expanded: false,
            });
        };
        if m.water_density.to_bits() != u32::MAX {
            fields.push(Field {
                num: 5,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.water_density),
                is_expanded: false,
            });
        };
        if m.po2_warn != u8::MAX {
            fields.push(Field {
                num: 6,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.po2_warn),
                is_expanded: false,
            });
        };
        if m.po2_critical != u8::MAX {
            fields.push(Field {
                num: 7,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.po2_critical),
                is_expanded: false,
            });
        };
        if m.po2_deco != u8::MAX {
            fields.push(Field {
                num: 8,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.po2_deco),
                is_expanded: false,
            });
        };
        if m.safety_stop_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 9,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.safety_stop_enabled.0),
                is_expanded: false,
            });
        };
        if m.bottom_depth.to_bits() != u32::MAX {
            fields.push(Field {
                num: 10,
                base_type: FitBaseType::FLOAT32,
                value: Value::Float32(m.bottom_depth),
                is_expanded: false,
            });
        };
        if m.bottom_time != u32::MAX {
            fields.push(Field {
                num: 11,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.bottom_time),
                is_expanded: false,
            });
        };
        if m.apnea_countdown_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 12,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.apnea_countdown_enabled.0),
                is_expanded: false,
            });
        };
        if m.apnea_countdown_time != u32::MAX {
            fields.push(Field {
                num: 13,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.apnea_countdown_time),
                is_expanded: false,
            });
        };
        if m.backlight_mode.0 != u8::MAX {
            fields.push(Field {
                num: 14,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.backlight_mode.0),
                is_expanded: false,
            });
        };
        if m.backlight_brightness != u8::MAX {
            fields.push(Field {
                num: 15,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.backlight_brightness),
                is_expanded: false,
            });
        };
        if m.backlight_timeout.0 != u8::MAX {
            fields.push(Field {
                num: 16,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.backlight_timeout.0),
                is_expanded: false,
            });
        };
        if m.repeat_dive_interval != u16::MAX {
            fields.push(Field {
                num: 17,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.repeat_dive_interval),
                is_expanded: false,
            });
        };
        if m.safety_stop_time != u16::MAX {
            fields.push(Field {
                num: 18,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.safety_stop_time),
                is_expanded: false,
            });
        };
        if m.heart_rate_source_type.0 != u8::MAX {
            fields.push(Field {
                num: 19,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.heart_rate_source_type.0),
                is_expanded: false,
            });
        };
        if m.heart_rate_source != u8::MAX {
            fields.push(Field {
                num: 20,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.heart_rate_source),
                is_expanded: false,
            });
        };
        if m.travel_gas.0 != u16::MAX {
            fields.push(Field {
                num: 21,
                base_type: FitBaseType::UINT16,
                value: Value::Uint16(m.travel_gas.0),
                is_expanded: false,
            });
        };
        if m.ccr_low_setpoint_switch_mode.0 != u8::MAX {
            fields.push(Field {
                num: 22,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.ccr_low_setpoint_switch_mode.0),
                is_expanded: false,
            });
        };
        if m.ccr_low_setpoint != u8::MAX {
            fields.push(Field {
                num: 23,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.ccr_low_setpoint),
                is_expanded: false,
            });
        };
        if m.ccr_low_setpoint_depth != u32::MAX {
            fields.push(Field {
                num: 24,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.ccr_low_setpoint_depth),
                is_expanded: false,
            });
        };
        if m.ccr_high_setpoint_switch_mode.0 != u8::MAX {
            fields.push(Field {
                num: 25,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.ccr_high_setpoint_switch_mode.0),
                is_expanded: false,
            });
        };
        if m.ccr_high_setpoint != u8::MAX {
            fields.push(Field {
                num: 26,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.ccr_high_setpoint),
                is_expanded: false,
            });
        };
        if m.ccr_high_setpoint_depth != u32::MAX {
            fields.push(Field {
                num: 27,
                base_type: FitBaseType::UINT32,
                value: Value::Uint32(m.ccr_high_setpoint_depth),
                is_expanded: false,
            });
        };
        if m.gas_consumption_display.0 != u8::MAX {
            fields.push(Field {
                num: 29,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.gas_consumption_display.0),
                is_expanded: false,
            });
        };
        if m.up_key_enabled.0 != u8::MAX {
            fields.push(Field {
                num: 30,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.up_key_enabled.0),
                is_expanded: false,
            });
        };
        if m.dive_sounds.0 != u8::MAX {
            fields.push(Field {
                num: 35,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.dive_sounds.0),
                is_expanded: false,
            });
        };
        if m.last_stop_multiple != u8::MAX {
            fields.push(Field {
                num: 36,
                base_type: FitBaseType::UINT8,
                value: Value::Uint8(m.last_stop_multiple),
                is_expanded: false,
            });
        };
        if m.no_fly_time_mode.0 != u8::MAX {
            fields.push(Field {
                num: 37,
                base_type: FitBaseType::ENUM,
                value: Value::Uint8(m.no_fly_time_mode.0),
                is_expanded: false,
            });
        };

        fields.extend_from_slice(&m.unknown_fields);

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

#[cfg(feature = "serde")]
impl Serialize for DiveSettings {
    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("DiveSettings", n)?;
        if let Some(v) = self.timestamp.unix_timestamp() {
            state.serialize_field("timestamp", &v)?;
        }
        if self.message_index.0 != u16::MAX {
            state.serialize_field("message_index", &self.message_index)?;
        }
        if !self.name.is_empty() {
            state.serialize_field("name", &self.name)?;
        }
        if self.model.0 != u8::MAX {
            state.serialize_field("model", &self.model)?;
        }
        if self.gf_low != u8::MAX {
            state.serialize_field("gf_low", &self.gf_low)?;
        }
        if self.gf_high != u8::MAX {
            state.serialize_field("gf_high", &self.gf_high)?;
        }
        if self.water_type.0 != u8::MAX {
            state.serialize_field("water_type", &self.water_type)?;
        }
        if self.water_density.to_bits() != u32::MAX {
            state.serialize_field("water_density", &self.water_density)?;
        }
        if let Some(v) = self.po2_warn_scaled() {
            state.serialize_field("po2_warn", &v)?;
        }
        if let Some(v) = self.po2_critical_scaled() {
            state.serialize_field("po2_critical", &v)?;
        }
        if let Some(v) = self.po2_deco_scaled() {
            state.serialize_field("po2_deco", &v)?;
        }
        if self.safety_stop_enabled.0 != u8::MAX {
            state.serialize_field("safety_stop_enabled", &self.safety_stop_enabled)?;
        }
        if self.bottom_depth.to_bits() != u32::MAX {
            state.serialize_field("bottom_depth", &self.bottom_depth)?;
        }
        if self.bottom_time != u32::MAX {
            state.serialize_field("bottom_time", &self.bottom_time)?;
        }
        if self.apnea_countdown_enabled.0 != u8::MAX {
            state.serialize_field("apnea_countdown_enabled", &self.apnea_countdown_enabled)?;
        }
        if self.apnea_countdown_time != u32::MAX {
            state.serialize_field("apnea_countdown_time", &self.apnea_countdown_time)?;
        }
        if self.backlight_mode.0 != u8::MAX {
            state.serialize_field("backlight_mode", &self.backlight_mode)?;
        }
        if self.backlight_brightness != u8::MAX {
            state.serialize_field("backlight_brightness", &self.backlight_brightness)?;
        }
        if self.backlight_timeout.0 != u8::MAX {
            state.serialize_field("backlight_timeout", &self.backlight_timeout)?;
        }
        if self.repeat_dive_interval != u16::MAX {
            state.serialize_field("repeat_dive_interval", &self.repeat_dive_interval)?;
        }
        if self.safety_stop_time != u16::MAX {
            state.serialize_field("safety_stop_time", &self.safety_stop_time)?;
        }
        if self.heart_rate_source_type.0 != u8::MAX {
            state.serialize_field("heart_rate_source_type", &self.heart_rate_source_type)?;
        }
        if self.heart_rate_source != u8::MAX {
            state.serialize_field("heart_rate_source", &self.heart_rate_source)?;
        }
        if self.travel_gas.0 != u16::MAX {
            state.serialize_field("travel_gas", &self.travel_gas)?;
        }
        if self.ccr_low_setpoint_switch_mode.0 != u8::MAX {
            state.serialize_field(
                "ccr_low_setpoint_switch_mode",
                &self.ccr_low_setpoint_switch_mode,
            )?;
        }
        if let Some(v) = self.ccr_low_setpoint_scaled() {
            state.serialize_field("ccr_low_setpoint", &v)?;
        }
        if let Some(v) = self.ccr_low_setpoint_depth_scaled() {
            state.serialize_field("ccr_low_setpoint_depth", &v)?;
        }
        if self.ccr_high_setpoint_switch_mode.0 != u8::MAX {
            state.serialize_field(
                "ccr_high_setpoint_switch_mode",
                &self.ccr_high_setpoint_switch_mode,
            )?;
        }
        if let Some(v) = self.ccr_high_setpoint_scaled() {
            state.serialize_field("ccr_high_setpoint", &v)?;
        }
        if let Some(v) = self.ccr_high_setpoint_depth_scaled() {
            state.serialize_field("ccr_high_setpoint_depth", &v)?;
        }
        if self.gas_consumption_display.0 != u8::MAX {
            state.serialize_field("gas_consumption_display", &self.gas_consumption_display)?;
        }
        if self.up_key_enabled.0 != u8::MAX {
            state.serialize_field("up_key_enabled", &self.up_key_enabled)?;
        }
        if self.dive_sounds.0 != u8::MAX {
            state.serialize_field("dive_sounds", &self.dive_sounds)?;
        }
        if let Some(v) = self.last_stop_multiple_scaled() {
            state.serialize_field("last_stop_multiple", &v)?;
        }
        if self.no_fly_time_mode.0 != u8::MAX {
            state.serialize_field("no_fly_time_mode", &self.no_fly_time_mode)?;
        }
        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 {
    timestamp: Option<i64>,
    message_index: typedef::MessageIndex,
    name: String,
    model: typedef::TissueModelType,
    gf_low: u8,
    gf_high: u8,
    water_type: typedef::WaterType,
    water_density: f32,
    po2_warn: f64,
    po2_critical: f64,
    po2_deco: f64,
    safety_stop_enabled: typedef::Bool,
    bottom_depth: f32,
    bottom_time: u32,
    apnea_countdown_enabled: typedef::Bool,
    apnea_countdown_time: u32,
    backlight_mode: typedef::DiveBacklightMode,
    backlight_brightness: u8,
    backlight_timeout: typedef::BacklightTimeout,
    repeat_dive_interval: u16,
    safety_stop_time: u16,
    heart_rate_source_type: typedef::SourceType,
    heart_rate_source: u8,
    travel_gas: typedef::MessageIndex,
    ccr_low_setpoint_switch_mode: typedef::CcrSetpointSwitchMode,
    ccr_low_setpoint: f64,
    ccr_low_setpoint_depth: f64,
    ccr_high_setpoint_switch_mode: typedef::CcrSetpointSwitchMode,
    ccr_high_setpoint: f64,
    ccr_high_setpoint_depth: f64,
    gas_consumption_display: typedef::GasConsumptionRateType,
    up_key_enabled: typedef::Bool,
    dive_sounds: typedef::Tone,
    last_stop_multiple: f64,
    no_fly_time_mode: typedef::NoFlyTimeMode,
    unknown_fields: Vec<Field>,
    developer_fields: Vec<DeveloperField>,
}

#[cfg(feature = "serde")]
impl From<De> for DiveSettings {
    fn from(m: De) -> Self {
        Self {
            timestamp: m.timestamp.map_or_else(
                || typedef::DateTime(u32::MAX),
                typedef::DateTime::from_unix_timestamp,
            ),
            message_index: m.message_index,
            name: m.name,
            model: m.model,
            gf_low: m.gf_low,
            gf_high: m.gf_high,
            water_type: m.water_type,
            water_density: m.water_density,
            po2_warn: {
                let unscaled = (m.po2_warn + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            po2_critical: {
                let unscaled = (m.po2_critical + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            po2_deco: {
                let unscaled = (m.po2_deco + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            safety_stop_enabled: m.safety_stop_enabled,
            bottom_depth: m.bottom_depth,
            bottom_time: m.bottom_time,
            apnea_countdown_enabled: m.apnea_countdown_enabled,
            apnea_countdown_time: m.apnea_countdown_time,
            backlight_mode: m.backlight_mode,
            backlight_brightness: m.backlight_brightness,
            backlight_timeout: m.backlight_timeout,
            repeat_dive_interval: m.repeat_dive_interval,
            safety_stop_time: m.safety_stop_time,
            heart_rate_source_type: m.heart_rate_source_type,
            heart_rate_source: m.heart_rate_source,
            travel_gas: m.travel_gas,
            ccr_low_setpoint_switch_mode: m.ccr_low_setpoint_switch_mode,
            ccr_low_setpoint: {
                let unscaled = (m.ccr_low_setpoint + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            ccr_low_setpoint_depth: {
                let unscaled = (m.ccr_low_setpoint_depth + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            ccr_high_setpoint_switch_mode: m.ccr_high_setpoint_switch_mode,
            ccr_high_setpoint: {
                let unscaled = (m.ccr_high_setpoint + 0.0) * 100.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            ccr_high_setpoint_depth: {
                let unscaled = (m.ccr_high_setpoint_depth + 0.0) * 1000.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
                    u32::MAX
                } else {
                    unscaled as u32
                }
            },
            gas_consumption_display: m.gas_consumption_display,
            up_key_enabled: m.up_key_enabled,
            dive_sounds: m.dive_sounds,
            last_stop_multiple: {
                let unscaled = (m.last_stop_multiple + 0.0) * 10.0;
                if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
                    u8::MAX
                } else {
                    unscaled as u8
                }
            },
            no_fly_time_mode: m.no_fly_time_mode,
            unknown_fields: m.unknown_fields,
            developer_fields: m.developer_fields,
        }
    }
}

#[cfg(feature = "serde")]
impl Default for De {
    fn default() -> Self {
        Self {
            timestamp: None,
            message_index: typedef::MessageIndex(u16::MAX),
            name: String::new(),
            model: typedef::TissueModelType(u8::MAX),
            gf_low: u8::MAX,
            gf_high: u8::MAX,
            water_type: typedef::WaterType(u8::MAX),
            water_density: f32::from_bits(u32::MAX),
            po2_warn: f64::from_bits(u64::MAX),
            po2_critical: f64::from_bits(u64::MAX),
            po2_deco: f64::from_bits(u64::MAX),
            safety_stop_enabled: typedef::Bool(u8::MAX),
            bottom_depth: f32::from_bits(u32::MAX),
            bottom_time: u32::MAX,
            apnea_countdown_enabled: typedef::Bool(u8::MAX),
            apnea_countdown_time: u32::MAX,
            backlight_mode: typedef::DiveBacklightMode(u8::MAX),
            backlight_brightness: u8::MAX,
            backlight_timeout: typedef::BacklightTimeout(u8::MAX),
            repeat_dive_interval: u16::MAX,
            safety_stop_time: u16::MAX,
            heart_rate_source_type: typedef::SourceType(u8::MAX),
            heart_rate_source: u8::MAX,
            travel_gas: typedef::MessageIndex(u16::MAX),
            ccr_low_setpoint_switch_mode: typedef::CcrSetpointSwitchMode(u8::MAX),
            ccr_low_setpoint: f64::from_bits(u64::MAX),
            ccr_low_setpoint_depth: f64::from_bits(u64::MAX),
            ccr_high_setpoint_switch_mode: typedef::CcrSetpointSwitchMode(u8::MAX),
            ccr_high_setpoint: f64::from_bits(u64::MAX),
            ccr_high_setpoint_depth: f64::from_bits(u64::MAX),
            gas_consumption_display: typedef::GasConsumptionRateType(u8::MAX),
            up_key_enabled: typedef::Bool(u8::MAX),
            dive_sounds: typedef::Tone(u8::MAX),
            last_stop_multiple: f64::from_bits(u64::MAX),
            no_fly_time_mode: typedef::NoFlyTimeMode(u8::MAX),
            unknown_fields: Vec::new(),
            developer_fields: Vec::new(),
        }
    }
}