#![allow(clippy::manual_range_patterns)]
use crate::profile::typedef::{self, FitBaseType};
use crate::proto::*;
use crate::semconv;
use alloc::vec::Vec;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize, Serializer, ser::SerializeStruct};
fn is_expanded(state: &[u8], num: u8) -> bool {
match num {
110 | 111 | 112 | 113 | 114 | 136 | 137 => (state[num as usize >> 3] >> (num & 7)) & 1 == 1,
_ => false,
}
}
#[cfg_attr(feature = "serde", derive(Deserialize), serde(from = "De"))]
#[derive(Debug, Clone)]
pub struct Lap {
pub message_index: typedef::MessageIndex,
pub timestamp: typedef::DateTime,
pub event: typedef::Event,
pub event_type: typedef::EventType,
pub start_time: typedef::DateTime,
pub start_position_lat: i32,
pub start_position_long: i32,
pub end_position_lat: i32,
pub end_position_long: i32,
pub total_elapsed_time: u32,
pub total_timer_time: u32,
pub total_distance: u32,
pub total_cycles: u32,
pub total_calories: u16,
pub total_fat_calories: u16,
pub avg_speed: u16,
pub max_speed: u16,
pub avg_heart_rate: u8,
pub max_heart_rate: u8,
pub avg_cadence: u8,
pub max_cadence: u8,
pub avg_power: u16,
pub max_power: u16,
pub total_ascent: u16,
pub total_descent: u16,
pub intensity: typedef::Intensity,
pub lap_trigger: typedef::LapTrigger,
pub sport: typedef::Sport,
pub event_group: u8,
pub num_lengths: u16,
pub normalized_power: u16,
pub left_right_balance: typedef::LeftRightBalance100,
pub first_length_index: u16,
pub avg_stroke_distance: u16,
pub swim_stroke: typedef::SwimStroke,
pub sub_sport: typedef::SubSport,
pub num_active_lengths: u16,
pub total_work: u32,
pub avg_altitude: u16,
pub max_altitude: u16,
pub gps_accuracy: u8,
pub avg_grade: i16,
pub avg_pos_grade: i16,
pub avg_neg_grade: i16,
pub max_pos_grade: i16,
pub max_neg_grade: i16,
pub avg_temperature: i8,
pub max_temperature: i8,
pub total_moving_time: u32,
pub avg_pos_vertical_speed: i16,
pub avg_neg_vertical_speed: i16,
pub max_pos_vertical_speed: i16,
pub max_neg_vertical_speed: i16,
pub time_in_hr_zone: Vec<u32>,
pub time_in_speed_zone: Vec<u32>,
pub time_in_cadence_zone: Vec<u32>,
pub time_in_power_zone: Vec<u32>,
pub repetition_num: u16,
pub min_altitude: u16,
pub min_heart_rate: u8,
pub active_time: u32,
pub wkt_step_index: typedef::MessageIndex,
pub opponent_score: u16,
pub stroke_count: Vec<u16>,
pub zone_count: Vec<u16>,
pub avg_vertical_oscillation: u16,
pub avg_stance_time_percent: u16,
pub avg_stance_time: u16,
pub avg_fractional_cadence: u8,
pub max_fractional_cadence: u8,
pub total_fractional_cycles: u8,
pub player_score: u16,
pub avg_total_hemoglobin_conc: Vec<u16>,
pub min_total_hemoglobin_conc: Vec<u16>,
pub max_total_hemoglobin_conc: Vec<u16>,
pub avg_saturated_hemoglobin_percent: Vec<u16>,
pub min_saturated_hemoglobin_percent: Vec<u16>,
pub max_saturated_hemoglobin_percent: Vec<u16>,
pub avg_left_torque_effectiveness: u8,
pub avg_right_torque_effectiveness: u8,
pub avg_left_pedal_smoothness: u8,
pub avg_right_pedal_smoothness: u8,
pub avg_combined_pedal_smoothness: u8,
pub time_standing: u32,
pub stand_count: u16,
pub avg_left_pco: i8,
pub avg_right_pco: i8,
pub avg_left_power_phase: Vec<u8>,
pub avg_left_power_phase_peak: Vec<u8>,
pub avg_right_power_phase: Vec<u8>,
pub avg_right_power_phase_peak: Vec<u8>,
pub avg_power_position: Vec<u16>,
pub max_power_position: Vec<u16>,
pub avg_cadence_position: Vec<u8>,
pub max_cadence_position: Vec<u8>,
pub enhanced_avg_speed: u32,
pub enhanced_max_speed: u32,
pub enhanced_avg_altitude: u32,
pub enhanced_min_altitude: u32,
pub enhanced_max_altitude: u32,
pub avg_lev_motor_power: u16,
pub max_lev_motor_power: u16,
pub lev_battery_consumption: u8,
pub avg_vertical_ratio: u16,
pub avg_stance_time_balance: u16,
pub avg_step_length: u16,
pub avg_vam: u16,
pub avg_depth: u32,
pub max_depth: u32,
pub min_temperature: i8,
pub enhanced_avg_respiration_rate: u16,
pub enhanced_max_respiration_rate: u16,
pub avg_respiration_rate: u8,
pub max_respiration_rate: u8,
pub total_grit: f32,
pub total_flow: f32,
pub jump_count: u16,
pub avg_grit: f32,
pub avg_flow: f32,
pub total_fractional_ascent: u8,
pub total_fractional_descent: u8,
pub avg_core_temperature: u16,
pub min_core_temperature: u16,
pub max_core_temperature: u16,
state: [u8; 18], pub unknown_fields: Vec<Field>,
pub developer_fields: Vec<DeveloperField>,
}
impl Lap {
pub const MESSAGE_INDEX: u8 = 254;
pub const TIMESTAMP: u8 = 253;
pub const EVENT: u8 = 0;
pub const EVENT_TYPE: u8 = 1;
pub const START_TIME: u8 = 2;
pub const START_POSITION_LAT: u8 = 3;
pub const START_POSITION_LONG: u8 = 4;
pub const END_POSITION_LAT: u8 = 5;
pub const END_POSITION_LONG: u8 = 6;
pub const TOTAL_ELAPSED_TIME: u8 = 7;
pub const TOTAL_TIMER_TIME: u8 = 8;
pub const TOTAL_DISTANCE: u8 = 9;
pub const TOTAL_CYCLES: u8 = 10;
pub const TOTAL_CALORIES: u8 = 11;
pub const TOTAL_FAT_CALORIES: u8 = 12;
pub const AVG_SPEED: u8 = 13;
pub const MAX_SPEED: u8 = 14;
pub const AVG_HEART_RATE: u8 = 15;
pub const MAX_HEART_RATE: u8 = 16;
pub const AVG_CADENCE: u8 = 17;
pub const MAX_CADENCE: u8 = 18;
pub const AVG_POWER: u8 = 19;
pub const MAX_POWER: u8 = 20;
pub const TOTAL_ASCENT: u8 = 21;
pub const TOTAL_DESCENT: u8 = 22;
pub const INTENSITY: u8 = 23;
pub const LAP_TRIGGER: u8 = 24;
pub const SPORT: u8 = 25;
pub const EVENT_GROUP: u8 = 26;
pub const NUM_LENGTHS: u8 = 32;
pub const NORMALIZED_POWER: u8 = 33;
pub const LEFT_RIGHT_BALANCE: u8 = 34;
pub const FIRST_LENGTH_INDEX: u8 = 35;
pub const AVG_STROKE_DISTANCE: u8 = 37;
pub const SWIM_STROKE: u8 = 38;
pub const SUB_SPORT: u8 = 39;
pub const NUM_ACTIVE_LENGTHS: u8 = 40;
pub const TOTAL_WORK: u8 = 41;
pub const AVG_ALTITUDE: u8 = 42;
pub const MAX_ALTITUDE: u8 = 43;
pub const GPS_ACCURACY: u8 = 44;
pub const AVG_GRADE: u8 = 45;
pub const AVG_POS_GRADE: u8 = 46;
pub const AVG_NEG_GRADE: u8 = 47;
pub const MAX_POS_GRADE: u8 = 48;
pub const MAX_NEG_GRADE: u8 = 49;
pub const AVG_TEMPERATURE: u8 = 50;
pub const MAX_TEMPERATURE: u8 = 51;
pub const TOTAL_MOVING_TIME: u8 = 52;
pub const AVG_POS_VERTICAL_SPEED: u8 = 53;
pub const AVG_NEG_VERTICAL_SPEED: u8 = 54;
pub const MAX_POS_VERTICAL_SPEED: u8 = 55;
pub const MAX_NEG_VERTICAL_SPEED: u8 = 56;
pub const TIME_IN_HR_ZONE: u8 = 57;
pub const TIME_IN_SPEED_ZONE: u8 = 58;
pub const TIME_IN_CADENCE_ZONE: u8 = 59;
pub const TIME_IN_POWER_ZONE: u8 = 60;
pub const REPETITION_NUM: u8 = 61;
pub const MIN_ALTITUDE: u8 = 62;
pub const MIN_HEART_RATE: u8 = 63;
pub const ACTIVE_TIME: u8 = 70;
pub const WKT_STEP_INDEX: u8 = 71;
pub const OPPONENT_SCORE: u8 = 74;
pub const STROKE_COUNT: u8 = 75;
pub const ZONE_COUNT: u8 = 76;
pub const AVG_VERTICAL_OSCILLATION: u8 = 77;
pub const AVG_STANCE_TIME_PERCENT: u8 = 78;
pub const AVG_STANCE_TIME: u8 = 79;
pub const AVG_FRACTIONAL_CADENCE: u8 = 80;
pub const MAX_FRACTIONAL_CADENCE: u8 = 81;
pub const TOTAL_FRACTIONAL_CYCLES: u8 = 82;
pub const PLAYER_SCORE: u8 = 83;
pub const AVG_TOTAL_HEMOGLOBIN_CONC: u8 = 84;
pub const MIN_TOTAL_HEMOGLOBIN_CONC: u8 = 85;
pub const MAX_TOTAL_HEMOGLOBIN_CONC: u8 = 86;
pub const AVG_SATURATED_HEMOGLOBIN_PERCENT: u8 = 87;
pub const MIN_SATURATED_HEMOGLOBIN_PERCENT: u8 = 88;
pub const MAX_SATURATED_HEMOGLOBIN_PERCENT: u8 = 89;
pub const AVG_LEFT_TORQUE_EFFECTIVENESS: u8 = 91;
pub const AVG_RIGHT_TORQUE_EFFECTIVENESS: u8 = 92;
pub const AVG_LEFT_PEDAL_SMOOTHNESS: u8 = 93;
pub const AVG_RIGHT_PEDAL_SMOOTHNESS: u8 = 94;
pub const AVG_COMBINED_PEDAL_SMOOTHNESS: u8 = 95;
pub const TIME_STANDING: u8 = 98;
pub const STAND_COUNT: u8 = 99;
pub const AVG_LEFT_PCO: u8 = 100;
pub const AVG_RIGHT_PCO: u8 = 101;
pub const AVG_LEFT_POWER_PHASE: u8 = 102;
pub const AVG_LEFT_POWER_PHASE_PEAK: u8 = 103;
pub const AVG_RIGHT_POWER_PHASE: u8 = 104;
pub const AVG_RIGHT_POWER_PHASE_PEAK: u8 = 105;
pub const AVG_POWER_POSITION: u8 = 106;
pub const MAX_POWER_POSITION: u8 = 107;
pub const AVG_CADENCE_POSITION: u8 = 108;
pub const MAX_CADENCE_POSITION: u8 = 109;
pub const ENHANCED_AVG_SPEED: u8 = 110;
pub const ENHANCED_MAX_SPEED: u8 = 111;
pub const ENHANCED_AVG_ALTITUDE: u8 = 112;
pub const ENHANCED_MIN_ALTITUDE: u8 = 113;
pub const ENHANCED_MAX_ALTITUDE: u8 = 114;
pub const AVG_LEV_MOTOR_POWER: u8 = 115;
pub const MAX_LEV_MOTOR_POWER: u8 = 116;
pub const LEV_BATTERY_CONSUMPTION: u8 = 117;
pub const AVG_VERTICAL_RATIO: u8 = 118;
pub const AVG_STANCE_TIME_BALANCE: u8 = 119;
pub const AVG_STEP_LENGTH: u8 = 120;
pub const AVG_VAM: u8 = 121;
pub const AVG_DEPTH: u8 = 122;
pub const MAX_DEPTH: u8 = 123;
pub const MIN_TEMPERATURE: u8 = 124;
pub const ENHANCED_AVG_RESPIRATION_RATE: u8 = 136;
pub const ENHANCED_MAX_RESPIRATION_RATE: u8 = 137;
pub const AVG_RESPIRATION_RATE: u8 = 147;
pub const MAX_RESPIRATION_RATE: u8 = 148;
pub const TOTAL_GRIT: u8 = 149;
pub const TOTAL_FLOW: u8 = 150;
pub const JUMP_COUNT: u8 = 151;
pub const AVG_GRIT: u8 = 153;
pub const AVG_FLOW: u8 = 154;
pub const TOTAL_FRACTIONAL_ASCENT: u8 = 156;
pub const TOTAL_FRACTIONAL_DESCENT: u8 = 157;
pub const AVG_CORE_TEMPERATURE: u8 = 158;
pub const MIN_CORE_TEMPERATURE: u8 = 159;
pub const MAX_CORE_TEMPERATURE: u8 = 160;
pub const fn new() -> Self {
Self {
message_index: typedef::MessageIndex(u16::MAX),
timestamp: typedef::DateTime(u32::MAX),
event: typedef::Event(u8::MAX),
event_type: typedef::EventType(u8::MAX),
start_time: typedef::DateTime(u32::MAX),
start_position_lat: i32::MAX,
start_position_long: i32::MAX,
end_position_lat: i32::MAX,
end_position_long: i32::MAX,
total_elapsed_time: u32::MAX,
total_timer_time: u32::MAX,
total_distance: u32::MAX,
total_cycles: u32::MAX,
total_calories: u16::MAX,
total_fat_calories: u16::MAX,
avg_speed: u16::MAX,
max_speed: u16::MAX,
avg_heart_rate: u8::MAX,
max_heart_rate: u8::MAX,
avg_cadence: u8::MAX,
max_cadence: u8::MAX,
avg_power: u16::MAX,
max_power: u16::MAX,
total_ascent: u16::MAX,
total_descent: u16::MAX,
intensity: typedef::Intensity(u8::MAX),
lap_trigger: typedef::LapTrigger(u8::MAX),
sport: typedef::Sport(u8::MAX),
event_group: u8::MAX,
num_lengths: u16::MAX,
normalized_power: u16::MAX,
left_right_balance: typedef::LeftRightBalance100(u16::MAX),
first_length_index: u16::MAX,
avg_stroke_distance: u16::MAX,
swim_stroke: typedef::SwimStroke(u8::MAX),
sub_sport: typedef::SubSport(u8::MAX),
num_active_lengths: u16::MAX,
total_work: u32::MAX,
avg_altitude: u16::MAX,
max_altitude: u16::MAX,
gps_accuracy: u8::MAX,
avg_grade: i16::MAX,
avg_pos_grade: i16::MAX,
avg_neg_grade: i16::MAX,
max_pos_grade: i16::MAX,
max_neg_grade: i16::MAX,
avg_temperature: i8::MAX,
max_temperature: i8::MAX,
total_moving_time: u32::MAX,
avg_pos_vertical_speed: i16::MAX,
avg_neg_vertical_speed: i16::MAX,
max_pos_vertical_speed: i16::MAX,
max_neg_vertical_speed: i16::MAX,
time_in_hr_zone: Vec::new(),
time_in_speed_zone: Vec::new(),
time_in_cadence_zone: Vec::new(),
time_in_power_zone: Vec::new(),
repetition_num: u16::MAX,
min_altitude: u16::MAX,
min_heart_rate: u8::MAX,
active_time: u32::MAX,
wkt_step_index: typedef::MessageIndex(u16::MAX),
opponent_score: u16::MAX,
stroke_count: Vec::new(),
zone_count: Vec::new(),
avg_vertical_oscillation: u16::MAX,
avg_stance_time_percent: u16::MAX,
avg_stance_time: u16::MAX,
avg_fractional_cadence: u8::MAX,
max_fractional_cadence: u8::MAX,
total_fractional_cycles: u8::MAX,
player_score: u16::MAX,
avg_total_hemoglobin_conc: Vec::new(),
min_total_hemoglobin_conc: Vec::new(),
max_total_hemoglobin_conc: Vec::new(),
avg_saturated_hemoglobin_percent: Vec::new(),
min_saturated_hemoglobin_percent: Vec::new(),
max_saturated_hemoglobin_percent: Vec::new(),
avg_left_torque_effectiveness: u8::MAX,
avg_right_torque_effectiveness: u8::MAX,
avg_left_pedal_smoothness: u8::MAX,
avg_right_pedal_smoothness: u8::MAX,
avg_combined_pedal_smoothness: u8::MAX,
time_standing: u32::MAX,
stand_count: u16::MAX,
avg_left_pco: i8::MAX,
avg_right_pco: i8::MAX,
avg_left_power_phase: Vec::new(),
avg_left_power_phase_peak: Vec::new(),
avg_right_power_phase: Vec::new(),
avg_right_power_phase_peak: Vec::new(),
avg_power_position: Vec::new(),
max_power_position: Vec::new(),
avg_cadence_position: Vec::new(),
max_cadence_position: Vec::new(),
enhanced_avg_speed: u32::MAX,
enhanced_max_speed: u32::MAX,
enhanced_avg_altitude: u32::MAX,
enhanced_min_altitude: u32::MAX,
enhanced_max_altitude: u32::MAX,
avg_lev_motor_power: u16::MAX,
max_lev_motor_power: u16::MAX,
lev_battery_consumption: u8::MAX,
avg_vertical_ratio: u16::MAX,
avg_stance_time_balance: u16::MAX,
avg_step_length: u16::MAX,
avg_vam: u16::MAX,
avg_depth: u32::MAX,
max_depth: u32::MAX,
min_temperature: i8::MAX,
enhanced_avg_respiration_rate: u16::MAX,
enhanced_max_respiration_rate: u16::MAX,
avg_respiration_rate: u8::MAX,
max_respiration_rate: u8::MAX,
total_grit: f32::from_bits(u32::MAX),
total_flow: f32::from_bits(u32::MAX),
jump_count: u16::MAX,
avg_grit: f32::from_bits(u32::MAX),
avg_flow: f32::from_bits(u32::MAX),
total_fractional_ascent: u8::MAX,
total_fractional_descent: u8::MAX,
avg_core_temperature: u16::MAX,
min_core_temperature: u16::MAX,
max_core_temperature: u16::MAX,
state: [0u8; 18],
unknown_fields: Vec::new(),
developer_fields: Vec::new(),
}
}
pub fn start_position_lat_degrees(&self) -> Option<f64> {
semconv::to_degrees(self.start_position_lat)
}
pub fn set_start_position_lat_degrees(&mut self, v: f64) -> &mut Self {
self.start_position_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
self
}
pub fn start_position_long_degrees(&self) -> Option<f64> {
semconv::to_degrees(self.start_position_long)
}
pub fn set_start_position_long_degrees(&mut self, v: f64) -> &mut Self {
self.start_position_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
self
}
pub fn end_position_lat_degrees(&self) -> Option<f64> {
semconv::to_degrees(self.end_position_lat)
}
pub fn set_end_position_lat_degrees(&mut self, v: f64) -> &mut Self {
self.end_position_lat = semconv::to_semicircles(v).unwrap_or(i32::MAX);
self
}
pub fn end_position_long_degrees(&self) -> Option<f64> {
semconv::to_degrees(self.end_position_long)
}
pub fn set_end_position_long_degrees(&mut self, v: f64) -> &mut Self {
self.end_position_long = semconv::to_semicircles(v).unwrap_or(i32::MAX);
self
}
pub fn total_elapsed_time_scaled(&self) -> Option<f64> {
if self.total_elapsed_time == u32::MAX {
return None;
}
Some(self.total_elapsed_time as f64 / 1000.0 - 0.0)
}
pub fn set_total_elapsed_time_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.total_elapsed_time = u32::MAX;
return self;
}
self.total_elapsed_time = unscaled as u32;
self
}
pub fn total_timer_time_scaled(&self) -> Option<f64> {
if self.total_timer_time == u32::MAX {
return None;
}
Some(self.total_timer_time as f64 / 1000.0 - 0.0)
}
pub fn set_total_timer_time_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.total_timer_time = u32::MAX;
return self;
}
self.total_timer_time = unscaled as u32;
self
}
pub fn total_distance_scaled(&self) -> Option<f64> {
if self.total_distance == u32::MAX {
return None;
}
Some(self.total_distance as f64 / 100.0 - 0.0)
}
pub fn set_total_distance_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.total_distance = u32::MAX;
return self;
}
self.total_distance = unscaled as u32;
self
}
pub fn avg_speed_scaled(&self) -> Option<f64> {
if self.avg_speed == u16::MAX {
return None;
}
Some(self.avg_speed as f64 / 1000.0 - 0.0)
}
pub fn set_avg_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_speed = u16::MAX;
return self;
}
self.avg_speed = unscaled as u16;
self
}
pub fn max_speed_scaled(&self) -> Option<f64> {
if self.max_speed == u16::MAX {
return None;
}
Some(self.max_speed as f64 / 1000.0 - 0.0)
}
pub fn set_max_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.max_speed = u16::MAX;
return self;
}
self.max_speed = unscaled as u16;
self
}
pub fn avg_stroke_distance_scaled(&self) -> Option<f64> {
if self.avg_stroke_distance == u16::MAX {
return None;
}
Some(self.avg_stroke_distance as f64 / 100.0 - 0.0)
}
pub fn set_avg_stroke_distance_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_stroke_distance = u16::MAX;
return self;
}
self.avg_stroke_distance = unscaled as u16;
self
}
pub fn avg_altitude_scaled(&self) -> Option<f64> {
if self.avg_altitude == u16::MAX {
return None;
}
Some(self.avg_altitude as f64 / 5.0 - 500.0)
}
pub fn set_avg_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_altitude = u16::MAX;
return self;
}
self.avg_altitude = unscaled as u16;
self
}
pub fn max_altitude_scaled(&self) -> Option<f64> {
if self.max_altitude == u16::MAX {
return None;
}
Some(self.max_altitude as f64 / 5.0 - 500.0)
}
pub fn set_max_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.max_altitude = u16::MAX;
return self;
}
self.max_altitude = unscaled as u16;
self
}
pub fn avg_grade_scaled(&self) -> Option<f64> {
if self.avg_grade == i16::MAX {
return None;
}
Some(self.avg_grade as f64 / 100.0 - 0.0)
}
pub fn set_avg_grade_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.avg_grade = i16::MAX;
return self;
}
self.avg_grade = unscaled as i16;
self
}
pub fn avg_pos_grade_scaled(&self) -> Option<f64> {
if self.avg_pos_grade == i16::MAX {
return None;
}
Some(self.avg_pos_grade as f64 / 100.0 - 0.0)
}
pub fn set_avg_pos_grade_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.avg_pos_grade = i16::MAX;
return self;
}
self.avg_pos_grade = unscaled as i16;
self
}
pub fn avg_neg_grade_scaled(&self) -> Option<f64> {
if self.avg_neg_grade == i16::MAX {
return None;
}
Some(self.avg_neg_grade as f64 / 100.0 - 0.0)
}
pub fn set_avg_neg_grade_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.avg_neg_grade = i16::MAX;
return self;
}
self.avg_neg_grade = unscaled as i16;
self
}
pub fn max_pos_grade_scaled(&self) -> Option<f64> {
if self.max_pos_grade == i16::MAX {
return None;
}
Some(self.max_pos_grade as f64 / 100.0 - 0.0)
}
pub fn set_max_pos_grade_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.max_pos_grade = i16::MAX;
return self;
}
self.max_pos_grade = unscaled as i16;
self
}
pub fn max_neg_grade_scaled(&self) -> Option<f64> {
if self.max_neg_grade == i16::MAX {
return None;
}
Some(self.max_neg_grade as f64 / 100.0 - 0.0)
}
pub fn set_max_neg_grade_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.max_neg_grade = i16::MAX;
return self;
}
self.max_neg_grade = unscaled as i16;
self
}
pub fn total_moving_time_scaled(&self) -> Option<f64> {
if self.total_moving_time == u32::MAX {
return None;
}
Some(self.total_moving_time as f64 / 1000.0 - 0.0)
}
pub fn set_total_moving_time_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.total_moving_time = u32::MAX;
return self;
}
self.total_moving_time = unscaled as u32;
self
}
pub fn avg_pos_vertical_speed_scaled(&self) -> Option<f64> {
if self.avg_pos_vertical_speed == i16::MAX {
return None;
}
Some(self.avg_pos_vertical_speed as f64 / 1000.0 - 0.0)
}
pub fn set_avg_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.avg_pos_vertical_speed = i16::MAX;
return self;
}
self.avg_pos_vertical_speed = unscaled as i16;
self
}
pub fn avg_neg_vertical_speed_scaled(&self) -> Option<f64> {
if self.avg_neg_vertical_speed == i16::MAX {
return None;
}
Some(self.avg_neg_vertical_speed as f64 / 1000.0 - 0.0)
}
pub fn set_avg_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.avg_neg_vertical_speed = i16::MAX;
return self;
}
self.avg_neg_vertical_speed = unscaled as i16;
self
}
pub fn max_pos_vertical_speed_scaled(&self) -> Option<f64> {
if self.max_pos_vertical_speed == i16::MAX {
return None;
}
Some(self.max_pos_vertical_speed as f64 / 1000.0 - 0.0)
}
pub fn set_max_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.max_pos_vertical_speed = i16::MAX;
return self;
}
self.max_pos_vertical_speed = unscaled as i16;
self
}
pub fn max_neg_vertical_speed_scaled(&self) -> Option<f64> {
if self.max_neg_vertical_speed == i16::MAX {
return None;
}
Some(self.max_neg_vertical_speed as f64 / 1000.0 - 0.0)
}
pub fn set_max_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.max_neg_vertical_speed = i16::MAX;
return self;
}
self.max_neg_vertical_speed = unscaled as i16;
self
}
pub fn time_in_hr_zone_scaled(&self) -> Option<Vec<f64>> {
if self.time_in_hr_zone.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.time_in_hr_zone.len());
for &x in &self.time_in_hr_zone {
v.push(x as f64 / 1000.0 - 0.0)
}
Some(v)
}
pub fn set_time_in_hr_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
self.time_in_hr_zone = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.time_in_hr_zone.push(u32::MAX);
continue;
}
self.time_in_hr_zone.push(unscaled as u32);
}
self
}
pub fn time_in_speed_zone_scaled(&self) -> Option<Vec<f64>> {
if self.time_in_speed_zone.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.time_in_speed_zone.len());
for &x in &self.time_in_speed_zone {
v.push(x as f64 / 1000.0 - 0.0)
}
Some(v)
}
pub fn set_time_in_speed_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
self.time_in_speed_zone = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.time_in_speed_zone.push(u32::MAX);
continue;
}
self.time_in_speed_zone.push(unscaled as u32);
}
self
}
pub fn time_in_cadence_zone_scaled(&self) -> Option<Vec<f64>> {
if self.time_in_cadence_zone.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.time_in_cadence_zone.len());
for &x in &self.time_in_cadence_zone {
v.push(x as f64 / 1000.0 - 0.0)
}
Some(v)
}
pub fn set_time_in_cadence_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
self.time_in_cadence_zone = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.time_in_cadence_zone.push(u32::MAX);
continue;
}
self.time_in_cadence_zone.push(unscaled as u32);
}
self
}
pub fn time_in_power_zone_scaled(&self) -> Option<Vec<f64>> {
if self.time_in_power_zone.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.time_in_power_zone.len());
for &x in &self.time_in_power_zone {
v.push(x as f64 / 1000.0 - 0.0)
}
Some(v)
}
pub fn set_time_in_power_zone_scaled(&mut self, v: &[f64]) -> &mut Self {
self.time_in_power_zone = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.time_in_power_zone.push(u32::MAX);
continue;
}
self.time_in_power_zone.push(unscaled as u32);
}
self
}
pub fn min_altitude_scaled(&self) -> Option<f64> {
if self.min_altitude == u16::MAX {
return None;
}
Some(self.min_altitude as f64 / 5.0 - 500.0)
}
pub fn set_min_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.min_altitude = u16::MAX;
return self;
}
self.min_altitude = unscaled as u16;
self
}
pub fn active_time_scaled(&self) -> Option<f64> {
if self.active_time == u32::MAX {
return None;
}
Some(self.active_time as f64 / 1000.0 - 0.0)
}
pub fn set_active_time_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.active_time = u32::MAX;
return self;
}
self.active_time = unscaled as u32;
self
}
pub fn avg_vertical_oscillation_scaled(&self) -> Option<f64> {
if self.avg_vertical_oscillation == u16::MAX {
return None;
}
Some(self.avg_vertical_oscillation as f64 / 10.0 - 0.0)
}
pub fn set_avg_vertical_oscillation_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_vertical_oscillation = u16::MAX;
return self;
}
self.avg_vertical_oscillation = unscaled as u16;
self
}
pub fn avg_stance_time_percent_scaled(&self) -> Option<f64> {
if self.avg_stance_time_percent == u16::MAX {
return None;
}
Some(self.avg_stance_time_percent as f64 / 100.0 - 0.0)
}
pub fn set_avg_stance_time_percent_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_stance_time_percent = u16::MAX;
return self;
}
self.avg_stance_time_percent = unscaled as u16;
self
}
pub fn avg_stance_time_scaled(&self) -> Option<f64> {
if self.avg_stance_time == u16::MAX {
return None;
}
Some(self.avg_stance_time as f64 / 10.0 - 0.0)
}
pub fn set_avg_stance_time_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_stance_time = u16::MAX;
return self;
}
self.avg_stance_time = unscaled as u16;
self
}
pub fn avg_fractional_cadence_scaled(&self) -> Option<f64> {
if self.avg_fractional_cadence == u8::MAX {
return None;
}
Some(self.avg_fractional_cadence as f64 / 128.0 - 0.0)
}
pub fn set_avg_fractional_cadence_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_fractional_cadence = u8::MAX;
return self;
}
self.avg_fractional_cadence = unscaled as u8;
self
}
pub fn max_fractional_cadence_scaled(&self) -> Option<f64> {
if self.max_fractional_cadence == u8::MAX {
return None;
}
Some(self.max_fractional_cadence as f64 / 128.0 - 0.0)
}
pub fn set_max_fractional_cadence_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.max_fractional_cadence = u8::MAX;
return self;
}
self.max_fractional_cadence = unscaled as u8;
self
}
pub fn total_fractional_cycles_scaled(&self) -> Option<f64> {
if self.total_fractional_cycles == u8::MAX {
return None;
}
Some(self.total_fractional_cycles as f64 / 128.0 - 0.0)
}
pub fn set_total_fractional_cycles_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.total_fractional_cycles = u8::MAX;
return self;
}
self.total_fractional_cycles = unscaled as u8;
self
}
pub fn avg_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
if self.avg_total_hemoglobin_conc.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_total_hemoglobin_conc.len());
for &x in &self.avg_total_hemoglobin_conc {
v.push(x as f64 / 100.0 - 0.0)
}
Some(v)
}
pub fn set_avg_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_total_hemoglobin_conc = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_total_hemoglobin_conc.push(u16::MAX);
continue;
}
self.avg_total_hemoglobin_conc.push(unscaled as u16);
}
self
}
pub fn min_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
if self.min_total_hemoglobin_conc.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.min_total_hemoglobin_conc.len());
for &x in &self.min_total_hemoglobin_conc {
v.push(x as f64 / 100.0 - 0.0)
}
Some(v)
}
pub fn set_min_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
self.min_total_hemoglobin_conc = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.min_total_hemoglobin_conc.push(u16::MAX);
continue;
}
self.min_total_hemoglobin_conc.push(unscaled as u16);
}
self
}
pub fn max_total_hemoglobin_conc_scaled(&self) -> Option<Vec<f64>> {
if self.max_total_hemoglobin_conc.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.max_total_hemoglobin_conc.len());
for &x in &self.max_total_hemoglobin_conc {
v.push(x as f64 / 100.0 - 0.0)
}
Some(v)
}
pub fn set_max_total_hemoglobin_conc_scaled(&mut self, v: &[f64]) -> &mut Self {
self.max_total_hemoglobin_conc = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.max_total_hemoglobin_conc.push(u16::MAX);
continue;
}
self.max_total_hemoglobin_conc.push(unscaled as u16);
}
self
}
pub fn avg_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
if self.avg_saturated_hemoglobin_percent.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_saturated_hemoglobin_percent.len());
for &x in &self.avg_saturated_hemoglobin_percent {
v.push(x as f64 / 10.0 - 0.0)
}
Some(v)
}
pub fn set_avg_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_saturated_hemoglobin_percent.push(u16::MAX);
continue;
}
self.avg_saturated_hemoglobin_percent.push(unscaled as u16);
}
self
}
pub fn min_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
if self.min_saturated_hemoglobin_percent.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.min_saturated_hemoglobin_percent.len());
for &x in &self.min_saturated_hemoglobin_percent {
v.push(x as f64 / 10.0 - 0.0)
}
Some(v)
}
pub fn set_min_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
self.min_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.min_saturated_hemoglobin_percent.push(u16::MAX);
continue;
}
self.min_saturated_hemoglobin_percent.push(unscaled as u16);
}
self
}
pub fn max_saturated_hemoglobin_percent_scaled(&self) -> Option<Vec<f64>> {
if self.max_saturated_hemoglobin_percent.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.max_saturated_hemoglobin_percent.len());
for &x in &self.max_saturated_hemoglobin_percent {
v.push(x as f64 / 10.0 - 0.0)
}
Some(v)
}
pub fn set_max_saturated_hemoglobin_percent_scaled(&mut self, v: &[f64]) -> &mut Self {
self.max_saturated_hemoglobin_percent = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.max_saturated_hemoglobin_percent.push(u16::MAX);
continue;
}
self.max_saturated_hemoglobin_percent.push(unscaled as u16);
}
self
}
pub fn avg_left_torque_effectiveness_scaled(&self) -> Option<f64> {
if self.avg_left_torque_effectiveness == u8::MAX {
return None;
}
Some(self.avg_left_torque_effectiveness as f64 / 2.0 - 0.0)
}
pub fn set_avg_left_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_left_torque_effectiveness = u8::MAX;
return self;
}
self.avg_left_torque_effectiveness = unscaled as u8;
self
}
pub fn avg_right_torque_effectiveness_scaled(&self) -> Option<f64> {
if self.avg_right_torque_effectiveness == u8::MAX {
return None;
}
Some(self.avg_right_torque_effectiveness as f64 / 2.0 - 0.0)
}
pub fn set_avg_right_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_right_torque_effectiveness = u8::MAX;
return self;
}
self.avg_right_torque_effectiveness = unscaled as u8;
self
}
pub fn avg_left_pedal_smoothness_scaled(&self) -> Option<f64> {
if self.avg_left_pedal_smoothness == u8::MAX {
return None;
}
Some(self.avg_left_pedal_smoothness as f64 / 2.0 - 0.0)
}
pub fn set_avg_left_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_left_pedal_smoothness = u8::MAX;
return self;
}
self.avg_left_pedal_smoothness = unscaled as u8;
self
}
pub fn avg_right_pedal_smoothness_scaled(&self) -> Option<f64> {
if self.avg_right_pedal_smoothness == u8::MAX {
return None;
}
Some(self.avg_right_pedal_smoothness as f64 / 2.0 - 0.0)
}
pub fn set_avg_right_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_right_pedal_smoothness = u8::MAX;
return self;
}
self.avg_right_pedal_smoothness = unscaled as u8;
self
}
pub fn avg_combined_pedal_smoothness_scaled(&self) -> Option<f64> {
if self.avg_combined_pedal_smoothness == u8::MAX {
return None;
}
Some(self.avg_combined_pedal_smoothness as f64 / 2.0 - 0.0)
}
pub fn set_avg_combined_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_combined_pedal_smoothness = u8::MAX;
return self;
}
self.avg_combined_pedal_smoothness = unscaled as u8;
self
}
pub fn time_standing_scaled(&self) -> Option<f64> {
if self.time_standing == u32::MAX {
return None;
}
Some(self.time_standing as f64 / 1000.0 - 0.0)
}
pub fn set_time_standing_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.time_standing = u32::MAX;
return self;
}
self.time_standing = unscaled as u32;
self
}
pub fn avg_left_power_phase_scaled(&self) -> Option<Vec<f64>> {
if self.avg_left_power_phase.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_left_power_phase.len());
for &x in &self.avg_left_power_phase {
v.push(x as f64 / 0.7111111 - 0.0)
}
Some(v)
}
pub fn set_avg_left_power_phase_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_left_power_phase = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_left_power_phase.push(u8::MAX);
continue;
}
self.avg_left_power_phase.push(unscaled as u8);
}
self
}
pub fn avg_left_power_phase_peak_scaled(&self) -> Option<Vec<f64>> {
if self.avg_left_power_phase_peak.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_left_power_phase_peak.len());
for &x in &self.avg_left_power_phase_peak {
v.push(x as f64 / 0.7111111 - 0.0)
}
Some(v)
}
pub fn set_avg_left_power_phase_peak_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_left_power_phase_peak = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_left_power_phase_peak.push(u8::MAX);
continue;
}
self.avg_left_power_phase_peak.push(unscaled as u8);
}
self
}
pub fn avg_right_power_phase_scaled(&self) -> Option<Vec<f64>> {
if self.avg_right_power_phase.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_right_power_phase.len());
for &x in &self.avg_right_power_phase {
v.push(x as f64 / 0.7111111 - 0.0)
}
Some(v)
}
pub fn set_avg_right_power_phase_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_right_power_phase = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_right_power_phase.push(u8::MAX);
continue;
}
self.avg_right_power_phase.push(unscaled as u8);
}
self
}
pub fn avg_right_power_phase_peak_scaled(&self) -> Option<Vec<f64>> {
if self.avg_right_power_phase_peak.is_empty() {
return None;
}
let mut v = Vec::with_capacity(self.avg_right_power_phase_peak.len());
for &x in &self.avg_right_power_phase_peak {
v.push(x as f64 / 0.7111111 - 0.0)
}
Some(v)
}
pub fn set_avg_right_power_phase_peak_scaled(&mut self, v: &[f64]) -> &mut Self {
self.avg_right_power_phase_peak = Vec::with_capacity(v.len());
if v.is_empty() {
return self;
}
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.avg_right_power_phase_peak.push(u8::MAX);
continue;
}
self.avg_right_power_phase_peak.push(unscaled as u8);
}
self
}
pub fn enhanced_avg_speed_scaled(&self) -> Option<f64> {
if self.enhanced_avg_speed == u32::MAX {
return None;
}
Some(self.enhanced_avg_speed as f64 / 1000.0 - 0.0)
}
pub fn set_enhanced_avg_speed_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.enhanced_avg_speed = u32::MAX;
return self;
}
self.enhanced_avg_speed = unscaled as u32;
self
}
pub fn enhanced_max_speed_scaled(&self) -> Option<f64> {
if self.enhanced_max_speed == u32::MAX {
return None;
}
Some(self.enhanced_max_speed as f64 / 1000.0 - 0.0)
}
pub fn set_enhanced_max_speed_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.enhanced_max_speed = u32::MAX;
return self;
}
self.enhanced_max_speed = unscaled as u32;
self
}
pub fn enhanced_avg_altitude_scaled(&self) -> Option<f64> {
if self.enhanced_avg_altitude == u32::MAX {
return None;
}
Some(self.enhanced_avg_altitude as f64 / 5.0 - 500.0)
}
pub fn set_enhanced_avg_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.enhanced_avg_altitude = u32::MAX;
return self;
}
self.enhanced_avg_altitude = unscaled as u32;
self
}
pub fn enhanced_min_altitude_scaled(&self) -> Option<f64> {
if self.enhanced_min_altitude == u32::MAX {
return None;
}
Some(self.enhanced_min_altitude as f64 / 5.0 - 500.0)
}
pub fn set_enhanced_min_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.enhanced_min_altitude = u32::MAX;
return self;
}
self.enhanced_min_altitude = unscaled as u32;
self
}
pub fn enhanced_max_altitude_scaled(&self) -> Option<f64> {
if self.enhanced_max_altitude == u32::MAX {
return None;
}
Some(self.enhanced_max_altitude as f64 / 5.0 - 500.0)
}
pub fn set_enhanced_max_altitude_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.enhanced_max_altitude = u32::MAX;
return self;
}
self.enhanced_max_altitude = unscaled as u32;
self
}
pub fn lev_battery_consumption_scaled(&self) -> Option<f64> {
if self.lev_battery_consumption == u8::MAX {
return None;
}
Some(self.lev_battery_consumption as f64 / 2.0 - 0.0)
}
pub fn set_lev_battery_consumption_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.lev_battery_consumption = u8::MAX;
return self;
}
self.lev_battery_consumption = unscaled as u8;
self
}
pub fn avg_vertical_ratio_scaled(&self) -> Option<f64> {
if self.avg_vertical_ratio == u16::MAX {
return None;
}
Some(self.avg_vertical_ratio as f64 / 100.0 - 0.0)
}
pub fn set_avg_vertical_ratio_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_vertical_ratio = u16::MAX;
return self;
}
self.avg_vertical_ratio = unscaled as u16;
self
}
pub fn avg_stance_time_balance_scaled(&self) -> Option<f64> {
if self.avg_stance_time_balance == u16::MAX {
return None;
}
Some(self.avg_stance_time_balance as f64 / 100.0 - 0.0)
}
pub fn set_avg_stance_time_balance_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_stance_time_balance = u16::MAX;
return self;
}
self.avg_stance_time_balance = unscaled as u16;
self
}
pub fn avg_step_length_scaled(&self) -> Option<f64> {
if self.avg_step_length == u16::MAX {
return None;
}
Some(self.avg_step_length as f64 / 10.0 - 0.0)
}
pub fn set_avg_step_length_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_step_length = u16::MAX;
return self;
}
self.avg_step_length = unscaled as u16;
self
}
pub fn avg_vam_scaled(&self) -> Option<f64> {
if self.avg_vam == u16::MAX {
return None;
}
Some(self.avg_vam as f64 / 1000.0 - 0.0)
}
pub fn set_avg_vam_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_vam = u16::MAX;
return self;
}
self.avg_vam = unscaled as u16;
self
}
pub fn avg_depth_scaled(&self) -> Option<f64> {
if self.avg_depth == u32::MAX {
return None;
}
Some(self.avg_depth as f64 / 1000.0 - 0.0)
}
pub fn set_avg_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.avg_depth = u32::MAX;
return self;
}
self.avg_depth = unscaled as u32;
self
}
pub fn max_depth_scaled(&self) -> Option<f64> {
if self.max_depth == u32::MAX {
return None;
}
Some(self.max_depth as f64 / 1000.0 - 0.0)
}
pub fn set_max_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.max_depth = u32::MAX;
return self;
}
self.max_depth = unscaled as u32;
self
}
pub fn enhanced_avg_respiration_rate_scaled(&self) -> Option<f64> {
if self.enhanced_avg_respiration_rate == u16::MAX {
return None;
}
Some(self.enhanced_avg_respiration_rate as f64 / 100.0 - 0.0)
}
pub fn set_enhanced_avg_respiration_rate_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.enhanced_avg_respiration_rate = u16::MAX;
return self;
}
self.enhanced_avg_respiration_rate = unscaled as u16;
self
}
pub fn enhanced_max_respiration_rate_scaled(&self) -> Option<f64> {
if self.enhanced_max_respiration_rate == u16::MAX {
return None;
}
Some(self.enhanced_max_respiration_rate as f64 / 100.0 - 0.0)
}
pub fn set_enhanced_max_respiration_rate_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.enhanced_max_respiration_rate = u16::MAX;
return self;
}
self.enhanced_max_respiration_rate = unscaled as u16;
self
}
pub fn total_fractional_ascent_scaled(&self) -> Option<f64> {
if self.total_fractional_ascent == u8::MAX {
return None;
}
Some(self.total_fractional_ascent as f64 / 100.0 - 0.0)
}
pub fn set_total_fractional_ascent_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.total_fractional_ascent = u8::MAX;
return self;
}
self.total_fractional_ascent = unscaled as u8;
self
}
pub fn total_fractional_descent_scaled(&self) -> Option<f64> {
if self.total_fractional_descent == u8::MAX {
return None;
}
Some(self.total_fractional_descent as f64 / 100.0 - 0.0)
}
pub fn set_total_fractional_descent_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.total_fractional_descent = u8::MAX;
return self;
}
self.total_fractional_descent = unscaled as u8;
self
}
pub fn avg_core_temperature_scaled(&self) -> Option<f64> {
if self.avg_core_temperature == u16::MAX {
return None;
}
Some(self.avg_core_temperature as f64 / 100.0 - 0.0)
}
pub fn set_avg_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.avg_core_temperature = u16::MAX;
return self;
}
self.avg_core_temperature = unscaled as u16;
self
}
pub fn min_core_temperature_scaled(&self) -> Option<f64> {
if self.min_core_temperature == u16::MAX {
return None;
}
Some(self.min_core_temperature as f64 / 100.0 - 0.0)
}
pub fn set_min_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.min_core_temperature = u16::MAX;
return self;
}
self.min_core_temperature = unscaled as u16;
self
}
pub fn max_core_temperature_scaled(&self) -> Option<f64> {
if self.max_core_temperature == u16::MAX {
return None;
}
Some(self.max_core_temperature as f64 / 100.0 - 0.0)
}
pub fn set_max_core_temperature_scaled(&mut self, v: f64) -> &mut Self {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.max_core_temperature = u16::MAX;
return self;
}
self.max_core_temperature = unscaled as u16;
self
}
pub fn mark_as_expanded(&mut self, num: u8, flag: bool) -> bool {
match num {
110 | 111 | 112 | 113 | 114 | 136 | 137 => {
if flag {
self.state[num as usize >> 3] |= 1 << (num & 7)
} else {
self.state[num as usize >> 3] &= !(1 << (num & 7))
}
true
}
_ => false,
}
}
pub fn is_expanded(&self, num: u8) -> bool {
is_expanded(&self.state, num)
}
fn count_valid_fields(&self) -> usize {
(self.message_index.0 != u16::MAX) as usize
+ (self.timestamp.0 != u32::MAX) as usize
+ (self.event.0 != u8::MAX) as usize
+ (self.event_type.0 != u8::MAX) as usize
+ (self.start_time.0 != u32::MAX) as usize
+ (self.start_position_lat != i32::MAX) as usize
+ (self.start_position_long != i32::MAX) as usize
+ (self.end_position_lat != i32::MAX) as usize
+ (self.end_position_long != i32::MAX) as usize
+ (self.total_elapsed_time != u32::MAX) as usize
+ (self.total_timer_time != u32::MAX) as usize
+ (self.total_distance != u32::MAX) as usize
+ (self.total_cycles != u32::MAX) as usize
+ (self.total_calories != u16::MAX) as usize
+ (self.total_fat_calories != u16::MAX) as usize
+ (self.avg_speed != u16::MAX) as usize
+ (self.max_speed != u16::MAX) as usize
+ (self.avg_heart_rate != u8::MAX) as usize
+ (self.max_heart_rate != u8::MAX) as usize
+ (self.avg_cadence != u8::MAX) as usize
+ (self.max_cadence != u8::MAX) as usize
+ (self.avg_power != u16::MAX) as usize
+ (self.max_power != u16::MAX) as usize
+ (self.total_ascent != u16::MAX) as usize
+ (self.total_descent != u16::MAX) as usize
+ (self.intensity.0 != u8::MAX) as usize
+ (self.lap_trigger.0 != u8::MAX) as usize
+ (self.sport.0 != u8::MAX) as usize
+ (self.event_group != u8::MAX) as usize
+ (self.num_lengths != u16::MAX) as usize
+ (self.normalized_power != u16::MAX) as usize
+ (self.left_right_balance.0 != u16::MAX) as usize
+ (self.first_length_index != u16::MAX) as usize
+ (self.avg_stroke_distance != u16::MAX) as usize
+ (self.swim_stroke.0 != u8::MAX) as usize
+ (self.sub_sport.0 != u8::MAX) as usize
+ (self.num_active_lengths != u16::MAX) as usize
+ (self.total_work != u32::MAX) as usize
+ (self.avg_altitude != u16::MAX) as usize
+ (self.max_altitude != u16::MAX) as usize
+ (self.gps_accuracy != u8::MAX) as usize
+ (self.avg_grade != i16::MAX) as usize
+ (self.avg_pos_grade != i16::MAX) as usize
+ (self.avg_neg_grade != i16::MAX) as usize
+ (self.max_pos_grade != i16::MAX) as usize
+ (self.max_neg_grade != i16::MAX) as usize
+ (self.avg_temperature != i8::MAX) as usize
+ (self.max_temperature != i8::MAX) as usize
+ (self.total_moving_time != u32::MAX) as usize
+ (self.avg_pos_vertical_speed != i16::MAX) as usize
+ (self.avg_neg_vertical_speed != i16::MAX) as usize
+ (self.max_pos_vertical_speed != i16::MAX) as usize
+ (self.max_neg_vertical_speed != i16::MAX) as usize
+ (!self.time_in_hr_zone.is_empty()) as usize
+ (!self.time_in_speed_zone.is_empty()) as usize
+ (!self.time_in_cadence_zone.is_empty()) as usize
+ (!self.time_in_power_zone.is_empty()) as usize
+ (self.repetition_num != u16::MAX) as usize
+ (self.min_altitude != u16::MAX) as usize
+ (self.min_heart_rate != u8::MAX) as usize
+ (self.active_time != u32::MAX) as usize
+ (self.wkt_step_index.0 != u16::MAX) as usize
+ (self.opponent_score != u16::MAX) as usize
+ (!self.stroke_count.is_empty()) as usize
+ (!self.zone_count.is_empty()) as usize
+ (self.avg_vertical_oscillation != u16::MAX) as usize
+ (self.avg_stance_time_percent != u16::MAX) as usize
+ (self.avg_stance_time != u16::MAX) as usize
+ (self.avg_fractional_cadence != u8::MAX) as usize
+ (self.max_fractional_cadence != u8::MAX) as usize
+ (self.total_fractional_cycles != u8::MAX) as usize
+ (self.player_score != u16::MAX) as usize
+ (!self.avg_total_hemoglobin_conc.is_empty()) as usize
+ (!self.min_total_hemoglobin_conc.is_empty()) as usize
+ (!self.max_total_hemoglobin_conc.is_empty()) as usize
+ (!self.avg_saturated_hemoglobin_percent.is_empty()) as usize
+ (!self.min_saturated_hemoglobin_percent.is_empty()) as usize
+ (!self.max_saturated_hemoglobin_percent.is_empty()) as usize
+ (self.avg_left_torque_effectiveness != u8::MAX) as usize
+ (self.avg_right_torque_effectiveness != u8::MAX) as usize
+ (self.avg_left_pedal_smoothness != u8::MAX) as usize
+ (self.avg_right_pedal_smoothness != u8::MAX) as usize
+ (self.avg_combined_pedal_smoothness != u8::MAX) as usize
+ (self.time_standing != u32::MAX) as usize
+ (self.stand_count != u16::MAX) as usize
+ (self.avg_left_pco != i8::MAX) as usize
+ (self.avg_right_pco != i8::MAX) as usize
+ (!self.avg_left_power_phase.is_empty()) as usize
+ (!self.avg_left_power_phase_peak.is_empty()) as usize
+ (!self.avg_right_power_phase.is_empty()) as usize
+ (!self.avg_right_power_phase_peak.is_empty()) as usize
+ (!self.avg_power_position.is_empty()) as usize
+ (!self.max_power_position.is_empty()) as usize
+ (!self.avg_cadence_position.is_empty()) as usize
+ (!self.max_cadence_position.is_empty()) as usize
+ (self.enhanced_avg_speed != u32::MAX) as usize
+ (self.enhanced_max_speed != u32::MAX) as usize
+ (self.enhanced_avg_altitude != u32::MAX) as usize
+ (self.enhanced_min_altitude != u32::MAX) as usize
+ (self.enhanced_max_altitude != u32::MAX) as usize
+ (self.avg_lev_motor_power != u16::MAX) as usize
+ (self.max_lev_motor_power != u16::MAX) as usize
+ (self.lev_battery_consumption != u8::MAX) as usize
+ (self.avg_vertical_ratio != u16::MAX) as usize
+ (self.avg_stance_time_balance != u16::MAX) as usize
+ (self.avg_step_length != u16::MAX) as usize
+ (self.avg_vam != u16::MAX) as usize
+ (self.avg_depth != u32::MAX) as usize
+ (self.max_depth != u32::MAX) as usize
+ (self.min_temperature != i8::MAX) as usize
+ (self.enhanced_avg_respiration_rate != u16::MAX) as usize
+ (self.enhanced_max_respiration_rate != u16::MAX) as usize
+ (self.avg_respiration_rate != u8::MAX) as usize
+ (self.max_respiration_rate != u8::MAX) as usize
+ (self.total_grit.to_bits() != u32::MAX) as usize
+ (self.total_flow.to_bits() != u32::MAX) as usize
+ (self.jump_count != u16::MAX) as usize
+ (self.avg_grit.to_bits() != u32::MAX) as usize
+ (self.avg_flow.to_bits() != u32::MAX) as usize
+ (self.total_fractional_ascent != u8::MAX) as usize
+ (self.total_fractional_descent != u8::MAX) as usize
+ (self.avg_core_temperature != u16::MAX) as usize
+ (self.min_core_temperature != u16::MAX) as usize
+ (self.max_core_temperature != u16::MAX) as usize
}
}
impl Default for Lap {
fn default() -> Self {
Self::new()
}
}
impl From<&Message> for Lap {
fn from(mesg: &Message) -> Self {
const KNOWN_NUMS: [u64; 4] = [
18446744000829325311,
2305842996261682368,
8438416128,
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 {
254 => v.message_index = typedef::MessageIndex(field.value.as_u16()),
253 => v.timestamp = typedef::DateTime(field.value.as_u32()),
0 => v.event = typedef::Event(field.value.as_u8()),
1 => v.event_type = typedef::EventType(field.value.as_u8()),
2 => v.start_time = typedef::DateTime(field.value.as_u32()),
3 => v.start_position_lat = field.value.as_i32(),
4 => v.start_position_long = field.value.as_i32(),
5 => v.end_position_lat = field.value.as_i32(),
6 => v.end_position_long = field.value.as_i32(),
7 => v.total_elapsed_time = field.value.as_u32(),
8 => v.total_timer_time = field.value.as_u32(),
9 => v.total_distance = field.value.as_u32(),
10 => v.total_cycles = field.value.as_u32(),
11 => v.total_calories = field.value.as_u16(),
12 => v.total_fat_calories = field.value.as_u16(),
13 => v.avg_speed = field.value.as_u16(),
14 => v.max_speed = field.value.as_u16(),
15 => v.avg_heart_rate = field.value.as_u8(),
16 => v.max_heart_rate = field.value.as_u8(),
17 => v.avg_cadence = field.value.as_u8(),
18 => v.max_cadence = field.value.as_u8(),
19 => v.avg_power = field.value.as_u16(),
20 => v.max_power = field.value.as_u16(),
21 => v.total_ascent = field.value.as_u16(),
22 => v.total_descent = field.value.as_u16(),
23 => v.intensity = typedef::Intensity(field.value.as_u8()),
24 => v.lap_trigger = typedef::LapTrigger(field.value.as_u8()),
25 => v.sport = typedef::Sport(field.value.as_u8()),
26 => v.event_group = field.value.as_u8(),
32 => v.num_lengths = field.value.as_u16(),
33 => v.normalized_power = field.value.as_u16(),
34 => v.left_right_balance = typedef::LeftRightBalance100(field.value.as_u16()),
35 => v.first_length_index = field.value.as_u16(),
37 => v.avg_stroke_distance = field.value.as_u16(),
38 => v.swim_stroke = typedef::SwimStroke(field.value.as_u8()),
39 => v.sub_sport = typedef::SubSport(field.value.as_u8()),
40 => v.num_active_lengths = field.value.as_u16(),
41 => v.total_work = field.value.as_u32(),
42 => v.avg_altitude = field.value.as_u16(),
43 => v.max_altitude = field.value.as_u16(),
44 => v.gps_accuracy = field.value.as_u8(),
45 => v.avg_grade = field.value.as_i16(),
46 => v.avg_pos_grade = field.value.as_i16(),
47 => v.avg_neg_grade = field.value.as_i16(),
48 => v.max_pos_grade = field.value.as_i16(),
49 => v.max_neg_grade = field.value.as_i16(),
50 => v.avg_temperature = field.value.as_i8(),
51 => v.max_temperature = field.value.as_i8(),
52 => v.total_moving_time = field.value.as_u32(),
53 => v.avg_pos_vertical_speed = field.value.as_i16(),
54 => v.avg_neg_vertical_speed = field.value.as_i16(),
55 => v.max_pos_vertical_speed = field.value.as_i16(),
56 => v.max_neg_vertical_speed = field.value.as_i16(),
57 => v.time_in_hr_zone = field.value.to_vec_u32(),
58 => v.time_in_speed_zone = field.value.to_vec_u32(),
59 => v.time_in_cadence_zone = field.value.to_vec_u32(),
60 => v.time_in_power_zone = field.value.to_vec_u32(),
61 => v.repetition_num = field.value.as_u16(),
62 => v.min_altitude = field.value.as_u16(),
63 => v.min_heart_rate = field.value.as_u8(),
70 => v.active_time = field.value.as_u32(),
71 => v.wkt_step_index = typedef::MessageIndex(field.value.as_u16()),
74 => v.opponent_score = field.value.as_u16(),
75 => v.stroke_count = field.value.to_vec_u16(),
76 => v.zone_count = field.value.to_vec_u16(),
77 => v.avg_vertical_oscillation = field.value.as_u16(),
78 => v.avg_stance_time_percent = field.value.as_u16(),
79 => v.avg_stance_time = field.value.as_u16(),
80 => v.avg_fractional_cadence = field.value.as_u8(),
81 => v.max_fractional_cadence = field.value.as_u8(),
82 => v.total_fractional_cycles = field.value.as_u8(),
83 => v.player_score = field.value.as_u16(),
84 => v.avg_total_hemoglobin_conc = field.value.to_vec_u16(),
85 => v.min_total_hemoglobin_conc = field.value.to_vec_u16(),
86 => v.max_total_hemoglobin_conc = field.value.to_vec_u16(),
87 => v.avg_saturated_hemoglobin_percent = field.value.to_vec_u16(),
88 => v.min_saturated_hemoglobin_percent = field.value.to_vec_u16(),
89 => v.max_saturated_hemoglobin_percent = field.value.to_vec_u16(),
91 => v.avg_left_torque_effectiveness = field.value.as_u8(),
92 => v.avg_right_torque_effectiveness = field.value.as_u8(),
93 => v.avg_left_pedal_smoothness = field.value.as_u8(),
94 => v.avg_right_pedal_smoothness = field.value.as_u8(),
95 => v.avg_combined_pedal_smoothness = field.value.as_u8(),
98 => v.time_standing = field.value.as_u32(),
99 => v.stand_count = field.value.as_u16(),
100 => v.avg_left_pco = field.value.as_i8(),
101 => v.avg_right_pco = field.value.as_i8(),
102 => v.avg_left_power_phase = field.value.to_vec_u8(),
103 => v.avg_left_power_phase_peak = field.value.to_vec_u8(),
104 => v.avg_right_power_phase = field.value.to_vec_u8(),
105 => v.avg_right_power_phase_peak = field.value.to_vec_u8(),
106 => v.avg_power_position = field.value.to_vec_u16(),
107 => v.max_power_position = field.value.to_vec_u16(),
108 => v.avg_cadence_position = field.value.to_vec_u8(),
109 => v.max_cadence_position = field.value.to_vec_u8(),
110 => v.enhanced_avg_speed = field.value.as_u32(),
111 => v.enhanced_max_speed = field.value.as_u32(),
112 => v.enhanced_avg_altitude = field.value.as_u32(),
113 => v.enhanced_min_altitude = field.value.as_u32(),
114 => v.enhanced_max_altitude = field.value.as_u32(),
115 => v.avg_lev_motor_power = field.value.as_u16(),
116 => v.max_lev_motor_power = field.value.as_u16(),
117 => v.lev_battery_consumption = field.value.as_u8(),
118 => v.avg_vertical_ratio = field.value.as_u16(),
119 => v.avg_stance_time_balance = field.value.as_u16(),
120 => v.avg_step_length = field.value.as_u16(),
121 => v.avg_vam = field.value.as_u16(),
122 => v.avg_depth = field.value.as_u32(),
123 => v.max_depth = field.value.as_u32(),
124 => v.min_temperature = field.value.as_i8(),
136 => v.enhanced_avg_respiration_rate = field.value.as_u16(),
137 => v.enhanced_max_respiration_rate = field.value.as_u16(),
147 => v.avg_respiration_rate = field.value.as_u8(),
148 => v.max_respiration_rate = field.value.as_u8(),
149 => v.total_grit = field.value.as_f32(),
150 => v.total_flow = field.value.as_f32(),
151 => v.jump_count = field.value.as_u16(),
153 => v.avg_grit = field.value.as_f32(),
154 => v.avg_flow = field.value.as_f32(),
156 => v.total_fractional_ascent = field.value.as_u8(),
157 => v.total_fractional_descent = field.value.as_u8(),
158 => v.avg_core_temperature = field.value.as_u16(),
159 => v.min_core_temperature = field.value.as_u16(),
160 => v.max_core_temperature = field.value.as_u16(),
_ => {
v.unknown_fields.push(field.clone());
continue;
}
};
if field.is_expanded && field.num < 138 {
v.state[field.num as usize >> 3] |= 1 << (field.num & 7)
}
}
v
}
}
impl From<Lap> for Message {
fn from(m: Lap) -> Self {
let mut fields =
Vec::<Field>::with_capacity(m.count_valid_fields() + m.unknown_fields.len());
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.timestamp.0 != u32::MAX {
fields.push(Field {
num: 253,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.timestamp.0),
is_expanded: false,
});
};
if m.event.0 != u8::MAX {
fields.push(Field {
num: 0,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.event.0),
is_expanded: false,
});
};
if m.event_type.0 != u8::MAX {
fields.push(Field {
num: 1,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.event_type.0),
is_expanded: false,
});
};
if m.start_time.0 != u32::MAX {
fields.push(Field {
num: 2,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.start_time.0),
is_expanded: false,
});
};
if m.start_position_lat != i32::MAX {
fields.push(Field {
num: 3,
base_type: FitBaseType::SINT32,
value: Value::Int32(m.start_position_lat),
is_expanded: false,
});
};
if m.start_position_long != i32::MAX {
fields.push(Field {
num: 4,
base_type: FitBaseType::SINT32,
value: Value::Int32(m.start_position_long),
is_expanded: false,
});
};
if m.end_position_lat != i32::MAX {
fields.push(Field {
num: 5,
base_type: FitBaseType::SINT32,
value: Value::Int32(m.end_position_lat),
is_expanded: false,
});
};
if m.end_position_long != i32::MAX {
fields.push(Field {
num: 6,
base_type: FitBaseType::SINT32,
value: Value::Int32(m.end_position_long),
is_expanded: false,
});
};
if m.total_elapsed_time != u32::MAX {
fields.push(Field {
num: 7,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_elapsed_time),
is_expanded: false,
});
};
if m.total_timer_time != u32::MAX {
fields.push(Field {
num: 8,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_timer_time),
is_expanded: false,
});
};
if m.total_distance != u32::MAX {
fields.push(Field {
num: 9,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_distance),
is_expanded: false,
});
};
if m.total_cycles != u32::MAX {
fields.push(Field {
num: 10,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_cycles),
is_expanded: false,
});
};
if m.total_calories != u16::MAX {
fields.push(Field {
num: 11,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.total_calories),
is_expanded: false,
});
};
if m.total_fat_calories != u16::MAX {
fields.push(Field {
num: 12,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.total_fat_calories),
is_expanded: false,
});
};
if m.avg_speed != u16::MAX {
fields.push(Field {
num: 13,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_speed),
is_expanded: false,
});
};
if m.max_speed != u16::MAX {
fields.push(Field {
num: 14,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.max_speed),
is_expanded: false,
});
};
if m.avg_heart_rate != u8::MAX {
fields.push(Field {
num: 15,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_heart_rate),
is_expanded: false,
});
};
if m.max_heart_rate != u8::MAX {
fields.push(Field {
num: 16,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.max_heart_rate),
is_expanded: false,
});
};
if m.avg_cadence != u8::MAX {
fields.push(Field {
num: 17,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_cadence),
is_expanded: false,
});
};
if m.max_cadence != u8::MAX {
fields.push(Field {
num: 18,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.max_cadence),
is_expanded: false,
});
};
if m.avg_power != u16::MAX {
fields.push(Field {
num: 19,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_power),
is_expanded: false,
});
};
if m.max_power != u16::MAX {
fields.push(Field {
num: 20,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.max_power),
is_expanded: false,
});
};
if m.total_ascent != u16::MAX {
fields.push(Field {
num: 21,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.total_ascent),
is_expanded: false,
});
};
if m.total_descent != u16::MAX {
fields.push(Field {
num: 22,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.total_descent),
is_expanded: false,
});
};
if m.intensity.0 != u8::MAX {
fields.push(Field {
num: 23,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.intensity.0),
is_expanded: false,
});
};
if m.lap_trigger.0 != u8::MAX {
fields.push(Field {
num: 24,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.lap_trigger.0),
is_expanded: false,
});
};
if m.sport.0 != u8::MAX {
fields.push(Field {
num: 25,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.sport.0),
is_expanded: false,
});
};
if m.event_group != u8::MAX {
fields.push(Field {
num: 26,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.event_group),
is_expanded: false,
});
};
if m.num_lengths != u16::MAX {
fields.push(Field {
num: 32,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.num_lengths),
is_expanded: false,
});
};
if m.normalized_power != u16::MAX {
fields.push(Field {
num: 33,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.normalized_power),
is_expanded: false,
});
};
if m.left_right_balance.0 != u16::MAX {
fields.push(Field {
num: 34,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.left_right_balance.0),
is_expanded: false,
});
};
if m.first_length_index != u16::MAX {
fields.push(Field {
num: 35,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.first_length_index),
is_expanded: false,
});
};
if m.avg_stroke_distance != u16::MAX {
fields.push(Field {
num: 37,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_stroke_distance),
is_expanded: false,
});
};
if m.swim_stroke.0 != u8::MAX {
fields.push(Field {
num: 38,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.swim_stroke.0),
is_expanded: false,
});
};
if m.sub_sport.0 != u8::MAX {
fields.push(Field {
num: 39,
base_type: FitBaseType::ENUM,
value: Value::Uint8(m.sub_sport.0),
is_expanded: false,
});
};
if m.num_active_lengths != u16::MAX {
fields.push(Field {
num: 40,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.num_active_lengths),
is_expanded: false,
});
};
if m.total_work != u32::MAX {
fields.push(Field {
num: 41,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_work),
is_expanded: false,
});
};
if m.avg_altitude != u16::MAX {
fields.push(Field {
num: 42,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_altitude),
is_expanded: false,
});
};
if m.max_altitude != u16::MAX {
fields.push(Field {
num: 43,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.max_altitude),
is_expanded: false,
});
};
if m.gps_accuracy != u8::MAX {
fields.push(Field {
num: 44,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.gps_accuracy),
is_expanded: false,
});
};
if m.avg_grade != i16::MAX {
fields.push(Field {
num: 45,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.avg_grade),
is_expanded: false,
});
};
if m.avg_pos_grade != i16::MAX {
fields.push(Field {
num: 46,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.avg_pos_grade),
is_expanded: false,
});
};
if m.avg_neg_grade != i16::MAX {
fields.push(Field {
num: 47,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.avg_neg_grade),
is_expanded: false,
});
};
if m.max_pos_grade != i16::MAX {
fields.push(Field {
num: 48,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.max_pos_grade),
is_expanded: false,
});
};
if m.max_neg_grade != i16::MAX {
fields.push(Field {
num: 49,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.max_neg_grade),
is_expanded: false,
});
};
if m.avg_temperature != i8::MAX {
fields.push(Field {
num: 50,
base_type: FitBaseType::SINT8,
value: Value::Int8(m.avg_temperature),
is_expanded: false,
});
};
if m.max_temperature != i8::MAX {
fields.push(Field {
num: 51,
base_type: FitBaseType::SINT8,
value: Value::Int8(m.max_temperature),
is_expanded: false,
});
};
if m.total_moving_time != u32::MAX {
fields.push(Field {
num: 52,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.total_moving_time),
is_expanded: false,
});
};
if m.avg_pos_vertical_speed != i16::MAX {
fields.push(Field {
num: 53,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.avg_pos_vertical_speed),
is_expanded: false,
});
};
if m.avg_neg_vertical_speed != i16::MAX {
fields.push(Field {
num: 54,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.avg_neg_vertical_speed),
is_expanded: false,
});
};
if m.max_pos_vertical_speed != i16::MAX {
fields.push(Field {
num: 55,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.max_pos_vertical_speed),
is_expanded: false,
});
};
if m.max_neg_vertical_speed != i16::MAX {
fields.push(Field {
num: 56,
base_type: FitBaseType::SINT16,
value: Value::Int16(m.max_neg_vertical_speed),
is_expanded: false,
});
};
if !m.time_in_hr_zone.is_empty() {
fields.push(Field {
num: 57,
base_type: FitBaseType::UINT32,
value: Value::VecUint32(m.time_in_hr_zone),
is_expanded: false,
});
};
if !m.time_in_speed_zone.is_empty() {
fields.push(Field {
num: 58,
base_type: FitBaseType::UINT32,
value: Value::VecUint32(m.time_in_speed_zone),
is_expanded: false,
});
};
if !m.time_in_cadence_zone.is_empty() {
fields.push(Field {
num: 59,
base_type: FitBaseType::UINT32,
value: Value::VecUint32(m.time_in_cadence_zone),
is_expanded: false,
});
};
if !m.time_in_power_zone.is_empty() {
fields.push(Field {
num: 60,
base_type: FitBaseType::UINT32,
value: Value::VecUint32(m.time_in_power_zone),
is_expanded: false,
});
};
if m.repetition_num != u16::MAX {
fields.push(Field {
num: 61,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.repetition_num),
is_expanded: false,
});
};
if m.min_altitude != u16::MAX {
fields.push(Field {
num: 62,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.min_altitude),
is_expanded: false,
});
};
if m.min_heart_rate != u8::MAX {
fields.push(Field {
num: 63,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.min_heart_rate),
is_expanded: false,
});
};
if m.active_time != u32::MAX {
fields.push(Field {
num: 70,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.active_time),
is_expanded: false,
});
};
if m.wkt_step_index.0 != u16::MAX {
fields.push(Field {
num: 71,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.wkt_step_index.0),
is_expanded: false,
});
};
if m.opponent_score != u16::MAX {
fields.push(Field {
num: 74,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.opponent_score),
is_expanded: false,
});
};
if !m.stroke_count.is_empty() {
fields.push(Field {
num: 75,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.stroke_count),
is_expanded: false,
});
};
if !m.zone_count.is_empty() {
fields.push(Field {
num: 76,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.zone_count),
is_expanded: false,
});
};
if m.avg_vertical_oscillation != u16::MAX {
fields.push(Field {
num: 77,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_vertical_oscillation),
is_expanded: false,
});
};
if m.avg_stance_time_percent != u16::MAX {
fields.push(Field {
num: 78,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_stance_time_percent),
is_expanded: false,
});
};
if m.avg_stance_time != u16::MAX {
fields.push(Field {
num: 79,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_stance_time),
is_expanded: false,
});
};
if m.avg_fractional_cadence != u8::MAX {
fields.push(Field {
num: 80,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_fractional_cadence),
is_expanded: false,
});
};
if m.max_fractional_cadence != u8::MAX {
fields.push(Field {
num: 81,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.max_fractional_cadence),
is_expanded: false,
});
};
if m.total_fractional_cycles != u8::MAX {
fields.push(Field {
num: 82,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.total_fractional_cycles),
is_expanded: false,
});
};
if m.player_score != u16::MAX {
fields.push(Field {
num: 83,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.player_score),
is_expanded: false,
});
};
if !m.avg_total_hemoglobin_conc.is_empty() {
fields.push(Field {
num: 84,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.avg_total_hemoglobin_conc),
is_expanded: false,
});
};
if !m.min_total_hemoglobin_conc.is_empty() {
fields.push(Field {
num: 85,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.min_total_hemoglobin_conc),
is_expanded: false,
});
};
if !m.max_total_hemoglobin_conc.is_empty() {
fields.push(Field {
num: 86,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.max_total_hemoglobin_conc),
is_expanded: false,
});
};
if !m.avg_saturated_hemoglobin_percent.is_empty() {
fields.push(Field {
num: 87,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.avg_saturated_hemoglobin_percent),
is_expanded: false,
});
};
if !m.min_saturated_hemoglobin_percent.is_empty() {
fields.push(Field {
num: 88,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.min_saturated_hemoglobin_percent),
is_expanded: false,
});
};
if !m.max_saturated_hemoglobin_percent.is_empty() {
fields.push(Field {
num: 89,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.max_saturated_hemoglobin_percent),
is_expanded: false,
});
};
if m.avg_left_torque_effectiveness != u8::MAX {
fields.push(Field {
num: 91,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_left_torque_effectiveness),
is_expanded: false,
});
};
if m.avg_right_torque_effectiveness != u8::MAX {
fields.push(Field {
num: 92,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_right_torque_effectiveness),
is_expanded: false,
});
};
if m.avg_left_pedal_smoothness != u8::MAX {
fields.push(Field {
num: 93,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_left_pedal_smoothness),
is_expanded: false,
});
};
if m.avg_right_pedal_smoothness != u8::MAX {
fields.push(Field {
num: 94,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_right_pedal_smoothness),
is_expanded: false,
});
};
if m.avg_combined_pedal_smoothness != u8::MAX {
fields.push(Field {
num: 95,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_combined_pedal_smoothness),
is_expanded: false,
});
};
if m.time_standing != u32::MAX {
fields.push(Field {
num: 98,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.time_standing),
is_expanded: false,
});
};
if m.stand_count != u16::MAX {
fields.push(Field {
num: 99,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.stand_count),
is_expanded: false,
});
};
if m.avg_left_pco != i8::MAX {
fields.push(Field {
num: 100,
base_type: FitBaseType::SINT8,
value: Value::Int8(m.avg_left_pco),
is_expanded: false,
});
};
if m.avg_right_pco != i8::MAX {
fields.push(Field {
num: 101,
base_type: FitBaseType::SINT8,
value: Value::Int8(m.avg_right_pco),
is_expanded: false,
});
};
if !m.avg_left_power_phase.is_empty() {
fields.push(Field {
num: 102,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.avg_left_power_phase),
is_expanded: false,
});
};
if !m.avg_left_power_phase_peak.is_empty() {
fields.push(Field {
num: 103,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.avg_left_power_phase_peak),
is_expanded: false,
});
};
if !m.avg_right_power_phase.is_empty() {
fields.push(Field {
num: 104,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.avg_right_power_phase),
is_expanded: false,
});
};
if !m.avg_right_power_phase_peak.is_empty() {
fields.push(Field {
num: 105,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.avg_right_power_phase_peak),
is_expanded: false,
});
};
if !m.avg_power_position.is_empty() {
fields.push(Field {
num: 106,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.avg_power_position),
is_expanded: false,
});
};
if !m.max_power_position.is_empty() {
fields.push(Field {
num: 107,
base_type: FitBaseType::UINT16,
value: Value::VecUint16(m.max_power_position),
is_expanded: false,
});
};
if !m.avg_cadence_position.is_empty() {
fields.push(Field {
num: 108,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.avg_cadence_position),
is_expanded: false,
});
};
if !m.max_cadence_position.is_empty() {
fields.push(Field {
num: 109,
base_type: FitBaseType::UINT8,
value: Value::VecUint8(m.max_cadence_position),
is_expanded: false,
});
};
if m.enhanced_avg_speed != u32::MAX {
fields.push(Field {
num: 110,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.enhanced_avg_speed),
is_expanded: is_expanded(&m.state, 110),
});
};
if m.enhanced_max_speed != u32::MAX {
fields.push(Field {
num: 111,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.enhanced_max_speed),
is_expanded: is_expanded(&m.state, 111),
});
};
if m.enhanced_avg_altitude != u32::MAX {
fields.push(Field {
num: 112,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.enhanced_avg_altitude),
is_expanded: is_expanded(&m.state, 112),
});
};
if m.enhanced_min_altitude != u32::MAX {
fields.push(Field {
num: 113,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.enhanced_min_altitude),
is_expanded: is_expanded(&m.state, 113),
});
};
if m.enhanced_max_altitude != u32::MAX {
fields.push(Field {
num: 114,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.enhanced_max_altitude),
is_expanded: is_expanded(&m.state, 114),
});
};
if m.avg_lev_motor_power != u16::MAX {
fields.push(Field {
num: 115,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_lev_motor_power),
is_expanded: false,
});
};
if m.max_lev_motor_power != u16::MAX {
fields.push(Field {
num: 116,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.max_lev_motor_power),
is_expanded: false,
});
};
if m.lev_battery_consumption != u8::MAX {
fields.push(Field {
num: 117,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.lev_battery_consumption),
is_expanded: false,
});
};
if m.avg_vertical_ratio != u16::MAX {
fields.push(Field {
num: 118,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_vertical_ratio),
is_expanded: false,
});
};
if m.avg_stance_time_balance != u16::MAX {
fields.push(Field {
num: 119,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_stance_time_balance),
is_expanded: false,
});
};
if m.avg_step_length != u16::MAX {
fields.push(Field {
num: 120,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_step_length),
is_expanded: false,
});
};
if m.avg_vam != u16::MAX {
fields.push(Field {
num: 121,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_vam),
is_expanded: false,
});
};
if m.avg_depth != u32::MAX {
fields.push(Field {
num: 122,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.avg_depth),
is_expanded: false,
});
};
if m.max_depth != u32::MAX {
fields.push(Field {
num: 123,
base_type: FitBaseType::UINT32,
value: Value::Uint32(m.max_depth),
is_expanded: false,
});
};
if m.min_temperature != i8::MAX {
fields.push(Field {
num: 124,
base_type: FitBaseType::SINT8,
value: Value::Int8(m.min_temperature),
is_expanded: false,
});
};
if m.enhanced_avg_respiration_rate != u16::MAX {
fields.push(Field {
num: 136,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.enhanced_avg_respiration_rate),
is_expanded: is_expanded(&m.state, 136),
});
};
if m.enhanced_max_respiration_rate != u16::MAX {
fields.push(Field {
num: 137,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.enhanced_max_respiration_rate),
is_expanded: is_expanded(&m.state, 137),
});
};
if m.avg_respiration_rate != u8::MAX {
fields.push(Field {
num: 147,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.avg_respiration_rate),
is_expanded: false,
});
};
if m.max_respiration_rate != u8::MAX {
fields.push(Field {
num: 148,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.max_respiration_rate),
is_expanded: false,
});
};
if m.total_grit.to_bits() != u32::MAX {
fields.push(Field {
num: 149,
base_type: FitBaseType::FLOAT32,
value: Value::Float32(m.total_grit),
is_expanded: false,
});
};
if m.total_flow.to_bits() != u32::MAX {
fields.push(Field {
num: 150,
base_type: FitBaseType::FLOAT32,
value: Value::Float32(m.total_flow),
is_expanded: false,
});
};
if m.jump_count != u16::MAX {
fields.push(Field {
num: 151,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.jump_count),
is_expanded: false,
});
};
if m.avg_grit.to_bits() != u32::MAX {
fields.push(Field {
num: 153,
base_type: FitBaseType::FLOAT32,
value: Value::Float32(m.avg_grit),
is_expanded: false,
});
};
if m.avg_flow.to_bits() != u32::MAX {
fields.push(Field {
num: 154,
base_type: FitBaseType::FLOAT32,
value: Value::Float32(m.avg_flow),
is_expanded: false,
});
};
if m.total_fractional_ascent != u8::MAX {
fields.push(Field {
num: 156,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.total_fractional_ascent),
is_expanded: false,
});
};
if m.total_fractional_descent != u8::MAX {
fields.push(Field {
num: 157,
base_type: FitBaseType::UINT8,
value: Value::Uint8(m.total_fractional_descent),
is_expanded: false,
});
};
if m.avg_core_temperature != u16::MAX {
fields.push(Field {
num: 158,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.avg_core_temperature),
is_expanded: false,
});
};
if m.min_core_temperature != u16::MAX {
fields.push(Field {
num: 159,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.min_core_temperature),
is_expanded: false,
});
};
if m.max_core_temperature != u16::MAX {
fields.push(Field {
num: 160,
base_type: FitBaseType::UINT16,
value: Value::Uint16(m.max_core_temperature),
is_expanded: false,
});
};
fields.extend_from_slice(&m.unknown_fields);
Self {
header: 0,
num: typedef::MesgNum::LAP,
fields,
developer_fields: m.developer_fields,
}
}
}
#[cfg(feature = "serde")]
impl Serialize for Lap {
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("Lap", n)?;
if self.message_index.0 != u16::MAX {
state.serialize_field("message_index", &self.message_index)?;
}
if let Some(v) = self.timestamp.unix_timestamp() {
state.serialize_field("timestamp", &v)?;
}
if self.event.0 != u8::MAX {
state.serialize_field("event", &self.event)?;
}
if self.event_type.0 != u8::MAX {
state.serialize_field("event_type", &self.event_type)?;
}
if let Some(v) = self.start_time.unix_timestamp() {
state.serialize_field("start_time", &v)?;
}
if let Some(v) = self.start_position_lat_degrees() {
state.serialize_field("start_position_lat", &v)?;
}
if let Some(v) = self.start_position_long_degrees() {
state.serialize_field("start_position_long", &v)?;
}
if let Some(v) = self.end_position_lat_degrees() {
state.serialize_field("end_position_lat", &v)?;
}
if let Some(v) = self.end_position_long_degrees() {
state.serialize_field("end_position_long", &v)?;
}
if let Some(v) = self.total_elapsed_time_scaled() {
state.serialize_field("total_elapsed_time", &v)?;
}
if let Some(v) = self.total_timer_time_scaled() {
state.serialize_field("total_timer_time", &v)?;
}
if let Some(v) = self.total_distance_scaled() {
state.serialize_field("total_distance", &v)?;
}
if self.total_cycles != u32::MAX {
state.serialize_field("total_cycles", &self.total_cycles)?;
}
if self.total_calories != u16::MAX {
state.serialize_field("total_calories", &self.total_calories)?;
}
if self.total_fat_calories != u16::MAX {
state.serialize_field("total_fat_calories", &self.total_fat_calories)?;
}
if let Some(v) = self.avg_speed_scaled() {
state.serialize_field("avg_speed", &v)?;
}
if let Some(v) = self.max_speed_scaled() {
state.serialize_field("max_speed", &v)?;
}
if self.avg_heart_rate != u8::MAX {
state.serialize_field("avg_heart_rate", &self.avg_heart_rate)?;
}
if self.max_heart_rate != u8::MAX {
state.serialize_field("max_heart_rate", &self.max_heart_rate)?;
}
if self.avg_cadence != u8::MAX {
state.serialize_field("avg_cadence", &self.avg_cadence)?;
}
if self.max_cadence != u8::MAX {
state.serialize_field("max_cadence", &self.max_cadence)?;
}
if self.avg_power != u16::MAX {
state.serialize_field("avg_power", &self.avg_power)?;
}
if self.max_power != u16::MAX {
state.serialize_field("max_power", &self.max_power)?;
}
if self.total_ascent != u16::MAX {
state.serialize_field("total_ascent", &self.total_ascent)?;
}
if self.total_descent != u16::MAX {
state.serialize_field("total_descent", &self.total_descent)?;
}
if self.intensity.0 != u8::MAX {
state.serialize_field("intensity", &self.intensity)?;
}
if self.lap_trigger.0 != u8::MAX {
state.serialize_field("lap_trigger", &self.lap_trigger)?;
}
if self.sport.0 != u8::MAX {
state.serialize_field("sport", &self.sport)?;
}
if self.event_group != u8::MAX {
state.serialize_field("event_group", &self.event_group)?;
}
if self.num_lengths != u16::MAX {
state.serialize_field("num_lengths", &self.num_lengths)?;
}
if self.normalized_power != u16::MAX {
state.serialize_field("normalized_power", &self.normalized_power)?;
}
if self.left_right_balance.0 != u16::MAX {
state.serialize_field("left_right_balance", &self.left_right_balance)?;
}
if self.first_length_index != u16::MAX {
state.serialize_field("first_length_index", &self.first_length_index)?;
}
if let Some(v) = self.avg_stroke_distance_scaled() {
state.serialize_field("avg_stroke_distance", &v)?;
}
if self.swim_stroke.0 != u8::MAX {
state.serialize_field("swim_stroke", &self.swim_stroke)?;
}
if self.sub_sport.0 != u8::MAX {
state.serialize_field("sub_sport", &self.sub_sport)?;
}
if self.num_active_lengths != u16::MAX {
state.serialize_field("num_active_lengths", &self.num_active_lengths)?;
}
if self.total_work != u32::MAX {
state.serialize_field("total_work", &self.total_work)?;
}
if let Some(v) = self.avg_altitude_scaled() {
state.serialize_field("avg_altitude", &v)?;
}
if let Some(v) = self.max_altitude_scaled() {
state.serialize_field("max_altitude", &v)?;
}
if self.gps_accuracy != u8::MAX {
state.serialize_field("gps_accuracy", &self.gps_accuracy)?;
}
if let Some(v) = self.avg_grade_scaled() {
state.serialize_field("avg_grade", &v)?;
}
if let Some(v) = self.avg_pos_grade_scaled() {
state.serialize_field("avg_pos_grade", &v)?;
}
if let Some(v) = self.avg_neg_grade_scaled() {
state.serialize_field("avg_neg_grade", &v)?;
}
if let Some(v) = self.max_pos_grade_scaled() {
state.serialize_field("max_pos_grade", &v)?;
}
if let Some(v) = self.max_neg_grade_scaled() {
state.serialize_field("max_neg_grade", &v)?;
}
if self.avg_temperature != i8::MAX {
state.serialize_field("avg_temperature", &self.avg_temperature)?;
}
if self.max_temperature != i8::MAX {
state.serialize_field("max_temperature", &self.max_temperature)?;
}
if let Some(v) = self.total_moving_time_scaled() {
state.serialize_field("total_moving_time", &v)?;
}
if let Some(v) = self.avg_pos_vertical_speed_scaled() {
state.serialize_field("avg_pos_vertical_speed", &v)?;
}
if let Some(v) = self.avg_neg_vertical_speed_scaled() {
state.serialize_field("avg_neg_vertical_speed", &v)?;
}
if let Some(v) = self.max_pos_vertical_speed_scaled() {
state.serialize_field("max_pos_vertical_speed", &v)?;
}
if let Some(v) = self.max_neg_vertical_speed_scaled() {
state.serialize_field("max_neg_vertical_speed", &v)?;
}
if let Some(v) = self.time_in_hr_zone_scaled() {
state.serialize_field("time_in_hr_zone", &v)?;
}
if let Some(v) = self.time_in_speed_zone_scaled() {
state.serialize_field("time_in_speed_zone", &v)?;
}
if let Some(v) = self.time_in_cadence_zone_scaled() {
state.serialize_field("time_in_cadence_zone", &v)?;
}
if let Some(v) = self.time_in_power_zone_scaled() {
state.serialize_field("time_in_power_zone", &v)?;
}
if self.repetition_num != u16::MAX {
state.serialize_field("repetition_num", &self.repetition_num)?;
}
if let Some(v) = self.min_altitude_scaled() {
state.serialize_field("min_altitude", &v)?;
}
if self.min_heart_rate != u8::MAX {
state.serialize_field("min_heart_rate", &self.min_heart_rate)?;
}
if let Some(v) = self.active_time_scaled() {
state.serialize_field("active_time", &v)?;
}
if self.wkt_step_index.0 != u16::MAX {
state.serialize_field("wkt_step_index", &self.wkt_step_index)?;
}
if self.opponent_score != u16::MAX {
state.serialize_field("opponent_score", &self.opponent_score)?;
}
if !self.stroke_count.is_empty() {
state.serialize_field("stroke_count", &self.stroke_count)?;
}
if !self.zone_count.is_empty() {
state.serialize_field("zone_count", &self.zone_count)?;
}
if let Some(v) = self.avg_vertical_oscillation_scaled() {
state.serialize_field("avg_vertical_oscillation", &v)?;
}
if let Some(v) = self.avg_stance_time_percent_scaled() {
state.serialize_field("avg_stance_time_percent", &v)?;
}
if let Some(v) = self.avg_stance_time_scaled() {
state.serialize_field("avg_stance_time", &v)?;
}
if let Some(v) = self.avg_fractional_cadence_scaled() {
state.serialize_field("avg_fractional_cadence", &v)?;
}
if let Some(v) = self.max_fractional_cadence_scaled() {
state.serialize_field("max_fractional_cadence", &v)?;
}
if let Some(v) = self.total_fractional_cycles_scaled() {
state.serialize_field("total_fractional_cycles", &v)?;
}
if self.player_score != u16::MAX {
state.serialize_field("player_score", &self.player_score)?;
}
if let Some(v) = self.avg_total_hemoglobin_conc_scaled() {
state.serialize_field("avg_total_hemoglobin_conc", &v)?;
}
if let Some(v) = self.min_total_hemoglobin_conc_scaled() {
state.serialize_field("min_total_hemoglobin_conc", &v)?;
}
if let Some(v) = self.max_total_hemoglobin_conc_scaled() {
state.serialize_field("max_total_hemoglobin_conc", &v)?;
}
if let Some(v) = self.avg_saturated_hemoglobin_percent_scaled() {
state.serialize_field("avg_saturated_hemoglobin_percent", &v)?;
}
if let Some(v) = self.min_saturated_hemoglobin_percent_scaled() {
state.serialize_field("min_saturated_hemoglobin_percent", &v)?;
}
if let Some(v) = self.max_saturated_hemoglobin_percent_scaled() {
state.serialize_field("max_saturated_hemoglobin_percent", &v)?;
}
if let Some(v) = self.avg_left_torque_effectiveness_scaled() {
state.serialize_field("avg_left_torque_effectiveness", &v)?;
}
if let Some(v) = self.avg_right_torque_effectiveness_scaled() {
state.serialize_field("avg_right_torque_effectiveness", &v)?;
}
if let Some(v) = self.avg_left_pedal_smoothness_scaled() {
state.serialize_field("avg_left_pedal_smoothness", &v)?;
}
if let Some(v) = self.avg_right_pedal_smoothness_scaled() {
state.serialize_field("avg_right_pedal_smoothness", &v)?;
}
if let Some(v) = self.avg_combined_pedal_smoothness_scaled() {
state.serialize_field("avg_combined_pedal_smoothness", &v)?;
}
if let Some(v) = self.time_standing_scaled() {
state.serialize_field("time_standing", &v)?;
}
if self.stand_count != u16::MAX {
state.serialize_field("stand_count", &self.stand_count)?;
}
if self.avg_left_pco != i8::MAX {
state.serialize_field("avg_left_pco", &self.avg_left_pco)?;
}
if self.avg_right_pco != i8::MAX {
state.serialize_field("avg_right_pco", &self.avg_right_pco)?;
}
if let Some(v) = self.avg_left_power_phase_scaled() {
state.serialize_field("avg_left_power_phase", &v)?;
}
if let Some(v) = self.avg_left_power_phase_peak_scaled() {
state.serialize_field("avg_left_power_phase_peak", &v)?;
}
if let Some(v) = self.avg_right_power_phase_scaled() {
state.serialize_field("avg_right_power_phase", &v)?;
}
if let Some(v) = self.avg_right_power_phase_peak_scaled() {
state.serialize_field("avg_right_power_phase_peak", &v)?;
}
if !self.avg_power_position.is_empty() {
state.serialize_field("avg_power_position", &self.avg_power_position)?;
}
if !self.max_power_position.is_empty() {
state.serialize_field("max_power_position", &self.max_power_position)?;
}
if !self.avg_cadence_position.is_empty() {
state.serialize_field("avg_cadence_position", &self.avg_cadence_position)?;
}
if !self.max_cadence_position.is_empty() {
state.serialize_field("max_cadence_position", &self.max_cadence_position)?;
}
if let Some(v) = self.enhanced_avg_speed_scaled() {
state.serialize_field("enhanced_avg_speed", &v)?;
}
if let Some(v) = self.enhanced_max_speed_scaled() {
state.serialize_field("enhanced_max_speed", &v)?;
}
if let Some(v) = self.enhanced_avg_altitude_scaled() {
state.serialize_field("enhanced_avg_altitude", &v)?;
}
if let Some(v) = self.enhanced_min_altitude_scaled() {
state.serialize_field("enhanced_min_altitude", &v)?;
}
if let Some(v) = self.enhanced_max_altitude_scaled() {
state.serialize_field("enhanced_max_altitude", &v)?;
}
if self.avg_lev_motor_power != u16::MAX {
state.serialize_field("avg_lev_motor_power", &self.avg_lev_motor_power)?;
}
if self.max_lev_motor_power != u16::MAX {
state.serialize_field("max_lev_motor_power", &self.max_lev_motor_power)?;
}
if let Some(v) = self.lev_battery_consumption_scaled() {
state.serialize_field("lev_battery_consumption", &v)?;
}
if let Some(v) = self.avg_vertical_ratio_scaled() {
state.serialize_field("avg_vertical_ratio", &v)?;
}
if let Some(v) = self.avg_stance_time_balance_scaled() {
state.serialize_field("avg_stance_time_balance", &v)?;
}
if let Some(v) = self.avg_step_length_scaled() {
state.serialize_field("avg_step_length", &v)?;
}
if let Some(v) = self.avg_vam_scaled() {
state.serialize_field("avg_vam", &v)?;
}
if let Some(v) = self.avg_depth_scaled() {
state.serialize_field("avg_depth", &v)?;
}
if let Some(v) = self.max_depth_scaled() {
state.serialize_field("max_depth", &v)?;
}
if self.min_temperature != i8::MAX {
state.serialize_field("min_temperature", &self.min_temperature)?;
}
if let Some(v) = self.enhanced_avg_respiration_rate_scaled() {
state.serialize_field("enhanced_avg_respiration_rate", &v)?;
}
if let Some(v) = self.enhanced_max_respiration_rate_scaled() {
state.serialize_field("enhanced_max_respiration_rate", &v)?;
}
if self.avg_respiration_rate != u8::MAX {
state.serialize_field("avg_respiration_rate", &self.avg_respiration_rate)?;
}
if self.max_respiration_rate != u8::MAX {
state.serialize_field("max_respiration_rate", &self.max_respiration_rate)?;
}
if self.total_grit.to_bits() != u32::MAX {
state.serialize_field("total_grit", &self.total_grit)?;
}
if self.total_flow.to_bits() != u32::MAX {
state.serialize_field("total_flow", &self.total_flow)?;
}
if self.jump_count != u16::MAX {
state.serialize_field("jump_count", &self.jump_count)?;
}
if self.avg_grit.to_bits() != u32::MAX {
state.serialize_field("avg_grit", &self.avg_grit)?;
}
if self.avg_flow.to_bits() != u32::MAX {
state.serialize_field("avg_flow", &self.avg_flow)?;
}
if let Some(v) = self.total_fractional_ascent_scaled() {
state.serialize_field("total_fractional_ascent", &v)?;
}
if let Some(v) = self.total_fractional_descent_scaled() {
state.serialize_field("total_fractional_descent", &v)?;
}
if let Some(v) = self.avg_core_temperature_scaled() {
state.serialize_field("avg_core_temperature", &v)?;
}
if let Some(v) = self.min_core_temperature_scaled() {
state.serialize_field("min_core_temperature", &v)?;
}
if let Some(v) = self.max_core_temperature_scaled() {
state.serialize_field("max_core_temperature", &v)?;
}
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 {
message_index: typedef::MessageIndex,
timestamp: Option<i64>,
event: typedef::Event,
event_type: typedef::EventType,
start_time: Option<i64>,
start_position_lat: f64,
start_position_long: f64,
end_position_lat: f64,
end_position_long: f64,
total_elapsed_time: f64,
total_timer_time: f64,
total_distance: f64,
total_cycles: u32,
total_calories: u16,
total_fat_calories: u16,
avg_speed: f64,
max_speed: f64,
avg_heart_rate: u8,
max_heart_rate: u8,
avg_cadence: u8,
max_cadence: u8,
avg_power: u16,
max_power: u16,
total_ascent: u16,
total_descent: u16,
intensity: typedef::Intensity,
lap_trigger: typedef::LapTrigger,
sport: typedef::Sport,
event_group: u8,
num_lengths: u16,
normalized_power: u16,
left_right_balance: typedef::LeftRightBalance100,
first_length_index: u16,
avg_stroke_distance: f64,
swim_stroke: typedef::SwimStroke,
sub_sport: typedef::SubSport,
num_active_lengths: u16,
total_work: u32,
avg_altitude: f64,
max_altitude: f64,
gps_accuracy: u8,
avg_grade: f64,
avg_pos_grade: f64,
avg_neg_grade: f64,
max_pos_grade: f64,
max_neg_grade: f64,
avg_temperature: i8,
max_temperature: i8,
total_moving_time: f64,
avg_pos_vertical_speed: f64,
avg_neg_vertical_speed: f64,
max_pos_vertical_speed: f64,
max_neg_vertical_speed: f64,
time_in_hr_zone: Vec<f64>,
time_in_speed_zone: Vec<f64>,
time_in_cadence_zone: Vec<f64>,
time_in_power_zone: Vec<f64>,
repetition_num: u16,
min_altitude: f64,
min_heart_rate: u8,
active_time: f64,
wkt_step_index: typedef::MessageIndex,
opponent_score: u16,
stroke_count: Vec<u16>,
zone_count: Vec<u16>,
avg_vertical_oscillation: f64,
avg_stance_time_percent: f64,
avg_stance_time: f64,
avg_fractional_cadence: f64,
max_fractional_cadence: f64,
total_fractional_cycles: f64,
player_score: u16,
avg_total_hemoglobin_conc: Vec<f64>,
min_total_hemoglobin_conc: Vec<f64>,
max_total_hemoglobin_conc: Vec<f64>,
avg_saturated_hemoglobin_percent: Vec<f64>,
min_saturated_hemoglobin_percent: Vec<f64>,
max_saturated_hemoglobin_percent: Vec<f64>,
avg_left_torque_effectiveness: f64,
avg_right_torque_effectiveness: f64,
avg_left_pedal_smoothness: f64,
avg_right_pedal_smoothness: f64,
avg_combined_pedal_smoothness: f64,
time_standing: f64,
stand_count: u16,
avg_left_pco: i8,
avg_right_pco: i8,
avg_left_power_phase: Vec<f64>,
avg_left_power_phase_peak: Vec<f64>,
avg_right_power_phase: Vec<f64>,
avg_right_power_phase_peak: Vec<f64>,
avg_power_position: Vec<u16>,
max_power_position: Vec<u16>,
avg_cadence_position: Vec<u8>,
max_cadence_position: Vec<u8>,
enhanced_avg_speed: f64,
enhanced_max_speed: f64,
enhanced_avg_altitude: f64,
enhanced_min_altitude: f64,
enhanced_max_altitude: f64,
avg_lev_motor_power: u16,
max_lev_motor_power: u16,
lev_battery_consumption: f64,
avg_vertical_ratio: f64,
avg_stance_time_balance: f64,
avg_step_length: f64,
avg_vam: f64,
avg_depth: f64,
max_depth: f64,
min_temperature: i8,
enhanced_avg_respiration_rate: f64,
enhanced_max_respiration_rate: f64,
avg_respiration_rate: u8,
max_respiration_rate: u8,
total_grit: f32,
total_flow: f32,
jump_count: u16,
avg_grit: f32,
avg_flow: f32,
total_fractional_ascent: f64,
total_fractional_descent: f64,
avg_core_temperature: f64,
min_core_temperature: f64,
max_core_temperature: f64,
unknown_fields: Vec<Field>,
developer_fields: Vec<DeveloperField>,
}
#[cfg(feature = "serde")]
impl From<De> for Lap {
fn from(m: De) -> Self {
Self {
message_index: m.message_index,
timestamp: m.timestamp.map_or_else(
|| typedef::DateTime(u32::MAX),
typedef::DateTime::from_unix_timestamp,
),
event: m.event,
event_type: m.event_type,
start_time: m.start_time.map_or_else(
|| typedef::DateTime(u32::MAX),
typedef::DateTime::from_unix_timestamp,
),
start_position_lat: semconv::to_semicircles(m.start_position_lat).unwrap_or(i32::MAX),
start_position_long: semconv::to_semicircles(m.start_position_long).unwrap_or(i32::MAX),
end_position_lat: semconv::to_semicircles(m.end_position_lat).unwrap_or(i32::MAX),
end_position_long: semconv::to_semicircles(m.end_position_long).unwrap_or(i32::MAX),
total_elapsed_time: {
let unscaled = (m.total_elapsed_time + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
total_timer_time: {
let unscaled = (m.total_timer_time + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
total_distance: {
let unscaled = (m.total_distance + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
total_cycles: m.total_cycles,
total_calories: m.total_calories,
total_fat_calories: m.total_fat_calories,
avg_speed: {
let unscaled = (m.avg_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
max_speed: {
let unscaled = (m.max_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_heart_rate: m.avg_heart_rate,
max_heart_rate: m.max_heart_rate,
avg_cadence: m.avg_cadence,
max_cadence: m.max_cadence,
avg_power: m.avg_power,
max_power: m.max_power,
total_ascent: m.total_ascent,
total_descent: m.total_descent,
intensity: m.intensity,
lap_trigger: m.lap_trigger,
sport: m.sport,
event_group: m.event_group,
num_lengths: m.num_lengths,
normalized_power: m.normalized_power,
left_right_balance: m.left_right_balance,
first_length_index: m.first_length_index,
avg_stroke_distance: {
let unscaled = (m.avg_stroke_distance + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
swim_stroke: m.swim_stroke,
sub_sport: m.sub_sport,
num_active_lengths: m.num_active_lengths,
total_work: m.total_work,
avg_altitude: {
let unscaled = (m.avg_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
max_altitude: {
let unscaled = (m.max_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
gps_accuracy: m.gps_accuracy,
avg_grade: {
let unscaled = (m.avg_grade + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
avg_pos_grade: {
let unscaled = (m.avg_pos_grade + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
avg_neg_grade: {
let unscaled = (m.avg_neg_grade + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
max_pos_grade: {
let unscaled = (m.max_pos_grade + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
max_neg_grade: {
let unscaled = (m.max_neg_grade + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
avg_temperature: m.avg_temperature,
max_temperature: m.max_temperature,
total_moving_time: {
let unscaled = (m.total_moving_time + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
avg_pos_vertical_speed: {
let unscaled = (m.avg_pos_vertical_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
avg_neg_vertical_speed: {
let unscaled = (m.avg_neg_vertical_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
max_pos_vertical_speed: {
let unscaled = (m.max_pos_vertical_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
max_neg_vertical_speed: {
let unscaled = (m.max_neg_vertical_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
i16::MAX
} else {
unscaled as i16
}
},
time_in_hr_zone: {
if m.time_in_hr_zone.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.time_in_hr_zone.len());
for &x in m.time_in_hr_zone.iter() {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
{
vals.push(u32::MAX);
continue;
}
vals.push(unscaled as u32);
}
vals
}
},
time_in_speed_zone: {
if m.time_in_speed_zone.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.time_in_speed_zone.len());
for &x in m.time_in_speed_zone.iter() {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
{
vals.push(u32::MAX);
continue;
}
vals.push(unscaled as u32);
}
vals
}
},
time_in_cadence_zone: {
if m.time_in_cadence_zone.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.time_in_cadence_zone.len());
for &x in m.time_in_cadence_zone.iter() {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
{
vals.push(u32::MAX);
continue;
}
vals.push(unscaled as u32);
}
vals
}
},
time_in_power_zone: {
if m.time_in_power_zone.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.time_in_power_zone.len());
for &x in m.time_in_power_zone.iter() {
let unscaled = (x + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64
{
vals.push(u32::MAX);
continue;
}
vals.push(unscaled as u32);
}
vals
}
},
repetition_num: m.repetition_num,
min_altitude: {
let unscaled = (m.min_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
min_heart_rate: m.min_heart_rate,
active_time: {
let unscaled = (m.active_time + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
wkt_step_index: m.wkt_step_index,
opponent_score: m.opponent_score,
stroke_count: m.stroke_count,
zone_count: m.zone_count,
avg_vertical_oscillation: {
let unscaled = (m.avg_vertical_oscillation + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_stance_time_percent: {
let unscaled = (m.avg_stance_time_percent + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_stance_time: {
let unscaled = (m.avg_stance_time + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_fractional_cadence: {
let unscaled = (m.avg_fractional_cadence + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
max_fractional_cadence: {
let unscaled = (m.max_fractional_cadence + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
total_fractional_cycles: {
let unscaled = (m.total_fractional_cycles + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
player_score: m.player_score,
avg_total_hemoglobin_conc: {
if m.avg_total_hemoglobin_conc.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_total_hemoglobin_conc.len());
for &x in m.avg_total_hemoglobin_conc.iter() {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
min_total_hemoglobin_conc: {
if m.min_total_hemoglobin_conc.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.min_total_hemoglobin_conc.len());
for &x in m.min_total_hemoglobin_conc.iter() {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
max_total_hemoglobin_conc: {
if m.max_total_hemoglobin_conc.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.max_total_hemoglobin_conc.len());
for &x in m.max_total_hemoglobin_conc.iter() {
let unscaled = (x + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
avg_saturated_hemoglobin_percent: {
if m.avg_saturated_hemoglobin_percent.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_saturated_hemoglobin_percent.len());
for &x in m.avg_saturated_hemoglobin_percent.iter() {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
min_saturated_hemoglobin_percent: {
if m.min_saturated_hemoglobin_percent.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.min_saturated_hemoglobin_percent.len());
for &x in m.min_saturated_hemoglobin_percent.iter() {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
max_saturated_hemoglobin_percent: {
if m.max_saturated_hemoglobin_percent.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.max_saturated_hemoglobin_percent.len());
for &x in m.max_saturated_hemoglobin_percent.iter() {
let unscaled = (x + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64
{
vals.push(u16::MAX);
continue;
}
vals.push(unscaled as u16);
}
vals
}
},
avg_left_torque_effectiveness: {
let unscaled = (m.avg_left_torque_effectiveness + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_right_torque_effectiveness: {
let unscaled = (m.avg_right_torque_effectiveness + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_left_pedal_smoothness: {
let unscaled = (m.avg_left_pedal_smoothness + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_right_pedal_smoothness: {
let unscaled = (m.avg_right_pedal_smoothness + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_combined_pedal_smoothness: {
let unscaled = (m.avg_combined_pedal_smoothness + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
time_standing: {
let unscaled = (m.time_standing + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
stand_count: m.stand_count,
avg_left_pco: m.avg_left_pco,
avg_right_pco: m.avg_right_pco,
avg_left_power_phase: {
if m.avg_left_power_phase.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_left_power_phase.len());
for &x in m.avg_left_power_phase.iter() {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
{
vals.push(u8::MAX);
continue;
}
vals.push(unscaled as u8);
}
vals
}
},
avg_left_power_phase_peak: {
if m.avg_left_power_phase_peak.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_left_power_phase_peak.len());
for &x in m.avg_left_power_phase_peak.iter() {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
{
vals.push(u8::MAX);
continue;
}
vals.push(unscaled as u8);
}
vals
}
},
avg_right_power_phase: {
if m.avg_right_power_phase.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_right_power_phase.len());
for &x in m.avg_right_power_phase.iter() {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
{
vals.push(u8::MAX);
continue;
}
vals.push(unscaled as u8);
}
vals
}
},
avg_right_power_phase_peak: {
if m.avg_right_power_phase_peak.is_empty() {
Vec::new()
} else {
let mut vals = Vec::with_capacity(m.avg_right_power_phase_peak.len());
for &x in m.avg_right_power_phase_peak.iter() {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64
{
vals.push(u8::MAX);
continue;
}
vals.push(unscaled as u8);
}
vals
}
},
avg_power_position: m.avg_power_position,
max_power_position: m.max_power_position,
avg_cadence_position: m.avg_cadence_position,
max_cadence_position: m.max_cadence_position,
enhanced_avg_speed: {
let unscaled = (m.enhanced_avg_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
enhanced_max_speed: {
let unscaled = (m.enhanced_max_speed + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
enhanced_avg_altitude: {
let unscaled = (m.enhanced_avg_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
enhanced_min_altitude: {
let unscaled = (m.enhanced_min_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
enhanced_max_altitude: {
let unscaled = (m.enhanced_max_altitude + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
avg_lev_motor_power: m.avg_lev_motor_power,
max_lev_motor_power: m.max_lev_motor_power,
lev_battery_consumption: {
let unscaled = (m.lev_battery_consumption + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_vertical_ratio: {
let unscaled = (m.avg_vertical_ratio + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_stance_time_balance: {
let unscaled = (m.avg_stance_time_balance + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_step_length: {
let unscaled = (m.avg_step_length + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_vam: {
let unscaled = (m.avg_vam + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_depth: {
let unscaled = (m.avg_depth + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
max_depth: {
let unscaled = (m.max_depth + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
u32::MAX
} else {
unscaled as u32
}
},
min_temperature: m.min_temperature,
enhanced_avg_respiration_rate: {
let unscaled = (m.enhanced_avg_respiration_rate + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
enhanced_max_respiration_rate: {
let unscaled = (m.enhanced_max_respiration_rate + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
avg_respiration_rate: m.avg_respiration_rate,
max_respiration_rate: m.max_respiration_rate,
total_grit: m.total_grit,
total_flow: m.total_flow,
jump_count: m.jump_count,
avg_grit: m.avg_grit,
avg_flow: m.avg_flow,
total_fractional_ascent: {
let unscaled = (m.total_fractional_ascent + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
total_fractional_descent: {
let unscaled = (m.total_fractional_descent + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
u8::MAX
} else {
unscaled as u8
}
},
avg_core_temperature: {
let unscaled = (m.avg_core_temperature + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
min_core_temperature: {
let unscaled = (m.min_core_temperature + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
max_core_temperature: {
let unscaled = (m.max_core_temperature + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
u16::MAX
} else {
unscaled as u16
}
},
state: [0u8; 18],
unknown_fields: m.unknown_fields,
developer_fields: m.developer_fields,
}
}
}
#[cfg(feature = "serde")]
impl Default for De {
fn default() -> Self {
Self {
message_index: typedef::MessageIndex(u16::MAX),
timestamp: None,
event: typedef::Event(u8::MAX),
event_type: typedef::EventType(u8::MAX),
start_time: None,
start_position_lat: f64::from_bits(u64::MAX),
start_position_long: f64::from_bits(u64::MAX),
end_position_lat: f64::from_bits(u64::MAX),
end_position_long: f64::from_bits(u64::MAX),
total_elapsed_time: f64::from_bits(u64::MAX),
total_timer_time: f64::from_bits(u64::MAX),
total_distance: f64::from_bits(u64::MAX),
total_cycles: u32::MAX,
total_calories: u16::MAX,
total_fat_calories: u16::MAX,
avg_speed: f64::from_bits(u64::MAX),
max_speed: f64::from_bits(u64::MAX),
avg_heart_rate: u8::MAX,
max_heart_rate: u8::MAX,
avg_cadence: u8::MAX,
max_cadence: u8::MAX,
avg_power: u16::MAX,
max_power: u16::MAX,
total_ascent: u16::MAX,
total_descent: u16::MAX,
intensity: typedef::Intensity(u8::MAX),
lap_trigger: typedef::LapTrigger(u8::MAX),
sport: typedef::Sport(u8::MAX),
event_group: u8::MAX,
num_lengths: u16::MAX,
normalized_power: u16::MAX,
left_right_balance: typedef::LeftRightBalance100(u16::MAX),
first_length_index: u16::MAX,
avg_stroke_distance: f64::from_bits(u64::MAX),
swim_stroke: typedef::SwimStroke(u8::MAX),
sub_sport: typedef::SubSport(u8::MAX),
num_active_lengths: u16::MAX,
total_work: u32::MAX,
avg_altitude: f64::from_bits(u64::MAX),
max_altitude: f64::from_bits(u64::MAX),
gps_accuracy: u8::MAX,
avg_grade: f64::from_bits(u64::MAX),
avg_pos_grade: f64::from_bits(u64::MAX),
avg_neg_grade: f64::from_bits(u64::MAX),
max_pos_grade: f64::from_bits(u64::MAX),
max_neg_grade: f64::from_bits(u64::MAX),
avg_temperature: i8::MAX,
max_temperature: i8::MAX,
total_moving_time: f64::from_bits(u64::MAX),
avg_pos_vertical_speed: f64::from_bits(u64::MAX),
avg_neg_vertical_speed: f64::from_bits(u64::MAX),
max_pos_vertical_speed: f64::from_bits(u64::MAX),
max_neg_vertical_speed: f64::from_bits(u64::MAX),
time_in_hr_zone: Vec::new(),
time_in_speed_zone: Vec::new(),
time_in_cadence_zone: Vec::new(),
time_in_power_zone: Vec::new(),
repetition_num: u16::MAX,
min_altitude: f64::from_bits(u64::MAX),
min_heart_rate: u8::MAX,
active_time: f64::from_bits(u64::MAX),
wkt_step_index: typedef::MessageIndex(u16::MAX),
opponent_score: u16::MAX,
stroke_count: Vec::new(),
zone_count: Vec::new(),
avg_vertical_oscillation: f64::from_bits(u64::MAX),
avg_stance_time_percent: f64::from_bits(u64::MAX),
avg_stance_time: f64::from_bits(u64::MAX),
avg_fractional_cadence: f64::from_bits(u64::MAX),
max_fractional_cadence: f64::from_bits(u64::MAX),
total_fractional_cycles: f64::from_bits(u64::MAX),
player_score: u16::MAX,
avg_total_hemoglobin_conc: Vec::new(),
min_total_hemoglobin_conc: Vec::new(),
max_total_hemoglobin_conc: Vec::new(),
avg_saturated_hemoglobin_percent: Vec::new(),
min_saturated_hemoglobin_percent: Vec::new(),
max_saturated_hemoglobin_percent: Vec::new(),
avg_left_torque_effectiveness: f64::from_bits(u64::MAX),
avg_right_torque_effectiveness: f64::from_bits(u64::MAX),
avg_left_pedal_smoothness: f64::from_bits(u64::MAX),
avg_right_pedal_smoothness: f64::from_bits(u64::MAX),
avg_combined_pedal_smoothness: f64::from_bits(u64::MAX),
time_standing: f64::from_bits(u64::MAX),
stand_count: u16::MAX,
avg_left_pco: i8::MAX,
avg_right_pco: i8::MAX,
avg_left_power_phase: Vec::new(),
avg_left_power_phase_peak: Vec::new(),
avg_right_power_phase: Vec::new(),
avg_right_power_phase_peak: Vec::new(),
avg_power_position: Vec::new(),
max_power_position: Vec::new(),
avg_cadence_position: Vec::new(),
max_cadence_position: Vec::new(),
enhanced_avg_speed: f64::from_bits(u64::MAX),
enhanced_max_speed: f64::from_bits(u64::MAX),
enhanced_avg_altitude: f64::from_bits(u64::MAX),
enhanced_min_altitude: f64::from_bits(u64::MAX),
enhanced_max_altitude: f64::from_bits(u64::MAX),
avg_lev_motor_power: u16::MAX,
max_lev_motor_power: u16::MAX,
lev_battery_consumption: f64::from_bits(u64::MAX),
avg_vertical_ratio: f64::from_bits(u64::MAX),
avg_stance_time_balance: f64::from_bits(u64::MAX),
avg_step_length: f64::from_bits(u64::MAX),
avg_vam: f64::from_bits(u64::MAX),
avg_depth: f64::from_bits(u64::MAX),
max_depth: f64::from_bits(u64::MAX),
min_temperature: i8::MAX,
enhanced_avg_respiration_rate: f64::from_bits(u64::MAX),
enhanced_max_respiration_rate: f64::from_bits(u64::MAX),
avg_respiration_rate: u8::MAX,
max_respiration_rate: u8::MAX,
total_grit: f32::from_bits(u32::MAX),
total_flow: f32::from_bits(u32::MAX),
jump_count: u16::MAX,
avg_grit: f32::from_bits(u32::MAX),
avg_flow: f32::from_bits(u32::MAX),
total_fractional_ascent: f64::from_bits(u64::MAX),
total_fractional_descent: f64::from_bits(u64::MAX),
avg_core_temperature: f64::from_bits(u64::MAX),
min_core_temperature: f64::from_bits(u64::MAX),
max_core_temperature: f64::from_bits(u64::MAX),
unknown_fields: Vec::new(),
developer_fields: Vec::new(),
}
}
}