motorcortex-rust 0.5.0

pub trait SetParameterValue {
    fn to_bytes_as_bool(&self) -> Vec<u8>;
    fn to_bytes_as_i8(&self) -> Vec<u8>;
    fn to_bytes_as_u8(&self) -> Vec<u8>;
    fn to_bytes_as_i16(&self) -> Vec<u8>;
    fn to_bytes_as_u16(&self) -> Vec<u8>;
    fn to_bytes_as_i32(&self) -> Vec<u8>;
    fn to_bytes_as_u32(&self) -> Vec<u8>;
    fn to_bytes_as_f32(&self) -> Vec<u8>;
    fn to_bytes_as_i64(&self) -> Vec<u8>;
    fn to_bytes_as_u64(&self) -> Vec<u8>;
    fn to_bytes_as_f64(&self) -> Vec<u8>;
    fn to_bytes_as_string(&self) -> Vec<u8>;
}

// Value
macro_rules! impl_set_parameter_value {
    ($t:ty) => {
        impl SetParameterValue for $t {
            fn to_bytes_as_bool(&self) -> Vec<u8> {
                vec![(*self != Default::default()) as u8]
            }
            fn to_bytes_as_i8(&self) -> Vec<u8> {
                (*self as i8).to_le_bytes().to_vec()
            }
            fn to_bytes_as_u8(&self) -> Vec<u8> {
                (*self as u8).to_le_bytes().to_vec()
            }
            fn to_bytes_as_i16(&self) -> Vec<u8> {
                (*self as i16).to_le_bytes().to_vec()
            }
            fn to_bytes_as_u16(&self) -> Vec<u8> {
                (*self as u16).to_le_bytes().to_vec()
            }
            fn to_bytes_as_i32(&self) -> Vec<u8> {
                (*self as i32).to_le_bytes().to_vec()
            }
            fn to_bytes_as_u32(&self) -> Vec<u8> {
                (*self as u32).to_le_bytes().to_vec()
            }
            fn to_bytes_as_f32(&self) -> Vec<u8> {
                (*self as f32).to_le_bytes().to_vec()
            }
            fn to_bytes_as_i64(&self) -> Vec<u8> {
                (*self as i64).to_le_bytes().to_vec()
            }
            fn to_bytes_as_u64(&self) -> Vec<u8> {
                (*self as u64).to_le_bytes().to_vec()
            }
            fn to_bytes_as_f64(&self) -> Vec<u8> {
                (*self as f64).to_le_bytes().to_vec()
            }
            fn to_bytes_as_string(&self) -> Vec<u8> {
                self.to_string().as_bytes().to_vec()
            }
        }
    };
}
// Specialization for `bool`
impl SetParameterValue for bool {
    fn to_bytes_as_bool(&self) -> Vec<u8> {
        vec![(*self) as u8]
    }
    fn to_bytes_as_i8(&self) -> Vec<u8> {
        (*self as i8).to_le_bytes().to_vec()
    }
    fn to_bytes_as_u8(&self) -> Vec<u8> {
        (*self as u8).to_le_bytes().to_vec()
    }
    fn to_bytes_as_i16(&self) -> Vec<u8> {
        (*self as i16).to_le_bytes().to_vec()
    }
    fn to_bytes_as_u16(&self) -> Vec<u8> {
        (*self as u16).to_le_bytes().to_vec()
    }
    fn to_bytes_as_i32(&self) -> Vec<u8> {
        (*self as i32).to_le_bytes().to_vec()
    }
    fn to_bytes_as_u32(&self) -> Vec<u8> {
        (*self as u32).to_le_bytes().to_vec()
    }
    fn to_bytes_as_f32(&self) -> Vec<u8> {
        let value: f32 = if *self { 1.0 } else { 0.0 };
        value.to_le_bytes().to_vec()
    }
    fn to_bytes_as_i64(&self) -> Vec<u8> {
        (*self as i64).to_le_bytes().to_vec()
    }
    fn to_bytes_as_u64(&self) -> Vec<u8> {
        (*self as u64).to_le_bytes().to_vec()
    }
    fn to_bytes_as_f64(&self) -> Vec<u8> {
        let value: f64 = if *self { 1.0 } else { 0.0 };
        value.to_le_bytes().to_vec()
    }
    fn to_bytes_as_string(&self) -> Vec<u8> {
        self.to_string().as_bytes().to_vec()
    }
}
impl SetParameterValue for &str {
    fn to_bytes_as_bool(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i8(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u8(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i16(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u16(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_f32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_f64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_string(&self) -> Vec<u8> {
        self.as_bytes().to_vec()
    }
}

impl SetParameterValue for String {
    fn to_bytes_as_bool(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i8(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u8(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i16(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u16(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_f32(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_i64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_u64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_f64(&self) -> Vec<u8> {
        vec![]
    }
    fn to_bytes_as_string(&self) -> Vec<u8> {
        self.as_bytes().to_vec()
    }
}

// Generate implementations for standard numeric types
impl_set_parameter_value!(i8);
impl_set_parameter_value!(u8);
impl_set_parameter_value!(i16);
impl_set_parameter_value!(u16);
impl_set_parameter_value!(i32);
impl_set_parameter_value!(u32);
impl_set_parameter_value!(i64);
impl_set_parameter_value!(u64);
impl_set_parameter_value!(f32);
impl_set_parameter_value!(f64);

// Vector
macro_rules! impl_set_parameter_array {
    ($t:ty) => {
        impl<const N: usize> SetParameterValue for [$t; N] {
            fn to_bytes_as_bool(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.push((val != Default::default()) as u8);
                }
                result
            }
            fn to_bytes_as_i8(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i8).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u8(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u8).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i16(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<i16>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i16).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u16(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<u16>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u16).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<i32>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<u32>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_f32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<f32>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as f32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<i64>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<u64>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_f64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(N * size_of::<f64>());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as f64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_string(&self) -> Vec<u8> {
                vec![]
            }
        }
    };
}
// Generate implementations for standard numeric types
impl_set_parameter_array!(i8);
impl_set_parameter_array!(u8);
impl_set_parameter_array!(i16);
impl_set_parameter_array!(u16);
impl_set_parameter_array!(i32);
impl_set_parameter_array!(u32);
impl_set_parameter_array!(i64);
impl_set_parameter_array!(u64);
impl_set_parameter_array!(f32);
impl_set_parameter_array!(f64);

impl<const N: usize> SetParameterValue for [bool; N] {
    fn to_bytes_as_bool(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.push((val != Default::default()) as u8);
        }
        result
    }
    fn to_bytes_as_i8(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i8).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u8(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u8).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i16(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<i16>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i16).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u16(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<u16>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u16).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<i32>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<u32>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_f32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<f32>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u32 as f32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<i64>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<u64>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_f64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(N * size_of::<f64>());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u64 as f64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_string(&self) -> Vec<u8> {
        vec![]
    }
}

macro_rules! impl_set_parameter_vec {
    ($t:ty) => {
        impl SetParameterValue for Vec<$t> {
            fn to_bytes_as_bool(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.push((val != Default::default()) as u8);
                }
                result
            }
            fn to_bytes_as_i8(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i8).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u8(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len());
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u8).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i16(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 2);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i16).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u16(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 2);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u16).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 4);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 4);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_f32(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 4);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as f32).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_i64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 8);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as i64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_u64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 8);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as u64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_f64(&self) -> Vec<u8> {
                // Pre-allocate enough space in the vector
                let mut result = Vec::with_capacity(self.len() * 8);
                // Extend the vector with the bytes of each element
                for &val in self {
                    result.extend_from_slice(&(val as f64).to_le_bytes());
                }
                result
            }
            fn to_bytes_as_string(&self) -> Vec<u8> {
                vec![]
            }
        }
    };
}

impl_set_parameter_vec!(i8);
impl_set_parameter_vec!(u8);
impl_set_parameter_vec!(i16);
impl_set_parameter_vec!(u16);
impl_set_parameter_vec!(i32);
impl_set_parameter_vec!(u32);
impl_set_parameter_vec!(i64);
impl_set_parameter_vec!(u64);
impl_set_parameter_vec!(f32);
impl_set_parameter_vec!(f64);

impl SetParameterValue for Vec<bool> {
    fn to_bytes_as_bool(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.push((val != Default::default()) as u8);
        }
        result
    }
    fn to_bytes_as_i8(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i8).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u8(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len());
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u8).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i16(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 2);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i16).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u16(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 2);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u16).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 4);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 4);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_f32(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 4);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u32 as f32).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_i64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 8);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as i64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_u64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 8);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_f64(&self) -> Vec<u8> {
        // Pre-allocate enough space in the vector
        let mut result = Vec::with_capacity(self.len() / 8);
        // Extend the vector with the bytes of each element
        for &val in self {
            result.extend_from_slice(&(val as u64 as f64).to_le_bytes());
        }
        result
    }
    fn to_bytes_as_string(&self) -> Vec<u8> {
        vec![]
    }
}