#![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 {
91 | 92 | 93 => (state[num as usize >> 3] >> (num & 7)) & 1 == 1,
_ => false,
}
}
#[derive(Debug, Clone)]
pub struct SegmentLap {
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 sport: typedef::Sport,
pub event_group: u8,
pub nec_lat: i32,
pub nec_long: i32,
pub swc_lat: i32,
pub swc_long: i32,
pub name: String,
pub normalized_power: u16,
pub left_right_balance: typedef::LeftRightBalance100,
pub sub_sport: typedef::SubSport,
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 sport_event: typedef::SportEvent,
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 status: typedef::SegmentLapStatus,
pub uuid: String,
pub avg_fractional_cadence: u8,
pub max_fractional_cadence: u8,
pub total_fractional_cycles: u8,
pub front_gear_shift_count: u16,
pub rear_gear_shift_count: u16,
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 manufacturer: typedef::Manufacturer,
pub total_grit: f32,
pub total_flow: f32,
pub avg_grit: f32,
pub avg_flow: f32,
pub total_fractional_ascent: u8,
pub total_fractional_descent: u8,
pub enhanced_avg_altitude: u32,
pub enhanced_max_altitude: u32,
pub enhanced_min_altitude: u32,
state: [u8; 12], pub unknown_fields: Vec<Field>,
pub developer_fields: Vec<DeveloperField>,
}
impl SegmentLap {
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 SPORT: u8 = 23;
pub const EVENT_GROUP: u8 = 24;
pub const NEC_LAT: u8 = 25;
pub const NEC_LONG: u8 = 26;
pub const SWC_LAT: u8 = 27;
pub const SWC_LONG: u8 = 28;
pub const NAME: u8 = 29;
pub const NORMALIZED_POWER: u8 = 30;
pub const LEFT_RIGHT_BALANCE: u8 = 31;
pub const SUB_SPORT: u8 = 32;
pub const TOTAL_WORK: u8 = 33;
pub const AVG_ALTITUDE: u8 = 34;
pub const MAX_ALTITUDE: u8 = 35;
pub const GPS_ACCURACY: u8 = 36;
pub const AVG_GRADE: u8 = 37;
pub const AVG_POS_GRADE: u8 = 38;
pub const AVG_NEG_GRADE: u8 = 39;
pub const MAX_POS_GRADE: u8 = 40;
pub const MAX_NEG_GRADE: u8 = 41;
pub const AVG_TEMPERATURE: u8 = 42;
pub const MAX_TEMPERATURE: u8 = 43;
pub const TOTAL_MOVING_TIME: u8 = 44;
pub const AVG_POS_VERTICAL_SPEED: u8 = 45;
pub const AVG_NEG_VERTICAL_SPEED: u8 = 46;
pub const MAX_POS_VERTICAL_SPEED: u8 = 47;
pub const MAX_NEG_VERTICAL_SPEED: u8 = 48;
pub const TIME_IN_HR_ZONE: u8 = 49;
pub const TIME_IN_SPEED_ZONE: u8 = 50;
pub const TIME_IN_CADENCE_ZONE: u8 = 51;
pub const TIME_IN_POWER_ZONE: u8 = 52;
pub const REPETITION_NUM: u8 = 53;
pub const MIN_ALTITUDE: u8 = 54;
pub const MIN_HEART_RATE: u8 = 55;
pub const ACTIVE_TIME: u8 = 56;
pub const WKT_STEP_INDEX: u8 = 57;
pub const SPORT_EVENT: u8 = 58;
pub const AVG_LEFT_TORQUE_EFFECTIVENESS: u8 = 59;
pub const AVG_RIGHT_TORQUE_EFFECTIVENESS: u8 = 60;
pub const AVG_LEFT_PEDAL_SMOOTHNESS: u8 = 61;
pub const AVG_RIGHT_PEDAL_SMOOTHNESS: u8 = 62;
pub const AVG_COMBINED_PEDAL_SMOOTHNESS: u8 = 63;
pub const STATUS: u8 = 64;
pub const UUID: u8 = 65;
pub const AVG_FRACTIONAL_CADENCE: u8 = 66;
pub const MAX_FRACTIONAL_CADENCE: u8 = 67;
pub const TOTAL_FRACTIONAL_CYCLES: u8 = 68;
pub const FRONT_GEAR_SHIFT_COUNT: u8 = 69;
pub const REAR_GEAR_SHIFT_COUNT: u8 = 70;
pub const TIME_STANDING: u8 = 71;
pub const STAND_COUNT: u8 = 72;
pub const AVG_LEFT_PCO: u8 = 73;
pub const AVG_RIGHT_PCO: u8 = 74;
pub const AVG_LEFT_POWER_PHASE: u8 = 75;
pub const AVG_LEFT_POWER_PHASE_PEAK: u8 = 76;
pub const AVG_RIGHT_POWER_PHASE: u8 = 77;
pub const AVG_RIGHT_POWER_PHASE_PEAK: u8 = 78;
pub const AVG_POWER_POSITION: u8 = 79;
pub const MAX_POWER_POSITION: u8 = 80;
pub const AVG_CADENCE_POSITION: u8 = 81;
pub const MAX_CADENCE_POSITION: u8 = 82;
pub const MANUFACTURER: u8 = 83;
pub const TOTAL_GRIT: u8 = 84;
pub const TOTAL_FLOW: u8 = 85;
pub const AVG_GRIT: u8 = 86;
pub const AVG_FLOW: u8 = 87;
pub const TOTAL_FRACTIONAL_ASCENT: u8 = 89;
pub const TOTAL_FRACTIONAL_DESCENT: u8 = 90;
pub const ENHANCED_AVG_ALTITUDE: u8 = 91;
pub const ENHANCED_MAX_ALTITUDE: u8 = 92;
pub const ENHANCED_MIN_ALTITUDE: u8 = 93;
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,
sport: typedef::Sport(u8::MAX),
event_group: u8::MAX,
nec_lat: i32::MAX,
nec_long: i32::MAX,
swc_lat: i32::MAX,
swc_long: i32::MAX,
name: String::new(),
normalized_power: u16::MAX,
left_right_balance: typedef::LeftRightBalance100(u16::MAX),
sub_sport: typedef::SubSport(u8::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::<u32>::new(),
time_in_speed_zone: Vec::<u32>::new(),
time_in_cadence_zone: Vec::<u32>::new(),
time_in_power_zone: Vec::<u32>::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),
sport_event: typedef::SportEvent(u8::MAX),
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,
status: typedef::SegmentLapStatus(u8::MAX),
uuid: String::new(),
avg_fractional_cadence: u8::MAX,
max_fractional_cadence: u8::MAX,
total_fractional_cycles: u8::MAX,
front_gear_shift_count: u16::MAX,
rear_gear_shift_count: u16::MAX,
time_standing: u32::MAX,
stand_count: u16::MAX,
avg_left_pco: i8::MAX,
avg_right_pco: i8::MAX,
avg_left_power_phase: Vec::<u8>::new(),
avg_left_power_phase_peak: Vec::<u8>::new(),
avg_right_power_phase: Vec::<u8>::new(),
avg_right_power_phase_peak: Vec::<u8>::new(),
avg_power_position: Vec::<u16>::new(),
max_power_position: Vec::<u16>::new(),
avg_cadence_position: Vec::<u8>::new(),
max_cadence_position: Vec::<u8>::new(),
manufacturer: typedef::Manufacturer(u16::MAX),
total_grit: f32::MAX,
total_flow: f32::MAX,
avg_grit: f32::MAX,
avg_flow: f32::MAX,
total_fractional_ascent: u8::MAX,
total_fractional_descent: u8::MAX,
enhanced_avg_altitude: u32::MAX,
enhanced_max_altitude: u32::MAX,
enhanced_min_altitude: u32::MAX,
state: [0u8; 12],
unknown_fields: Vec::new(),
developer_fields: Vec::new(),
}
}
pub fn total_elapsed_time_scaled(&self) -> f64 {
if self.total_elapsed_time == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.total_elapsed_time as f64 / 1000.0 - 0.0
}
pub fn set_total_elapsed_time_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.total_timer_time == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.total_timer_time as f64 / 1000.0 - 0.0
}
pub fn set_total_timer_time_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.total_distance == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.total_distance as f64 / 100.0 - 0.0
}
pub fn set_total_distance_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_speed == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_speed as f64 / 1000.0 - 0.0
}
pub fn set_avg_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_speed == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_speed as f64 / 1000.0 - 0.0
}
pub fn set_max_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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_altitude_scaled(&self) -> f64 {
if self.avg_altitude == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_altitude as f64 / 5.0 - 500.0
}
pub fn set_avg_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_altitude == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_altitude as f64 / 5.0 - 500.0
}
pub fn set_max_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_grade as f64 / 100.0 - 0.0
}
pub fn set_avg_grade_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_pos_grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_pos_grade as f64 / 100.0 - 0.0
}
pub fn set_avg_pos_grade_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_neg_grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_neg_grade as f64 / 100.0 - 0.0
}
pub fn set_avg_neg_grade_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_pos_grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_pos_grade as f64 / 100.0 - 0.0
}
pub fn set_max_pos_grade_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_neg_grade == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_neg_grade as f64 / 100.0 - 0.0
}
pub fn set_max_neg_grade_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.total_moving_time == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.total_moving_time as f64 / 1000.0 - 0.0
}
pub fn set_total_moving_time_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_pos_vertical_speed == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_pos_vertical_speed as f64 / 1000.0 - 0.0
}
pub fn set_avg_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_neg_vertical_speed == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_neg_vertical_speed as f64 / 1000.0 - 0.0
}
pub fn set_avg_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_pos_vertical_speed == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_pos_vertical_speed as f64 / 1000.0 - 0.0
}
pub fn set_max_pos_vertical_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_neg_vertical_speed == i16::MAX {
return f64::from_bits(u64::MAX);
}
self.max_neg_vertical_speed as f64 / 1000.0 - 0.0
}
pub fn set_max_neg_vertical_speed_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> Vec<f64> {
if self.time_in_hr_zone == Vec::<u32>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_time_in_hr_zone_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.time_in_hr_zone = Vec::new();
return self;
}
self.time_in_hr_zone = Vec::with_capacity(v.len());
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) -> Vec<f64> {
if self.time_in_speed_zone == Vec::<u32>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_time_in_speed_zone_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.time_in_speed_zone = Vec::new();
return self;
}
self.time_in_speed_zone = Vec::with_capacity(v.len());
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) -> Vec<f64> {
if self.time_in_cadence_zone == Vec::<u32>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_time_in_cadence_zone_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.time_in_cadence_zone = Vec::new();
return self;
}
self.time_in_cadence_zone = Vec::with_capacity(v.len());
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) -> Vec<f64> {
if self.time_in_power_zone == Vec::<u32>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_time_in_power_zone_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.time_in_power_zone = Vec::new();
return self;
}
self.time_in_power_zone = Vec::with_capacity(v.len());
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) -> f64 {
if self.min_altitude == u16::MAX {
return f64::from_bits(u64::MAX);
}
self.min_altitude as f64 / 5.0 - 500.0
}
pub fn set_min_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.active_time == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.active_time as f64 / 1000.0 - 0.0
}
pub fn set_active_time_scaled(&mut self, v: f64) -> &mut SegmentLap {
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_left_torque_effectiveness_scaled(&self) -> f64 {
if self.avg_left_torque_effectiveness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_left_torque_effectiveness as f64 / 2.0 - 0.0
}
pub fn set_avg_left_torque_effectiveness_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_right_torque_effectiveness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_right_torque_effectiveness as f64 / 2.0 - 0.0
}
pub fn set_avg_right_torque_effectiveness_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_left_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_left_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_avg_left_pedal_smoothness_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_right_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_right_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_avg_right_pedal_smoothness_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.avg_combined_pedal_smoothness == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_combined_pedal_smoothness as f64 / 2.0 - 0.0
}
pub fn set_avg_combined_pedal_smoothness_scaled(&mut self, v: f64) -> &mut SegmentLap {
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 avg_fractional_cadence_scaled(&self) -> f64 {
if self.avg_fractional_cadence == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.avg_fractional_cadence as f64 / 128.0 - 0.0
}
pub fn set_avg_fractional_cadence_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.max_fractional_cadence == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.max_fractional_cadence as f64 / 128.0 - 0.0
}
pub fn set_max_fractional_cadence_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.total_fractional_cycles == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.total_fractional_cycles as f64 / 128.0 - 0.0
}
pub fn set_total_fractional_cycles_scaled(&mut self, v: f64) -> &mut SegmentLap {
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 time_standing_scaled(&self) -> f64 {
if self.time_standing == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.time_standing as f64 / 1000.0 - 0.0
}
pub fn set_time_standing_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> Vec<f64> {
if self.avg_left_power_phase == Vec::<u8>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_avg_left_power_phase_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.avg_left_power_phase = Vec::new();
return self;
}
self.avg_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.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) -> Vec<f64> {
if self.avg_left_power_phase_peak == Vec::<u8>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_avg_left_power_phase_peak_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.avg_left_power_phase_peak = Vec::new();
return self;
}
self.avg_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.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) -> Vec<f64> {
if self.avg_right_power_phase == Vec::<u8>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_avg_right_power_phase_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.avg_right_power_phase = Vec::new();
return self;
}
self.avg_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.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) -> Vec<f64> {
if self.avg_right_power_phase_peak == Vec::<u8>::new() {
return Vec::new();
}
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)
}
v
}
pub fn set_avg_right_power_phase_peak_scaled(&mut self, v: &Vec<f64>) -> &mut SegmentLap {
if v.is_empty() {
self.avg_right_power_phase_peak = Vec::new();
return self;
}
self.avg_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.avg_right_power_phase_peak.push(u8::MAX);
continue;
}
self.avg_right_power_phase_peak.push(unscaled as u8);
}
self
}
pub fn total_fractional_ascent_scaled(&self) -> f64 {
if self.total_fractional_ascent == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.total_fractional_ascent as f64 / 100.0 - 0.0
}
pub fn set_total_fractional_ascent_scaled(&mut self, v: f64) -> &mut SegmentLap {
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) -> f64 {
if self.total_fractional_descent == u8::MAX {
return f64::from_bits(u64::MAX);
}
self.total_fractional_descent as f64 / 100.0 - 0.0
}
pub fn set_total_fractional_descent_scaled(&mut self, v: f64) -> &mut SegmentLap {
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 enhanced_avg_altitude_scaled(&self) -> f64 {
if self.enhanced_avg_altitude == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_avg_altitude as f64 / 5.0 - 500.0
}
pub fn set_enhanced_avg_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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_max_altitude_scaled(&self) -> f64 {
if self.enhanced_max_altitude == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_max_altitude as f64 / 5.0 - 500.0
}
pub fn set_enhanced_max_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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 enhanced_min_altitude_scaled(&self) -> f64 {
if self.enhanced_min_altitude == u32::MAX {
return f64::from_bits(u64::MAX);
}
self.enhanced_min_altitude as f64 / 5.0 - 500.0
}
pub fn set_enhanced_min_altitude_scaled(&mut self, v: f64) -> &mut SegmentLap {
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 mark_as_expanded(&mut self, num: u8, flag: bool) -> bool {
match num {
91 | 92 | 93 => {
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 SegmentLap {
fn default() -> Self {
Self::new()
}
}
impl From<&Message> for SegmentLap {
fn from(mesg: &Message) -> Self {
let mut vals: [&Value; 255] = [const { &Value::Invalid }; 255];
let mut state = [0u8; 12];
const KNOWN_NUMS: [u64; 4] = [18446744073709551615, 1056964607, 0, 6917529027641081856];
let mut n = 0u64;
for field in &mesg.fields {
n += (KNOWN_NUMS[field.num as usize >> 6] >> (field.num & 63)) & 1 ^ 1
}
let mut 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 < 94 {
state[field.num as usize >> 3] |= 1 << (field.num & 7)
}
vals[field.num as usize] = &field.value;
}
Self {
message_index: typedef::MessageIndex(vals[254].as_u16()),
timestamp: typedef::DateTime(vals[253].as_u32()),
event: typedef::Event(vals[0].as_u8()),
event_type: typedef::EventType(vals[1].as_u8()),
start_time: typedef::DateTime(vals[2].as_u32()),
start_position_lat: vals[3].as_i32(),
start_position_long: vals[4].as_i32(),
end_position_lat: vals[5].as_i32(),
end_position_long: vals[6].as_i32(),
total_elapsed_time: vals[7].as_u32(),
total_timer_time: vals[8].as_u32(),
total_distance: vals[9].as_u32(),
total_cycles: vals[10].as_u32(),
total_calories: vals[11].as_u16(),
total_fat_calories: vals[12].as_u16(),
avg_speed: vals[13].as_u16(),
max_speed: vals[14].as_u16(),
avg_heart_rate: vals[15].as_u8(),
max_heart_rate: vals[16].as_u8(),
avg_cadence: vals[17].as_u8(),
max_cadence: vals[18].as_u8(),
avg_power: vals[19].as_u16(),
max_power: vals[20].as_u16(),
total_ascent: vals[21].as_u16(),
total_descent: vals[22].as_u16(),
sport: typedef::Sport(vals[23].as_u8()),
event_group: vals[24].as_u8(),
nec_lat: vals[25].as_i32(),
nec_long: vals[26].as_i32(),
swc_lat: vals[27].as_i32(),
swc_long: vals[28].as_i32(),
name: vals[29].as_string(),
normalized_power: vals[30].as_u16(),
left_right_balance: typedef::LeftRightBalance100(vals[31].as_u16()),
sub_sport: typedef::SubSport(vals[32].as_u8()),
total_work: vals[33].as_u32(),
avg_altitude: vals[34].as_u16(),
max_altitude: vals[35].as_u16(),
gps_accuracy: vals[36].as_u8(),
avg_grade: vals[37].as_i16(),
avg_pos_grade: vals[38].as_i16(),
avg_neg_grade: vals[39].as_i16(),
max_pos_grade: vals[40].as_i16(),
max_neg_grade: vals[41].as_i16(),
avg_temperature: vals[42].as_i8(),
max_temperature: vals[43].as_i8(),
total_moving_time: vals[44].as_u32(),
avg_pos_vertical_speed: vals[45].as_i16(),
avg_neg_vertical_speed: vals[46].as_i16(),
max_pos_vertical_speed: vals[47].as_i16(),
max_neg_vertical_speed: vals[48].as_i16(),
time_in_hr_zone: vals[49].as_vec_u32(),
time_in_speed_zone: vals[50].as_vec_u32(),
time_in_cadence_zone: vals[51].as_vec_u32(),
time_in_power_zone: vals[52].as_vec_u32(),
repetition_num: vals[53].as_u16(),
min_altitude: vals[54].as_u16(),
min_heart_rate: vals[55].as_u8(),
active_time: vals[56].as_u32(),
wkt_step_index: typedef::MessageIndex(vals[57].as_u16()),
sport_event: typedef::SportEvent(vals[58].as_u8()),
avg_left_torque_effectiveness: vals[59].as_u8(),
avg_right_torque_effectiveness: vals[60].as_u8(),
avg_left_pedal_smoothness: vals[61].as_u8(),
avg_right_pedal_smoothness: vals[62].as_u8(),
avg_combined_pedal_smoothness: vals[63].as_u8(),
status: typedef::SegmentLapStatus(vals[64].as_u8()),
uuid: vals[65].as_string(),
avg_fractional_cadence: vals[66].as_u8(),
max_fractional_cadence: vals[67].as_u8(),
total_fractional_cycles: vals[68].as_u8(),
front_gear_shift_count: vals[69].as_u16(),
rear_gear_shift_count: vals[70].as_u16(),
time_standing: vals[71].as_u32(),
stand_count: vals[72].as_u16(),
avg_left_pco: vals[73].as_i8(),
avg_right_pco: vals[74].as_i8(),
avg_left_power_phase: vals[75].as_vec_u8(),
avg_left_power_phase_peak: vals[76].as_vec_u8(),
avg_right_power_phase: vals[77].as_vec_u8(),
avg_right_power_phase_peak: vals[78].as_vec_u8(),
avg_power_position: vals[79].as_vec_u16(),
max_power_position: vals[80].as_vec_u16(),
avg_cadence_position: vals[81].as_vec_u8(),
max_cadence_position: vals[82].as_vec_u8(),
manufacturer: typedef::Manufacturer(vals[83].as_u16()),
total_grit: vals[84].as_f32(),
total_flow: vals[85].as_f32(),
avg_grit: vals[86].as_f32(),
avg_flow: vals[87].as_f32(),
total_fractional_ascent: vals[89].as_u8(),
total_fractional_descent: vals[90].as_u8(),
enhanced_avg_altitude: vals[91].as_u32(),
enhanced_max_altitude: vals[92].as_u32(),
enhanced_min_altitude: vals[93].as_u32(),
state,
unknown_fields,
developer_fields: mesg.developer_fields.clone(),
}
}
}
impl From<SegmentLap> for Message {
fn from(m: SegmentLap) -> Self {
let mut arr = [const {
Field {
num: 0,
profile_type: ProfileType(0),
value: Value::Invalid,
is_expanded: false,
}
}; 95];
let mut len = 0usize;
let state = m.state;
if m.message_index != typedef::MessageIndex(u16::MAX) {
arr[len] = Field {
num: 254,
profile_type: ProfileType::MESSAGE_INDEX,
value: Value::Uint16(m.message_index.0),
is_expanded: false,
};
len += 1;
}
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.event != typedef::Event(u8::MAX) {
arr[len] = Field {
num: 0,
profile_type: ProfileType::EVENT,
value: Value::Uint8(m.event.0),
is_expanded: false,
};
len += 1;
}
if m.event_type != typedef::EventType(u8::MAX) {
arr[len] = Field {
num: 1,
profile_type: ProfileType::EVENT_TYPE,
value: Value::Uint8(m.event_type.0),
is_expanded: false,
};
len += 1;
}
if m.start_time != typedef::DateTime(u32::MAX) {
arr[len] = Field {
num: 2,
profile_type: ProfileType::DATE_TIME,
value: Value::Uint32(m.start_time.0),
is_expanded: false,
};
len += 1;
}
if m.start_position_lat != i32::MAX {
arr[len] = Field {
num: 3,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.start_position_lat),
is_expanded: false,
};
len += 1;
}
if m.start_position_long != i32::MAX {
arr[len] = Field {
num: 4,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.start_position_long),
is_expanded: false,
};
len += 1;
}
if m.end_position_lat != i32::MAX {
arr[len] = Field {
num: 5,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.end_position_lat),
is_expanded: false,
};
len += 1;
}
if m.end_position_long != i32::MAX {
arr[len] = Field {
num: 6,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.end_position_long),
is_expanded: false,
};
len += 1;
}
if m.total_elapsed_time != u32::MAX {
arr[len] = Field {
num: 7,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_elapsed_time),
is_expanded: false,
};
len += 1;
}
if m.total_timer_time != u32::MAX {
arr[len] = Field {
num: 8,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_timer_time),
is_expanded: false,
};
len += 1;
}
if m.total_distance != u32::MAX {
arr[len] = Field {
num: 9,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_distance),
is_expanded: false,
};
len += 1;
}
if m.total_cycles != u32::MAX {
arr[len] = Field {
num: 10,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_cycles),
is_expanded: false,
};
len += 1;
}
if m.total_calories != u16::MAX {
arr[len] = Field {
num: 11,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_calories),
is_expanded: false,
};
len += 1;
}
if m.total_fat_calories != u16::MAX {
arr[len] = Field {
num: 12,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_fat_calories),
is_expanded: false,
};
len += 1;
}
if m.avg_speed != u16::MAX {
arr[len] = Field {
num: 13,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.avg_speed),
is_expanded: false,
};
len += 1;
}
if m.max_speed != u16::MAX {
arr[len] = Field {
num: 14,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.max_speed),
is_expanded: false,
};
len += 1;
}
if m.avg_heart_rate != u8::MAX {
arr[len] = Field {
num: 15,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_heart_rate),
is_expanded: false,
};
len += 1;
}
if m.max_heart_rate != u8::MAX {
arr[len] = Field {
num: 16,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.max_heart_rate),
is_expanded: false,
};
len += 1;
}
if m.avg_cadence != u8::MAX {
arr[len] = Field {
num: 17,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_cadence),
is_expanded: false,
};
len += 1;
}
if m.max_cadence != u8::MAX {
arr[len] = Field {
num: 18,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.max_cadence),
is_expanded: false,
};
len += 1;
}
if m.avg_power != u16::MAX {
arr[len] = Field {
num: 19,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.avg_power),
is_expanded: false,
};
len += 1;
}
if m.max_power != u16::MAX {
arr[len] = Field {
num: 20,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.max_power),
is_expanded: false,
};
len += 1;
}
if m.total_ascent != u16::MAX {
arr[len] = Field {
num: 21,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_ascent),
is_expanded: false,
};
len += 1;
}
if m.total_descent != u16::MAX {
arr[len] = Field {
num: 22,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.total_descent),
is_expanded: false,
};
len += 1;
}
if m.sport != typedef::Sport(u8::MAX) {
arr[len] = Field {
num: 23,
profile_type: ProfileType::SPORT,
value: Value::Uint8(m.sport.0),
is_expanded: false,
};
len += 1;
}
if m.event_group != u8::MAX {
arr[len] = Field {
num: 24,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.event_group),
is_expanded: false,
};
len += 1;
}
if m.nec_lat != i32::MAX {
arr[len] = Field {
num: 25,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.nec_lat),
is_expanded: false,
};
len += 1;
}
if m.nec_long != i32::MAX {
arr[len] = Field {
num: 26,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.nec_long),
is_expanded: false,
};
len += 1;
}
if m.swc_lat != i32::MAX {
arr[len] = Field {
num: 27,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.swc_lat),
is_expanded: false,
};
len += 1;
}
if m.swc_long != i32::MAX {
arr[len] = Field {
num: 28,
profile_type: ProfileType::SINT32,
value: Value::Int32(m.swc_long),
is_expanded: false,
};
len += 1;
}
if m.name != String::new() {
arr[len] = Field {
num: 29,
profile_type: ProfileType::STRING,
value: Value::String(m.name),
is_expanded: false,
};
len += 1;
}
if m.normalized_power != u16::MAX {
arr[len] = Field {
num: 30,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.normalized_power),
is_expanded: false,
};
len += 1;
}
if m.left_right_balance != typedef::LeftRightBalance100(u16::MAX) {
arr[len] = Field {
num: 31,
profile_type: ProfileType::LEFT_RIGHT_BALANCE_100,
value: Value::Uint16(m.left_right_balance.0),
is_expanded: false,
};
len += 1;
}
if m.sub_sport != typedef::SubSport(u8::MAX) {
arr[len] = Field {
num: 32,
profile_type: ProfileType::SUB_SPORT,
value: Value::Uint8(m.sub_sport.0),
is_expanded: false,
};
len += 1;
}
if m.total_work != u32::MAX {
arr[len] = Field {
num: 33,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_work),
is_expanded: false,
};
len += 1;
}
if m.avg_altitude != u16::MAX {
arr[len] = Field {
num: 34,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.avg_altitude),
is_expanded: false,
};
len += 1;
}
if m.max_altitude != u16::MAX {
arr[len] = Field {
num: 35,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.max_altitude),
is_expanded: false,
};
len += 1;
}
if m.gps_accuracy != u8::MAX {
arr[len] = Field {
num: 36,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.gps_accuracy),
is_expanded: false,
};
len += 1;
}
if m.avg_grade != i16::MAX {
arr[len] = Field {
num: 37,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.avg_grade),
is_expanded: false,
};
len += 1;
}
if m.avg_pos_grade != i16::MAX {
arr[len] = Field {
num: 38,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.avg_pos_grade),
is_expanded: false,
};
len += 1;
}
if m.avg_neg_grade != i16::MAX {
arr[len] = Field {
num: 39,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.avg_neg_grade),
is_expanded: false,
};
len += 1;
}
if m.max_pos_grade != i16::MAX {
arr[len] = Field {
num: 40,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.max_pos_grade),
is_expanded: false,
};
len += 1;
}
if m.max_neg_grade != i16::MAX {
arr[len] = Field {
num: 41,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.max_neg_grade),
is_expanded: false,
};
len += 1;
}
if m.avg_temperature != i8::MAX {
arr[len] = Field {
num: 42,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.avg_temperature),
is_expanded: false,
};
len += 1;
}
if m.max_temperature != i8::MAX {
arr[len] = Field {
num: 43,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.max_temperature),
is_expanded: false,
};
len += 1;
}
if m.total_moving_time != u32::MAX {
arr[len] = Field {
num: 44,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.total_moving_time),
is_expanded: false,
};
len += 1;
}
if m.avg_pos_vertical_speed != i16::MAX {
arr[len] = Field {
num: 45,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.avg_pos_vertical_speed),
is_expanded: false,
};
len += 1;
}
if m.avg_neg_vertical_speed != i16::MAX {
arr[len] = Field {
num: 46,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.avg_neg_vertical_speed),
is_expanded: false,
};
len += 1;
}
if m.max_pos_vertical_speed != i16::MAX {
arr[len] = Field {
num: 47,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.max_pos_vertical_speed),
is_expanded: false,
};
len += 1;
}
if m.max_neg_vertical_speed != i16::MAX {
arr[len] = Field {
num: 48,
profile_type: ProfileType::SINT16,
value: Value::Int16(m.max_neg_vertical_speed),
is_expanded: false,
};
len += 1;
}
if m.time_in_hr_zone != Vec::<u32>::new() {
arr[len] = Field {
num: 49,
profile_type: ProfileType::UINT32,
value: Value::VecUint32(m.time_in_hr_zone),
is_expanded: false,
};
len += 1;
}
if m.time_in_speed_zone != Vec::<u32>::new() {
arr[len] = Field {
num: 50,
profile_type: ProfileType::UINT32,
value: Value::VecUint32(m.time_in_speed_zone),
is_expanded: false,
};
len += 1;
}
if m.time_in_cadence_zone != Vec::<u32>::new() {
arr[len] = Field {
num: 51,
profile_type: ProfileType::UINT32,
value: Value::VecUint32(m.time_in_cadence_zone),
is_expanded: false,
};
len += 1;
}
if m.time_in_power_zone != Vec::<u32>::new() {
arr[len] = Field {
num: 52,
profile_type: ProfileType::UINT32,
value: Value::VecUint32(m.time_in_power_zone),
is_expanded: false,
};
len += 1;
}
if m.repetition_num != u16::MAX {
arr[len] = Field {
num: 53,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.repetition_num),
is_expanded: false,
};
len += 1;
}
if m.min_altitude != u16::MAX {
arr[len] = Field {
num: 54,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.min_altitude),
is_expanded: false,
};
len += 1;
}
if m.min_heart_rate != u8::MAX {
arr[len] = Field {
num: 55,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.min_heart_rate),
is_expanded: false,
};
len += 1;
}
if m.active_time != u32::MAX {
arr[len] = Field {
num: 56,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.active_time),
is_expanded: false,
};
len += 1;
}
if m.wkt_step_index != typedef::MessageIndex(u16::MAX) {
arr[len] = Field {
num: 57,
profile_type: ProfileType::MESSAGE_INDEX,
value: Value::Uint16(m.wkt_step_index.0),
is_expanded: false,
};
len += 1;
}
if m.sport_event != typedef::SportEvent(u8::MAX) {
arr[len] = Field {
num: 58,
profile_type: ProfileType::SPORT_EVENT,
value: Value::Uint8(m.sport_event.0),
is_expanded: false,
};
len += 1;
}
if m.avg_left_torque_effectiveness != u8::MAX {
arr[len] = Field {
num: 59,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_left_torque_effectiveness),
is_expanded: false,
};
len += 1;
}
if m.avg_right_torque_effectiveness != u8::MAX {
arr[len] = Field {
num: 60,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_right_torque_effectiveness),
is_expanded: false,
};
len += 1;
}
if m.avg_left_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 61,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_left_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.avg_right_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 62,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_right_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.avg_combined_pedal_smoothness != u8::MAX {
arr[len] = Field {
num: 63,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_combined_pedal_smoothness),
is_expanded: false,
};
len += 1;
}
if m.status != typedef::SegmentLapStatus(u8::MAX) {
arr[len] = Field {
num: 64,
profile_type: ProfileType::SEGMENT_LAP_STATUS,
value: Value::Uint8(m.status.0),
is_expanded: false,
};
len += 1;
}
if m.uuid != String::new() {
arr[len] = Field {
num: 65,
profile_type: ProfileType::STRING,
value: Value::String(m.uuid),
is_expanded: false,
};
len += 1;
}
if m.avg_fractional_cadence != u8::MAX {
arr[len] = Field {
num: 66,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.avg_fractional_cadence),
is_expanded: false,
};
len += 1;
}
if m.max_fractional_cadence != u8::MAX {
arr[len] = Field {
num: 67,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.max_fractional_cadence),
is_expanded: false,
};
len += 1;
}
if m.total_fractional_cycles != u8::MAX {
arr[len] = Field {
num: 68,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.total_fractional_cycles),
is_expanded: false,
};
len += 1;
}
if m.front_gear_shift_count != u16::MAX {
arr[len] = Field {
num: 69,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.front_gear_shift_count),
is_expanded: false,
};
len += 1;
}
if m.rear_gear_shift_count != u16::MAX {
arr[len] = Field {
num: 70,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.rear_gear_shift_count),
is_expanded: false,
};
len += 1;
}
if m.time_standing != u32::MAX {
arr[len] = Field {
num: 71,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.time_standing),
is_expanded: false,
};
len += 1;
}
if m.stand_count != u16::MAX {
arr[len] = Field {
num: 72,
profile_type: ProfileType::UINT16,
value: Value::Uint16(m.stand_count),
is_expanded: false,
};
len += 1;
}
if m.avg_left_pco != i8::MAX {
arr[len] = Field {
num: 73,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.avg_left_pco),
is_expanded: false,
};
len += 1;
}
if m.avg_right_pco != i8::MAX {
arr[len] = Field {
num: 74,
profile_type: ProfileType::SINT8,
value: Value::Int8(m.avg_right_pco),
is_expanded: false,
};
len += 1;
}
if m.avg_left_power_phase != Vec::<u8>::new() {
arr[len] = Field {
num: 75,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.avg_left_power_phase),
is_expanded: false,
};
len += 1;
}
if m.avg_left_power_phase_peak != Vec::<u8>::new() {
arr[len] = Field {
num: 76,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.avg_left_power_phase_peak),
is_expanded: false,
};
len += 1;
}
if m.avg_right_power_phase != Vec::<u8>::new() {
arr[len] = Field {
num: 77,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.avg_right_power_phase),
is_expanded: false,
};
len += 1;
}
if m.avg_right_power_phase_peak != Vec::<u8>::new() {
arr[len] = Field {
num: 78,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.avg_right_power_phase_peak),
is_expanded: false,
};
len += 1;
}
if m.avg_power_position != Vec::<u16>::new() {
arr[len] = Field {
num: 79,
profile_type: ProfileType::UINT16,
value: Value::VecUint16(m.avg_power_position),
is_expanded: false,
};
len += 1;
}
if m.max_power_position != Vec::<u16>::new() {
arr[len] = Field {
num: 80,
profile_type: ProfileType::UINT16,
value: Value::VecUint16(m.max_power_position),
is_expanded: false,
};
len += 1;
}
if m.avg_cadence_position != Vec::<u8>::new() {
arr[len] = Field {
num: 81,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.avg_cadence_position),
is_expanded: false,
};
len += 1;
}
if m.max_cadence_position != Vec::<u8>::new() {
arr[len] = Field {
num: 82,
profile_type: ProfileType::UINT8,
value: Value::VecUint8(m.max_cadence_position),
is_expanded: false,
};
len += 1;
}
if m.manufacturer != typedef::Manufacturer(u16::MAX) {
arr[len] = Field {
num: 83,
profile_type: ProfileType::MANUFACTURER,
value: Value::Uint16(m.manufacturer.0),
is_expanded: false,
};
len += 1;
}
if m.total_grit != f32::MAX {
arr[len] = Field {
num: 84,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.total_grit),
is_expanded: false,
};
len += 1;
}
if m.total_flow != f32::MAX {
arr[len] = Field {
num: 85,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.total_flow),
is_expanded: false,
};
len += 1;
}
if m.avg_grit != f32::MAX {
arr[len] = Field {
num: 86,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.avg_grit),
is_expanded: false,
};
len += 1;
}
if m.avg_flow != f32::MAX {
arr[len] = Field {
num: 87,
profile_type: ProfileType::FLOAT32,
value: Value::Float32(m.avg_flow),
is_expanded: false,
};
len += 1;
}
if m.total_fractional_ascent != u8::MAX {
arr[len] = Field {
num: 89,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.total_fractional_ascent),
is_expanded: false,
};
len += 1;
}
if m.total_fractional_descent != u8::MAX {
arr[len] = Field {
num: 90,
profile_type: ProfileType::UINT8,
value: Value::Uint8(m.total_fractional_descent),
is_expanded: false,
};
len += 1;
}
if m.enhanced_avg_altitude != u32::MAX {
arr[len] = Field {
num: 91,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.enhanced_avg_altitude),
is_expanded: is_expanded(&state, 91),
};
len += 1;
}
if m.enhanced_max_altitude != u32::MAX {
arr[len] = Field {
num: 92,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.enhanced_max_altitude),
is_expanded: is_expanded(&state, 92),
};
len += 1;
}
if m.enhanced_min_altitude != u32::MAX {
arr[len] = Field {
num: 93,
profile_type: ProfileType::UINT32,
value: Value::Uint32(m.enhanced_min_altitude),
is_expanded: is_expanded(&state, 93),
};
len += 1;
}
Message {
header: 0,
num: typedef::MesgNum::SEGMENT_LAP,
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,
}
}
}