#![allow(unused, clippy::comparison_to_empty, clippy::manual_range_patterns)]
use crate::profile::{ProfileType, typedef};
use crate::proto::*;
fn is_expanded(state: &[u8], num: u8) -> bool {
match num {
5 | 6 | 19 | 29 | 73 | 78 | 108 => (state[num as usize >> 3] >> (num & 7)) & 1 == 1,
_ => false,
}
}
#[derive(Debug, Clone)]
pub struct Record {
pub timestamp: typedef::DateTime,
pub position_lat: i32,
pub position_long: i32,
pub altitude: u16,
pub heart_rate: u8,
pub cadence: u8,
pub distance: u32,
pub speed: u16,
pub power: u16,
pub compressed_speed_distance: [u8; 3],
pub grade: i16,
pub resistance: u8,
pub time_from_course: i32,
pub cycle_length: u8,
pub temperature: i8,
pub speed_1s: Vec<u8>,
pub cycles: u8,
pub total_cycles: u32,
pub compressed_accumulated_power: u16,
pub accumulated_power: u32,
pub left_right_balance: typedef::LeftRightBalance,
pub gps_accuracy: u8,
pub vertical_speed: i16,
pub calories: u16,
pub vertical_oscillation: u16,
pub stance_time_percent: u16,
pub stance_time: u16,
pub activity_type: typedef::ActivityType,
pub left_torque_effectiveness: u8,
pub right_torque_effectiveness: u8,
pub left_pedal_smoothness: u8,
pub right_pedal_smoothness: u8,
pub combined_pedal_smoothness: u8,
pub time128: u8,
pub stroke_type: typedef::StrokeType,
pub zone: u8,
pub ball_speed: u16,
pub cadence256: u16,
pub fractional_cadence: u8,
pub total_hemoglobin_conc: u16,
pub total_hemoglobin_conc_min: u16,
pub total_hemoglobin_conc_max: u16,
pub saturated_hemoglobin_percent: u16,
pub saturated_hemoglobin_percent_min: u16,
pub saturated_hemoglobin_percent_max: u16,
pub device_index: typedef::DeviceIndex,
pub left_pco: i8,
pub right_pco: i8,
pub left_power_phase: Vec<u8>,
pub left_power_phase_peak: Vec<u8>,
pub right_power_phase: Vec<u8>,
pub right_power_phase_peak: Vec<u8>,
pub enhanced_speed: u32,
pub enhanced_altitude: u32,
pub battery_soc: u8,
pub motor_power: u16,
pub vertical_ratio: u16,
pub stance_time_balance: u16,
pub step_length: u16,
pub cycle_length16: u16,
pub absolute_pressure: u32,
pub depth: u32,
pub next_stop_depth: u32,
pub next_stop_time: u32,
pub time_to_surface: u32,
pub ndl_time: u32,
pub cns_load: u8,
pub n2_load: u16,
pub respiration_rate: u8,
pub enhanced_respiration_rate: u16,
pub grit: f32,
pub flow: f32,
pub current_stress: u16,
pub ebike_travel_range: u16,
pub ebike_battery_level: u8,
pub ebike_assist_mode: u8,
pub ebike_assist_level_percent: u8,
pub air_time_remaining: u32,
pub pressure_sac: u16,
pub volume_sac: u16,
pub rmv: u16,
pub ascent_rate: i32,
pub po2: u8,
pub core_temperature: u16,
state: [u8; 14], pub unknown_fields: Vec<Field>,
pub developer_fields: Vec<DeveloperField>,
}
impl Record {
pub const TIMESTAMP: u8 = 253;
pub const POSITION_LAT: u8 = 0;
pub const POSITION_LONG: u8 = 1;
pub const ALTITUDE: u8 = 2;
pub const HEART_RATE: u8 = 3;
pub const CADENCE: u8 = 4;
pub const DISTANCE: u8 = 5;
pub const SPEED: u8 = 6;
pub const POWER: u8 = 7;
pub const COMPRESSED_SPEED_DISTANCE: u8 = 8;
pub const GRADE: u8 = 9;
pub const RESISTANCE: u8 = 10;
pub const TIME_FROM_COURSE: u8 = 11;
pub const CYCLE_LENGTH: u8 = 12;
pub const TEMPERATURE: u8 = 13;
pub const SPEED_1S: u8 = 17;
pub const CYCLES: u8 = 18;
pub const TOTAL_CYCLES: u8 = 19;
pub const COMPRESSED_ACCUMULATED_POWER: u8 = 28;
pub const ACCUMULATED_POWER: u8 = 29;
pub const LEFT_RIGHT_BALANCE: u8 = 30;
pub const GPS_ACCURACY: u8 = 31;
pub const VERTICAL_SPEED: u8 = 32;
pub const CALORIES: u8 = 33;
pub const VERTICAL_OSCILLATION: u8 = 39;
pub const STANCE_TIME_PERCENT: u8 = 40;
pub const STANCE_TIME: u8 = 41;
pub const ACTIVITY_TYPE: u8 = 42;
pub const LEFT_TORQUE_EFFECTIVENESS: u8 = 43;
pub const RIGHT_TORQUE_EFFECTIVENESS: u8 = 44;
pub const LEFT_PEDAL_SMOOTHNESS: u8 = 45;
pub const RIGHT_PEDAL_SMOOTHNESS: u8 = 46;
pub const COMBINED_PEDAL_SMOOTHNESS: u8 = 47;
pub const TIME128: u8 = 48;
pub const STROKE_TYPE: u8 = 49;
pub const ZONE: u8 = 50;
pub const BALL_SPEED: u8 = 51;
pub const CADENCE256: u8 = 52;
pub const FRACTIONAL_CADENCE: u8 = 53;
pub const TOTAL_HEMOGLOBIN_CONC: u8 = 54;
pub const TOTAL_HEMOGLOBIN_CONC_MIN: u8 = 55;
pub const TOTAL_HEMOGLOBIN_CONC_MAX: u8 = 56;
pub const SATURATED_HEMOGLOBIN_PERCENT: u8 = 57;
pub const SATURATED_HEMOGLOBIN_PERCENT_MIN: u8 = 58;
pub const SATURATED_HEMOGLOBIN_PERCENT_MAX: u8 = 59;
pub const DEVICE_INDEX: u8 = 62;
pub const LEFT_PCO: u8 = 67;
pub const RIGHT_PCO: u8 = 68;
pub const LEFT_POWER_PHASE: u8 = 69;
pub const LEFT_POWER_PHASE_PEAK: u8 = 70;
pub const RIGHT_POWER_PHASE: u8 = 71;
pub const RIGHT_POWER_PHASE_PEAK: u8 = 72;
pub const ENHANCED_SPEED: u8 = 73;
pub const ENHANCED_ALTITUDE: u8 = 78;
pub const BATTERY_SOC: u8 = 81;
pub const MOTOR_POWER: u8 = 82;
pub const VERTICAL_RATIO: u8 = 83;
pub const STANCE_TIME_BALANCE: u8 = 84;
pub const STEP_LENGTH: u8 = 85;
pub const CYCLE_LENGTH16: u8 = 87;
pub const ABSOLUTE_PRESSURE: u8 = 91;
pub const DEPTH: u8 = 92;
pub const NEXT_STOP_DEPTH: u8 = 93;
pub const NEXT_STOP_TIME: u8 = 94;
pub const TIME_TO_SURFACE: u8 = 95;
pub const NDL_TIME: u8 = 96;
pub const CNS_LOAD: u8 = 97;
pub const N2_LOAD: u8 = 98;
pub const RESPIRATION_RATE: u8 = 99;
pub const ENHANCED_RESPIRATION_RATE: u8 = 108;
pub const GRIT: u8 = 114;
pub const FLOW: u8 = 115;
pub const CURRENT_STRESS: u8 = 116;
pub const EBIKE_TRAVEL_RANGE: u8 = 117;
pub const EBIKE_BATTERY_LEVEL: u8 = 118;
pub const EBIKE_ASSIST_MODE: u8 = 119;
pub const EBIKE_ASSIST_LEVEL_PERCENT: u8 = 120;
pub const AIR_TIME_REMAINING: u8 = 123;
pub const PRESSURE_SAC: u8 = 124;
pub const VOLUME_SAC: u8 = 125;
pub const RMV: u8 = 126;
pub const ASCENT_RATE: u8 = 127;
pub const PO2: u8 = 129;
pub const CORE_TEMPERATURE: u8 = 139;
pub const fn new() -> Self {
Self {
timestamp: typedef::DateTime(u32::MAX),
position_lat: i32::MAX,
position_long: i32::MAX,
altitude: u16::MAX,
heart_rate: u8::MAX,
cadence: u8::MAX,
distance: u32::MAX,
speed: u16::MAX,
power: u16::MAX,
compressed_speed_distance: [u8::MAX; 3],
grade: i16::MAX,
resistance: u8::MAX,
time_from_course: i32::MAX,
cycle_length: u8::MAX,
temperature: i8::MAX,
speed_1s: Vec::<u8>::new(),
cycles: u8::MAX,
total_cycles: u32::MAX,
compressed_accumulated_power: u16::MAX,
accumulated_power: u32::MAX,
left_right_balance: typedef::LeftRightBalance(u8::MAX),
gps_accuracy: u8::MAX,
vertical_speed: i16::MAX,
calories: u16::MAX,
vertical_oscillation: u16::MAX,
stance_time_percent: u16::MAX,
stance_time: u16::MAX,
activity_type: typedef::ActivityType(u8::MAX),
left_torque_effectiveness: u8::MAX,
right_torque_effectiveness: u8::MAX,
left_pedal_smoothness: u8::MAX,
right_pedal_smoothness: u8::MAX,
combined_pedal_smoothness: u8::MAX,
time128: u8::MAX,
stroke_type: typedef::StrokeType(u8::MAX),
zone: u8::MAX,
ball_speed: u16::MAX,
cadence256: u16::MAX,
fractional_cadence: u8::MAX,
total_hemoglobin_conc: u16::MAX,
total_hemoglobin_conc_min: u16::MAX,
total_hemoglobin_conc_max: u16::MAX,
saturated_hemoglobin_percent: u16::MAX,
saturated_hemoglobin_percent_min: u16::MAX,
saturated_hemoglobin_percent_max: u16::MAX,
device_index: typedef::DeviceIndex(u8::MAX),
left_pco: i8::MAX,
right_pco: i8::MAX,
left_power_phase: Vec::<u8>::new(),
left_power_phase_peak: Vec::<u8>::new(),
right_power_phase: Vec::<u8>::new(),
right_power_phase_peak: Vec::<u8>::new(),
enhanced_speed: u32::MAX,
enhanced_altitude: u32::MAX,
battery_soc: u8::MAX,
motor_power: u16::MAX,
vertical_ratio: u16::MAX,
stance_time_balance: u16::MAX,
step_length: u16::MAX,
cycle_length16: u16::MAX,
absolute_pressure: u32::MAX,
depth: u32::MAX,
next_stop_depth: u32::MAX,
next_stop_time: u32::MAX,
time_to_surface: u32::MAX,
ndl_time: u32::MAX,
cns_load: u8::MAX,
n2_load: u16::MAX,
respiration_rate: u8::MAX,
enhanced_respiration_rate: u16::MAX,
grit: f32::MAX,
flow: f32::MAX,
current_stress: u16::MAX,
ebike_travel_range: u16::MAX,
ebike_battery_level: u8::MAX,
ebike_assist_mode: u8::MAX,
ebike_assist_level_percent: u8::MAX,
air_time_remaining: u32::MAX,
pressure_sac: u16::MAX,
volume_sac: u16::MAX,
rmv: u16::MAX,
ascent_rate: i32::MAX,
po2: u8::MAX,
core_temperature: u16::MAX,
state: [0u8; 14],
unknown_fields: Vec::new(),
developer_fields: Vec::new(),
}
}
pub fn altitude_scaled(&self) -> f64 {
if self.altitude == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.altitude as f64 / 5.0 - 500.0
}
pub fn set_altitude_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.altitude = u16::MAX;
return self;
}
self.altitude = unscaled as u16;
self
}
pub fn distance_scaled(&self) -> f64 {
if self.distance == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.distance as f64 / 100.0 - 0.0
}
pub fn set_distance_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.distance = u32::MAX;
return self;
}
self.distance = unscaled as u32;
self
}
pub fn speed_scaled(&self) -> f64 {
if self.speed == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.speed as f64 / 1000.0 - 0.0
}
pub fn set_speed_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.speed = u16::MAX;
return self;
}
self.speed = unscaled as u16;
self
}
pub fn grade_scaled(&self) -> f64 {
if self.grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.grade as f64 / 100.0 - 0.0
}
pub fn set_grade_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.grade = i16::MAX;
return self;
}
self.grade = unscaled as i16;
self
}
pub fn time_from_course_scaled(&self) -> f64 {
if self.time_from_course == i32::MAX {
return f64::from_bits(u64::MAX);
}
self.time_from_course as f64 / 1000.0 - 0.0
}
pub fn set_time_from_course_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i32::MAX as f64 {
self.time_from_course = i32::MAX;
return self;
}
self.time_from_course = unscaled as i32;
self
}
pub fn cycle_length_scaled(&self) -> f64 {
if self.cycle_length == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.cycle_length as f64 / 100.0 - 0.0
}
pub fn set_cycle_length_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.cycle_length = u8::MAX;
return self;
}
self.cycle_length = unscaled as u8;
self
}
pub fn speed_1s_scaled(&self) -> Vec<f64> {
if self.speed_1s == Vec::<u8>::new() {
return Vec::new();
}
let mut v = Vec::with_capacity(self.speed_1s.len());
for &x in &self.speed_1s {
v.push(x as f64 / 16.0 - 0.0)
}
v
}
pub fn set_speed_1s_scaled(&mut self, v: &Vec<f64>) -> &mut Record {
if v.is_empty() {
self.speed_1s = Vec::new();
return self;
}
self.speed_1s = Vec::with_capacity(v.len());
for &x in v {
let unscaled = (x + 0.0) * 16.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.speed_1s.push(u8::MAX);
continue;
}
self.speed_1s.push(unscaled as u8);
}
self
}
pub fn vertical_speed_scaled(&self) -> f64 {
if self.vertical_speed == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.vertical_speed as f64 / 1000.0 - 0.0
}
pub fn set_vertical_speed_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i16::MAX as f64 {
self.vertical_speed = i16::MAX;
return self;
}
self.vertical_speed = unscaled as i16;
self
}
pub fn vertical_oscillation_scaled(&self) -> f64 {
if self.vertical_oscillation == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.vertical_oscillation as f64 / 10.0 - 0.0
}
pub fn set_vertical_oscillation_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.vertical_oscillation = u16::MAX;
return self;
}
self.vertical_oscillation = unscaled as u16;
self
}
pub fn stance_time_percent_scaled(&self) -> f64 {
if self.stance_time_percent == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.stance_time_percent as f64 / 100.0 - 0.0
}
pub fn set_stance_time_percent_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.stance_time_percent = u16::MAX;
return self;
}
self.stance_time_percent = unscaled as u16;
self
}
pub fn stance_time_scaled(&self) -> f64 {
if self.stance_time == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.stance_time as f64 / 10.0 - 0.0
}
pub fn set_stance_time_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.stance_time = u16::MAX;
return self;
}
self.stance_time = unscaled as u16;
self
}
pub fn left_torque_effectiveness_scaled(&self) -> f64 {
if self.left_torque_effectiveness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.left_torque_effectiveness as f64 / 2.0 - 0.0
}
pub fn set_left_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.left_torque_effectiveness = u8::MAX;
return self;
}
self.left_torque_effectiveness = unscaled as u8;
self
}
pub fn right_torque_effectiveness_scaled(&self) -> f64 {
if self.right_torque_effectiveness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.right_torque_effectiveness as f64 / 2.0 - 0.0
}
pub fn set_right_torque_effectiveness_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.right_torque_effectiveness = u8::MAX;
return self;
}
self.right_torque_effectiveness = unscaled as u8;
self
}
pub fn left_pedal_smoothness_scaled(&self) -> f64 {
if self.left_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.left_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_left_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.left_pedal_smoothness = u8::MAX;
return self;
}
self.left_pedal_smoothness = unscaled as u8;
self
}
pub fn right_pedal_smoothness_scaled(&self) -> f64 {
if self.right_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.right_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_right_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.right_pedal_smoothness = u8::MAX;
return self;
}
self.right_pedal_smoothness = unscaled as u8;
self
}
pub fn combined_pedal_smoothness_scaled(&self) -> f64 {
if self.combined_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.combined_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_combined_pedal_smoothness_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.combined_pedal_smoothness = u8::MAX;
return self;
}
self.combined_pedal_smoothness = unscaled as u8;
self
}
pub fn time128_scaled(&self) -> f64 {
if self.time128 == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.time128 as f64 / 128.0 - 0.0
}
pub fn set_time128_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.time128 = u8::MAX;
return self;
}
self.time128 = unscaled as u8;
self
}
pub fn ball_speed_scaled(&self) -> f64 {
if self.ball_speed == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.ball_speed as f64 / 100.0 - 0.0
}
pub fn set_ball_speed_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.ball_speed = u16::MAX;
return self;
}
self.ball_speed = unscaled as u16;
self
}
pub fn cadence256_scaled(&self) -> f64 {
if self.cadence256 == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.cadence256 as f64 / 256.0 - 0.0
}
pub fn set_cadence256_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 256.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.cadence256 = u16::MAX;
return self;
}
self.cadence256 = unscaled as u16;
self
}
pub fn fractional_cadence_scaled(&self) -> f64 {
if self.fractional_cadence == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.fractional_cadence as f64 / 128.0 - 0.0
}
pub fn set_fractional_cadence_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 128.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.fractional_cadence = u8::MAX;
return self;
}
self.fractional_cadence = unscaled as u8;
self
}
pub fn total_hemoglobin_conc_scaled(&self) -> f64 {
if self.total_hemoglobin_conc == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.total_hemoglobin_conc as f64 / 100.0 - 0.0
}
pub fn set_total_hemoglobin_conc_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.total_hemoglobin_conc = u16::MAX;
return self;
}
self.total_hemoglobin_conc = unscaled as u16;
self
}
pub fn total_hemoglobin_conc_min_scaled(&self) -> f64 {
if self.total_hemoglobin_conc_min == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.total_hemoglobin_conc_min as f64 / 100.0 - 0.0
}
pub fn set_total_hemoglobin_conc_min_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.total_hemoglobin_conc_min = u16::MAX;
return self;
}
self.total_hemoglobin_conc_min = unscaled as u16;
self
}
pub fn total_hemoglobin_conc_max_scaled(&self) -> f64 {
if self.total_hemoglobin_conc_max == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.total_hemoglobin_conc_max as f64 / 100.0 - 0.0
}
pub fn set_total_hemoglobin_conc_max_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.total_hemoglobin_conc_max = u16::MAX;
return self;
}
self.total_hemoglobin_conc_max = unscaled as u16;
self
}
pub fn saturated_hemoglobin_percent_scaled(&self) -> f64 {
if self.saturated_hemoglobin_percent == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.saturated_hemoglobin_percent as f64 / 10.0 - 0.0
}
pub fn set_saturated_hemoglobin_percent_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.saturated_hemoglobin_percent = u16::MAX;
return self;
}
self.saturated_hemoglobin_percent = unscaled as u16;
self
}
pub fn saturated_hemoglobin_percent_min_scaled(&self) -> f64 {
if self.saturated_hemoglobin_percent_min == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.saturated_hemoglobin_percent_min as f64 / 10.0 - 0.0
}
pub fn set_saturated_hemoglobin_percent_min_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.saturated_hemoglobin_percent_min = u16::MAX;
return self;
}
self.saturated_hemoglobin_percent_min = unscaled as u16;
self
}
pub fn saturated_hemoglobin_percent_max_scaled(&self) -> f64 {
if self.saturated_hemoglobin_percent_max == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.saturated_hemoglobin_percent_max as f64 / 10.0 - 0.0
}
pub fn set_saturated_hemoglobin_percent_max_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.saturated_hemoglobin_percent_max = u16::MAX;
return self;
}
self.saturated_hemoglobin_percent_max = unscaled as u16;
self
}
pub fn left_power_phase_scaled(&self) -> Vec<f64> {
if self.left_power_phase == Vec::<u8>::new() {
return Vec::new();
}
let mut v = Vec::with_capacity(self.left_power_phase.len());
for &x in &self.left_power_phase {
v.push(x as f64 / 0.7111111 - 0.0)
}
v
}
pub fn set_left_power_phase_scaled(&mut self, v: &Vec<f64>) -> &mut Record {
if v.is_empty() {
self.left_power_phase = Vec::new();
return self;
}
self.left_power_phase = Vec::with_capacity(v.len());
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.left_power_phase.push(u8::MAX);
continue;
}
self.left_power_phase.push(unscaled as u8);
}
self
}
pub fn left_power_phase_peak_scaled(&self) -> Vec<f64> {
if self.left_power_phase_peak == Vec::<u8>::new() {
return Vec::new();
}
let mut v = Vec::with_capacity(self.left_power_phase_peak.len());
for &x in &self.left_power_phase_peak {
v.push(x as f64 / 0.7111111 - 0.0)
}
v
}
pub fn set_left_power_phase_peak_scaled(&mut self, v: &Vec<f64>) -> &mut Record {
if v.is_empty() {
self.left_power_phase_peak = Vec::new();
return self;
}
self.left_power_phase_peak = Vec::with_capacity(v.len());
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.left_power_phase_peak.push(u8::MAX);
continue;
}
self.left_power_phase_peak.push(unscaled as u8);
}
self
}
pub fn right_power_phase_scaled(&self) -> Vec<f64> {
if self.right_power_phase == Vec::<u8>::new() {
return Vec::new();
}
let mut v = Vec::with_capacity(self.right_power_phase.len());
for &x in &self.right_power_phase {
v.push(x as f64 / 0.7111111 - 0.0)
}
v
}
pub fn set_right_power_phase_scaled(&mut self, v: &Vec<f64>) -> &mut Record {
if v.is_empty() {
self.right_power_phase = Vec::new();
return self;
}
self.right_power_phase = Vec::with_capacity(v.len());
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.right_power_phase.push(u8::MAX);
continue;
}
self.right_power_phase.push(unscaled as u8);
}
self
}
pub fn right_power_phase_peak_scaled(&self) -> Vec<f64> {
if self.right_power_phase_peak == Vec::<u8>::new() {
return Vec::new();
}
let mut v = Vec::with_capacity(self.right_power_phase_peak.len());
for &x in &self.right_power_phase_peak {
v.push(x as f64 / 0.7111111 - 0.0)
}
v
}
pub fn set_right_power_phase_peak_scaled(&mut self, v: &Vec<f64>) -> &mut Record {
if v.is_empty() {
self.right_power_phase_peak = Vec::new();
return self;
}
self.right_power_phase_peak = Vec::with_capacity(v.len());
for &x in v {
let unscaled = (x + 0.0) * 0.7111111;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.right_power_phase_peak.push(u8::MAX);
continue;
}
self.right_power_phase_peak.push(unscaled as u8);
}
self
}
pub fn enhanced_speed_scaled(&self) -> f64 {
if self.enhanced_speed == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_speed as f64 / 1000.0 - 0.0
}
pub fn set_enhanced_speed_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.enhanced_speed = u32::MAX;
return self;
}
self.enhanced_speed = unscaled as u32;
self
}
pub fn enhanced_altitude_scaled(&self) -> f64 {
if self.enhanced_altitude == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_altitude as f64 / 5.0 - 500.0
}
pub fn set_enhanced_altitude_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 500.0) * 5.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.enhanced_altitude = u32::MAX;
return self;
}
self.enhanced_altitude = unscaled as u32;
self
}
pub fn battery_soc_scaled(&self) -> f64 {
if self.battery_soc == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.battery_soc as f64 / 2.0 - 0.0
}
pub fn set_battery_soc_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 2.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.battery_soc = u8::MAX;
return self;
}
self.battery_soc = unscaled as u8;
self
}
pub fn vertical_ratio_scaled(&self) -> f64 {
if self.vertical_ratio == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.vertical_ratio as f64 / 100.0 - 0.0
}
pub fn set_vertical_ratio_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.vertical_ratio = u16::MAX;
return self;
}
self.vertical_ratio = unscaled as u16;
self
}
pub fn stance_time_balance_scaled(&self) -> f64 {
if self.stance_time_balance == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.stance_time_balance as f64 / 100.0 - 0.0
}
pub fn set_stance_time_balance_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.stance_time_balance = u16::MAX;
return self;
}
self.stance_time_balance = unscaled as u16;
self
}
pub fn step_length_scaled(&self) -> f64 {
if self.step_length == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.step_length as f64 / 10.0 - 0.0
}
pub fn set_step_length_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 10.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.step_length = u16::MAX;
return self;
}
self.step_length = unscaled as u16;
self
}
pub fn cycle_length16_scaled(&self) -> f64 {
if self.cycle_length16 == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.cycle_length16 as f64 / 100.0 - 0.0
}
pub fn set_cycle_length16_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.cycle_length16 = u16::MAX;
return self;
}
self.cycle_length16 = unscaled as u16;
self
}
pub fn depth_scaled(&self) -> f64 {
if self.depth == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.depth as f64 / 1000.0 - 0.0
}
pub fn set_depth_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.depth = u32::MAX;
return self;
}
self.depth = unscaled as u32;
self
}
pub fn next_stop_depth_scaled(&self) -> f64 {
if self.next_stop_depth == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.next_stop_depth as f64 / 1000.0 - 0.0
}
pub fn set_next_stop_depth_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u32::MAX as f64 {
self.next_stop_depth = u32::MAX;
return self;
}
self.next_stop_depth = unscaled as u32;
self
}
pub fn enhanced_respiration_rate_scaled(&self) -> f64 {
if self.enhanced_respiration_rate == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_respiration_rate as f64 / 100.0 - 0.0
}
pub fn set_enhanced_respiration_rate_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.enhanced_respiration_rate = u16::MAX;
return self;
}
self.enhanced_respiration_rate = unscaled as u16;
self
}
pub fn current_stress_scaled(&self) -> f64 {
if self.current_stress == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.current_stress as f64 / 100.0 - 0.0
}
pub fn set_current_stress_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.current_stress = u16::MAX;
return self;
}
self.current_stress = unscaled as u16;
self
}
pub fn pressure_sac_scaled(&self) -> f64 {
if self.pressure_sac == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.pressure_sac as f64 / 100.0 - 0.0
}
pub fn set_pressure_sac_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.pressure_sac = u16::MAX;
return self;
}
self.pressure_sac = unscaled as u16;
self
}
pub fn volume_sac_scaled(&self) -> f64 {
if self.volume_sac == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.volume_sac as f64 / 100.0 - 0.0
}
pub fn set_volume_sac_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.volume_sac = u16::MAX;
return self;
}
self.volume_sac = unscaled as u16;
self
}
pub fn rmv_scaled(&self) -> f64 {
if self.rmv == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.rmv as f64 / 100.0 - 0.0
}
pub fn set_rmv_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.rmv = u16::MAX;
return self;
}
self.rmv = unscaled as u16;
self
}
pub fn ascent_rate_scaled(&self) -> f64 {
if self.ascent_rate == i32::MAX {
return f64::from_bits(u64::MAX);
}
self.ascent_rate as f64 / 1000.0 - 0.0
}
pub fn set_ascent_rate_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 1000.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > i32::MAX as f64 {
self.ascent_rate = i32::MAX;
return self;
}
self.ascent_rate = unscaled as i32;
self
}
pub fn po2_scaled(&self) -> f64 {
if self.po2 == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.po2 as f64 / 100.0 - 0.0
}
pub fn set_po2_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u8::MAX as f64 {
self.po2 = u8::MAX;
return self;
}
self.po2 = unscaled as u8;
self
}
pub fn core_temperature_scaled(&self) -> f64 {
if self.core_temperature == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.core_temperature as f64 / 100.0 - 0.0
}
pub fn set_core_temperature_scaled(&mut self, v: f64) -> &mut Record {
let unscaled = (v + 0.0) * 100.0;
if unscaled.is_nan() || unscaled.is_infinite() || unscaled > u16::MAX as f64 {
self.core_temperature = u16::MAX;
return self;
}
self.core_temperature = unscaled as u16;
self
}
pub fn mark_as_expanded(&mut self, num: u8, flag: bool) -> bool {
match num {
5 | 6 | 19 | 29 | 73 | 78 | 108 => {
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)
}
}
impl Default for Record {
fn default() -> Self {
Self::new()
}
}
impl From<&Message> for Record {
fn from(mesg: &Message) -> Self {
let mut vals: [&Value; 254] = [const { &Value::Invalid }; 254];
let mut state = [0u8; 14];
const KNOWN_NUMS: [u64; 4] = [
5764606990190788607,
18013290270358914040,
2050,
2305843009213693952,
];
let mut n = 0u64;
for field in &mesg.fields {
n += (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 ^ 1
}
let mut unknown_fields: Vec<Field> = Vec::with_capacity(n as usize);
for field in &mesg.fields {
if (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 == 0 {
unknown_fields.push(field.clone());
continue;
}
if field.is_expanded && field.num < 109 {
state[field.num as usize >> 3] |= 1 << (field.num & 7)
}
vals[field.num as usize] = &field.value;
}
Self {
timestamp: typedef::DateTime(vals[253].as_u32()),
position_lat: vals[0].as_i32(),
position_long: vals[1].as_i32(),
altitude: vals[2].as_u16(),
heart_rate: vals[3].as_u8(),
cadence: vals[4].as_u8(),
distance: vals[5].as_u32(),
speed: vals[6].as_u16(),
power: vals[7].as_u16(),
compressed_speed_distance: match &vals[8] {
Value::VecUint8(v) => {
let mut arr: [u8; 3] = [u8::MAX; 3];
for (i, x) in v.iter().enumerate() {
arr[i] = *x;
}
arr
}
_ => [u8::MAX; 3],
},
grade: vals[9].as_i16(),
resistance: vals[10].as_u8(),
time_from_course: vals[11].as_i32(),
cycle_length: vals[12].as_u8(),
temperature: vals[13].as_i8(),
speed_1s: vals[17].as_vec_u8(),
cycles: vals[18].as_u8(),
total_cycles: vals[19].as_u32(),
compressed_accumulated_power: vals[28].as_u16(),
accumulated_power: vals[29].as_u32(),
left_right_balance: typedef::LeftRightBalance(vals[30].as_u8()),
gps_accuracy: vals[31].as_u8(),
vertical_speed: vals[32].as_i16(),
calories: vals[33].as_u16(),
vertical_oscillation: vals[39].as_u16(),
stance_time_percent: vals[40].as_u16(),
stance_time: vals[41].as_u16(),
activity_type: typedef::ActivityType(vals[42].as_u8()),
left_torque_effectiveness: vals[43].as_u8(),
right_torque_effectiveness: vals[44].as_u8(),
left_pedal_smoothness: vals[45].as_u8(),
right_pedal_smoothness: vals[46].as_u8(),
combined_pedal_smoothness: vals[47].as_u8(),
time128: vals[48].as_u8(),
stroke_type: typedef::StrokeType(vals[49].as_u8()),
zone: vals[50].as_u8(),
ball_speed: vals[51].as_u16(),
cadence256: vals[52].as_u16(),
fractional_cadence: vals[53].as_u8(),
total_hemoglobin_conc: vals[54].as_u16(),
total_hemoglobin_conc_min: vals[55].as_u16(),
total_hemoglobin_conc_max: vals[56].as_u16(),
saturated_hemoglobin_percent: vals[57].as_u16(),
saturated_hemoglobin_percent_min: vals[58].as_u16(),
saturated_hemoglobin_percent_max: vals[59].as_u16(),
device_index: typedef::DeviceIndex(vals[62].as_u8()),
left_pco: vals[67].as_i8(),
right_pco: vals[68].as_i8(),
left_power_phase: vals[69].as_vec_u8(),
left_power_phase_peak: vals[70].as_vec_u8(),
right_power_phase: vals[71].as_vec_u8(),
right_power_phase_peak: vals[72].as_vec_u8(),
enhanced_speed: vals[73].as_u32(),
enhanced_altitude: vals[78].as_u32(),
battery_soc: vals[81].as_u8(),
motor_power: vals[82].as_u16(),
vertical_ratio: vals[83].as_u16(),
stance_time_balance: vals[84].as_u16(),
step_length: vals[85].as_u16(),
cycle_length16: vals[87].as_u16(),
absolute_pressure: vals[91].as_u32(),
depth: vals[92].as_u32(),
next_stop_depth: vals[93].as_u32(),
next_stop_time: vals[94].as_u32(),
time_to_surface: vals[95].as_u32(),
ndl_time: vals[96].as_u32(),
cns_load: vals[97].as_u8(),
n2_load: vals[98].as_u16(),
respiration_rate: vals[99].as_u8(),
enhanced_respiration_rate: vals[108].as_u16(),
grit: vals[114].as_f32(),
flow: vals[115].as_f32(),
current_stress: vals[116].as_u16(),
ebike_travel_range: vals[117].as_u16(),
ebike_battery_level: vals[118].as_u8(),
ebike_assist_mode: vals[119].as_u8(),
ebike_assist_level_percent: vals[120].as_u8(),
air_time_remaining: vals[123].as_u32(),
pressure_sac: vals[124].as_u16(),
volume_sac: vals[125].as_u16(),
rmv: vals[126].as_u16(),
ascent_rate: vals[127].as_i32(),
po2: vals[129].as_u8(),
core_temperature: vals[139].as_u16(),
state,
unknown_fields,
developer_fields: mesg.developer_fields.clone(),
}
}
}
impl From<Record> for Message {
fn from(m: Record) -> Self {
let mut arr = [const {
Field {
num: 0,
profile_type: ProfileType(0),
value: Value::Invalid,
is_expanded: false,
}
}; 84];
let mut len = 0usize;
let state = m.state;
if m.timestamp != typedef::DateTime(u32::MAX) {
arr[len] = Field {
num: 253,
profile_type: ProfileType::DATE_TIME,
value: Value::Uint32(m.timestamp.0),
is_expanded: false,
};
len += 1;
}
if m.position_lat != i32::MAX {
arr[len] = Field {
num: 0,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.position_lat),
is_expanded: false,
};
len += 1;
}
if m.position_long != i32::MAX {
arr[len] = Field {
num: 1,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.position_long),
is_expanded: false,
};
len += 1;
}
if m.altitude != u16::MAX {
arr[len] = Field {
num: 2,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.altitude),
is_expanded: false,
};
len += 1;
}
if m.heart_rate != u8::MAX {
arr[len] = Field {
num: 3,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.heart_rate),
is_expanded: false,
};
len += 1;
}
if m.cadence != u8::MAX {
arr[len] = Field {
num: 4,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.cadence),
is_expanded: false,
};
len += 1;
}
if m.distance != u32::MAX {
arr[len] = Field {
num: 5,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.distance),
is_expanded: is_expanded(&state, 5),
};
len += 1;
}
if m.speed != u16::MAX {
arr[len] = Field {
num: 6,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.speed),
is_expanded: is_expanded(&state, 6),
};
len += 1;
}
if m.power != u16::MAX {
arr[len] = Field {
num: 7,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.power),
is_expanded: false,
};
len += 1;
}
if m.compressed_speed_distance != [u8::MAX; 3] {
arr[len] = Field {
num: 8,
profile_type: ProfileType::BYTE,
value: Value::VecUint8(Vec::from(&m.compressed_speed_distance)),
is_expanded: false,
};
len += 1;
}
if m.grade != i16::MAX {
arr[len] = Field {
num: 9,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.grade),
is_expanded: false,
};
len += 1;
}
if m.resistance != u8::MAX {
arr[len] = Field {
num: 10,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.resistance),
is_expanded: false,
};
len += 1;
}
if m.time_from_course != i32::MAX {
arr[len] = Field {
num: 11,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.time_from_course),
is_expanded: false,
};
len += 1;
}
if m.cycle_length != u8::MAX {
arr[len] = Field {
num: 12,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.cycle_length),
is_expanded: false,
};
len += 1;
}
if m.temperature != i8::MAX {
arr[len] = Field {
num: 13,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.temperature),
is_expanded: false,
};
len += 1;
}
if m.speed_1s != Vec::<u8>::new() {
arr[len] = Field {
num: 17,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.speed_1s),
is_expanded: false,
};
len += 1;
}
if m.cycles != u8::MAX {
arr[len] = Field {
num: 18,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.cycles),
is_expanded: false,
};
len += 1;
}
if m.total_cycles != u32::MAX {
arr[len] = Field {
num: 19,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_cycles),
is_expanded: is_expanded(&state, 19),
};
len += 1;
}
if m.compressed_accumulated_power != u16::MAX {
arr[len] = Field {
num: 28,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.compressed_accumulated_power),
is_expanded: false,
};
len += 1;
}
if m.accumulated_power != u32::MAX {
arr[len] = Field {
num: 29,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.accumulated_power),
is_expanded: is_expanded(&state, 29),
};
len += 1;
}
if m.left_right_balance != typedef::LeftRightBalance(u8::MAX) {
arr[len] = Field {
num: 30,
profile_type: ProfileType::LEFT_RIGHT_BALANCE,
value: Value::Uint8(m.left_right_balance.0),
is_expanded: false,
};
len += 1;
}
if m.gps_accuracy != u8::MAX {
arr[len] = Field {
num: 31,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.gps_accuracy),
is_expanded: false,
};
len += 1;
}
if m.vertical_speed != i16::MAX {
arr[len] = Field {
num: 32,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.vertical_speed),
is_expanded: false,
};
len += 1;
}
if m.calories != u16::MAX {
arr[len] = Field {
num: 33,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.calories),
is_expanded: false,
};
len += 1;
}
if m.vertical_oscillation != u16::MAX {
arr[len] = Field {
num: 39,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.vertical_oscillation),
is_expanded: false,
};
len += 1;
}
if m.stance_time_percent != u16::MAX {
arr[len] = Field {
num: 40,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.stance_time_percent),
is_expanded: false,
};
len += 1;
}
if m.stance_time != u16::MAX {
arr[len] = Field {
num: 41,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.stance_time),
is_expanded: false,
};
len += 1;
}
if m.activity_type != typedef::ActivityType(u8::MAX) {
arr[len] = Field {
num: 42,
profile_type: ProfileType::ACTIVITY_TYPE,
value: Value::Uint8(m.activity_type.0),
is_expanded: false,
};
len += 1;
}
if m.left_torque_effectiveness != u8::MAX {
arr[len] = Field {
num: 43,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.left_torque_effectiveness),
is_expanded: false,
};
len += 1;
}
if m.right_torque_effectiveness != u8::MAX {
arr[len] = Field {
num: 44,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.right_torque_effectiveness),
is_expanded: false,
};
len += 1;
}
if m.left_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 45,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.left_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.right_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 46,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.right_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.combined_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 47,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.combined_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.time128 != u8::MAX {
arr[len] = Field {
num: 48,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.time128),
is_expanded: false,
};
len += 1;
}
if m.stroke_type != typedef::StrokeType(u8::MAX) {
arr[len] = Field {
num: 49,
profile_type: ProfileType::STROKE_TYPE,
value: Value::Uint8(m.stroke_type.0),
is_expanded: false,
};
len += 1;
}
if m.zone != u8::MAX {
arr[len] = Field {
num: 50,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.zone),
is_expanded: false,
};
len += 1;
}
if m.ball_speed != u16::MAX {
arr[len] = Field {
num: 51,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.ball_speed),
is_expanded: false,
};
len += 1;
}
if m.cadence256 != u16::MAX {
arr[len] = Field {
num: 52,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.cadence256),
is_expanded: false,
};
len += 1;
}
if m.fractional_cadence != u8::MAX {
arr[len] = Field {
num: 53,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.fractional_cadence),
is_expanded: false,
};
len += 1;
}
if m.total_hemoglobin_conc != u16::MAX {
arr[len] = Field {
num: 54,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_hemoglobin_conc),
is_expanded: false,
};
len += 1;
}
if m.total_hemoglobin_conc_min != u16::MAX {
arr[len] = Field {
num: 55,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_hemoglobin_conc_min),
is_expanded: false,
};
len += 1;
}
if m.total_hemoglobin_conc_max != u16::MAX {
arr[len] = Field {
num: 56,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_hemoglobin_conc_max),
is_expanded: false,
};
len += 1;
}
if m.saturated_hemoglobin_percent != u16::MAX {
arr[len] = Field {
num: 57,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.saturated_hemoglobin_percent),
is_expanded: false,
};
len += 1;
}
if m.saturated_hemoglobin_percent_min != u16::MAX {
arr[len] = Field {
num: 58,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.saturated_hemoglobin_percent_min),
is_expanded: false,
};
len += 1;
}
if m.saturated_hemoglobin_percent_max != u16::MAX {
arr[len] = Field {
num: 59,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.saturated_hemoglobin_percent_max),
is_expanded: false,
};
len += 1;
}
if m.device_index != typedef::DeviceIndex(u8::MAX) {
arr[len] = Field {
num: 62,
profile_type: ProfileType::DEVICE_INDEX,
value: Value::Uint8(m.device_index.0),
is_expanded: false,
};
len += 1;
}
if m.left_pco != i8::MAX {
arr[len] = Field {
num: 67,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.left_pco),
is_expanded: false,
};
len += 1;
}
if m.right_pco != i8::MAX {
arr[len] = Field {
num: 68,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.right_pco),
is_expanded: false,
};
len += 1;
}
if m.left_power_phase != Vec::<u8>::new() {
arr[len] = Field {
num: 69,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.left_power_phase),
is_expanded: false,
};
len += 1;
}
if m.left_power_phase_peak != Vec::<u8>::new() {
arr[len] = Field {
num: 70,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.left_power_phase_peak),
is_expanded: false,
};
len += 1;
}
if m.right_power_phase != Vec::<u8>::new() {
arr[len] = Field {
num: 71,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.right_power_phase),
is_expanded: false,
};
len += 1;
}
if m.right_power_phase_peak != Vec::<u8>::new() {
arr[len] = Field {
num: 72,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.right_power_phase_peak),
is_expanded: false,
};
len += 1;
}
if m.enhanced_speed != u32::MAX {
arr[len] = Field {
num: 73,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.enhanced_speed),
is_expanded: is_expanded(&state, 73),
};
len += 1;
}
if m.enhanced_altitude != u32::MAX {
arr[len] = Field {
num: 78,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.enhanced_altitude),
is_expanded: is_expanded(&state, 78),
};
len += 1;
}
if m.battery_soc != u8::MAX {
arr[len] = Field {
num: 81,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.battery_soc),
is_expanded: false,
};
len += 1;
}
if m.motor_power != u16::MAX {
arr[len] = Field {
num: 82,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.motor_power),
is_expanded: false,
};
len += 1;
}
if m.vertical_ratio != u16::MAX {
arr[len] = Field {
num: 83,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.vertical_ratio),
is_expanded: false,
};
len += 1;
}
if m.stance_time_balance != u16::MAX {
arr[len] = Field {
num: 84,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.stance_time_balance),
is_expanded: false,
};
len += 1;
}
if m.step_length != u16::MAX {
arr[len] = Field {
num: 85,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.step_length),
is_expanded: false,
};
len += 1;
}
if m.cycle_length16 != u16::MAX {
arr[len] = Field {
num: 87,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.cycle_length16),
is_expanded: false,
};
len += 1;
}
if m.absolute_pressure != u32::MAX {
arr[len] = Field {
num: 91,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.absolute_pressure),
is_expanded: false,
};
len += 1;
}
if m.depth != u32::MAX {
arr[len] = Field {
num: 92,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.depth),
is_expanded: false,
};
len += 1;
}
if m.next_stop_depth != u32::MAX {
arr[len] = Field {
num: 93,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.next_stop_depth),
is_expanded: false,
};
len += 1;
}
if m.next_stop_time != u32::MAX {
arr[len] = Field {
num: 94,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.next_stop_time),
is_expanded: false,
};
len += 1;
}
if m.time_to_surface != u32::MAX {
arr[len] = Field {
num: 95,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.time_to_surface),
is_expanded: false,
};
len += 1;
}
if m.ndl_time != u32::MAX {
arr[len] = Field {
num: 96,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.ndl_time),
is_expanded: false,
};
len += 1;
}
if m.cns_load != u8::MAX {
arr[len] = Field {
num: 97,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.cns_load),
is_expanded: false,
};
len += 1;
}
if m.n2_load != u16::MAX {
arr[len] = Field {
num: 98,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.n2_load),
is_expanded: false,
};
len += 1;
}
if m.respiration_rate != u8::MAX {
arr[len] = Field {
num: 99,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.respiration_rate),
is_expanded: false,
};
len += 1;
}
if m.enhanced_respiration_rate != u16::MAX {
arr[len] = Field {
num: 108,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.enhanced_respiration_rate),
is_expanded: is_expanded(&state, 108),
};
len += 1;
}
if m.grit != f32::MAX {
arr[len] = Field {
num: 114,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.grit),
is_expanded: false,
};
len += 1;
}
if m.flow != f32::MAX {
arr[len] = Field {
num: 115,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.flow),
is_expanded: false,
};
len += 1;
}
if m.current_stress != u16::MAX {
arr[len] = Field {
num: 116,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.current_stress),
is_expanded: false,
};
len += 1;
}
if m.ebike_travel_range != u16::MAX {
arr[len] = Field {
num: 117,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.ebike_travel_range),
is_expanded: false,
};
len += 1;
}
if m.ebike_battery_level != u8::MAX {
arr[len] = Field {
num: 118,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.ebike_battery_level),
is_expanded: false,
};
len += 1;
}
if m.ebike_assist_mode != u8::MAX {
arr[len] = Field {
num: 119,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.ebike_assist_mode),
is_expanded: false,
};
len += 1;
}
if m.ebike_assist_level_percent != u8::MAX {
arr[len] = Field {
num: 120,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.ebike_assist_level_percent),
is_expanded: false,
};
len += 1;
}
if m.air_time_remaining != u32::MAX {
arr[len] = Field {
num: 123,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.air_time_remaining),
is_expanded: false,
};
len += 1;
}
if m.pressure_sac != u16::MAX {
arr[len] = Field {
num: 124,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.pressure_sac),
is_expanded: false,
};
len += 1;
}
if m.volume_sac != u16::MAX {
arr[len] = Field {
num: 125,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.volume_sac),
is_expanded: false,
};
len += 1;
}
if m.rmv != u16::MAX {
arr[len] = Field {
num: 126,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.rmv),
is_expanded: false,
};
len += 1;
}
if m.ascent_rate != i32::MAX {
arr[len] = Field {
num: 127,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.ascent_rate),
is_expanded: false,
};
len += 1;
}
if m.po2 != u8::MAX {
arr[len] = Field {
num: 129,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.po2),
is_expanded: false,
};
len += 1;
}
if m.core_temperature != u16::MAX {
arr[len] = Field {
num: 139,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.core_temperature),
is_expanded: false,
};
len += 1;
}
Message {
header: 0,
num: typedef::MesgNum::RECORD,
fields: {
let mut fields: Vec<Field> = Vec::with_capacity(len + m.unknown_fields.len());
fields.extend_from_slice(&arr[..len]);
fields.extend_from_slice(&m.unknown_fields);
fields
},
developer_fields: m.developer_fields,
}
}
}