From aa41f978df1cbe9381cf28fdb59a33d10d944ac2 Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Wed, 2 Apr 2025 21:54:12 +0200 Subject: [PATCH 1/4] Add methods for element-wise access to `JointArray` --- nidhogg/src/types/joint_array.rs | 342 ++++++++++++++++++++++++++++--- 1 file changed, 315 insertions(+), 27 deletions(-) diff --git a/nidhogg/src/types/joint_array.rs b/nidhogg/src/types/joint_array.rs index 5dec2e5..db1212c 100644 --- a/nidhogg/src/types/joint_array.rs +++ b/nidhogg/src/types/joint_array.rs @@ -92,6 +92,140 @@ pub struct JointArray { } impl JointArray { + /// Returns a reference to the joint value at the specified index. + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// + /// let joints = JointArray::::default(); + /// assert_eq!(*joints.get(0).unwrap(), 0); // head_yaw + /// assert_eq!(*joints.get(1).unwrap(), 0); // head_pitch + /// assert!(joints.get(25).is_none()); // out of bounds + /// ``` + pub fn get(&self, index: usize) -> Option<&T> { + match index { + 0 => Some(&self.head_yaw), + 1 => Some(&self.head_pitch), + 2 => Some(&self.left_shoulder_pitch), + 3 => Some(&self.left_shoulder_roll), + 4 => Some(&self.left_elbow_yaw), + 5 => Some(&self.left_elbow_roll), + 6 => Some(&self.left_wrist_yaw), + 7 => Some(&self.left_hip_yaw_pitch), + 8 => Some(&self.left_hip_roll), + 9 => Some(&self.left_hip_pitch), + 10 => Some(&self.left_knee_pitch), + 11 => Some(&self.left_ankle_pitch), + 12 => Some(&self.left_ankle_roll), + 13 => Some(&self.right_shoulder_pitch), + 14 => Some(&self.right_shoulder_roll), + 15 => Some(&self.right_elbow_yaw), + 16 => Some(&self.right_elbow_roll), + 17 => Some(&self.right_wrist_yaw), + 18 => Some(&self.right_hip_roll), + 19 => Some(&self.right_hip_pitch), + 20 => Some(&self.right_knee_pitch), + 21 => Some(&self.right_ankle_pitch), + 22 => Some(&self.right_ankle_roll), + 23 => Some(&self.left_hand), + 24 => Some(&self.right_hand), + _ => None, + } + } + + /// Returns a mutable reference to the joint value at the specified index. + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// + /// let mut joints = JointArray::::default(); + /// + /// if let Some(value) = joints.get_mut(0) { + /// *value = 42; + /// } + /// + /// assert_eq!(joints.head_yaw, 42); + /// assert!(joints.get_mut(25).is_none()); // out of bounds + /// ``` + pub fn get_mut(&mut self, index: usize) -> Option<&mut T> { + match index { + 0 => Some(&mut self.head_yaw), + 1 => Some(&mut self.head_pitch), + 2 => Some(&mut self.left_shoulder_pitch), + 3 => Some(&mut self.left_shoulder_roll), + 4 => Some(&mut self.left_elbow_yaw), + 5 => Some(&mut self.left_elbow_roll), + 6 => Some(&mut self.left_wrist_yaw), + 7 => Some(&mut self.left_hip_yaw_pitch), + 8 => Some(&mut self.left_hip_roll), + 9 => Some(&mut self.left_hip_pitch), + 10 => Some(&mut self.left_knee_pitch), + 11 => Some(&mut self.left_ankle_pitch), + 12 => Some(&mut self.left_ankle_roll), + 13 => Some(&mut self.right_shoulder_pitch), + 14 => Some(&mut self.right_shoulder_roll), + 15 => Some(&mut self.right_elbow_yaw), + 16 => Some(&mut self.right_elbow_roll), + 17 => Some(&mut self.right_wrist_yaw), + 18 => Some(&mut self.right_hip_roll), + 19 => Some(&mut self.right_hip_pitch), + 20 => Some(&mut self.right_knee_pitch), + 21 => Some(&mut self.right_ankle_pitch), + 22 => Some(&mut self.right_ankle_roll), + 23 => Some(&mut self.left_hand), + 24 => Some(&mut self.right_hand), + _ => None, + } + } + + /// Converts the [`JointArray`] into a [`Vec`] + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// use nidhogg::types::FillExt; + /// + /// let joints = JointArray::::fill(5); + /// let vec = joints.to_vec(); + /// + /// assert_eq!(vec.len(), 25); + /// assert!(vec.iter().all(|&v| v == 5)); + /// ``` + pub fn to_vec(self) -> Vec { + vec![ + self.head_yaw, + self.head_pitch, + self.left_shoulder_pitch, + self.left_shoulder_roll, + self.left_elbow_yaw, + self.left_elbow_roll, + self.left_wrist_yaw, + self.left_hip_yaw_pitch, + self.left_hip_roll, + self.left_hip_pitch, + self.left_knee_pitch, + self.left_ankle_pitch, + self.left_ankle_roll, + self.right_shoulder_pitch, + self.right_shoulder_roll, + self.right_elbow_yaw, + self.right_elbow_roll, + self.right_wrist_yaw, + self.right_hip_roll, + self.right_hip_pitch, + self.right_knee_pitch, + self.right_ankle_pitch, + self.right_ankle_roll, + self.left_hand, + self.right_hand, + ] + } + /// Transforms each element in the [`JointArray`] using the provided closure `f`, /// producing a new [`JointArray`] with the transformed values. /// @@ -447,6 +581,44 @@ impl FillExt for JointArray { } } +impl TryFrom<&[T]> for JointArray { + type Error = &'static str; + + fn try_from(values: &[T]) -> Result { + if values.len() != 25 { + return Err("Slice must contain exactly 25 elements to convert to JointArray"); + } + + Ok(JointArray { + head_yaw: values[0].clone(), + head_pitch: values[1].clone(), + left_shoulder_pitch: values[2].clone(), + left_shoulder_roll: values[3].clone(), + left_elbow_yaw: values[4].clone(), + left_elbow_roll: values[5].clone(), + left_wrist_yaw: values[6].clone(), + left_hip_yaw_pitch: values[7].clone(), + left_hip_roll: values[8].clone(), + left_hip_pitch: values[9].clone(), + left_knee_pitch: values[10].clone(), + left_ankle_pitch: values[11].clone(), + left_ankle_roll: values[12].clone(), + right_shoulder_pitch: values[13].clone(), + right_shoulder_roll: values[14].clone(), + right_elbow_yaw: values[15].clone(), + right_elbow_roll: values[16].clone(), + right_wrist_yaw: values[17].clone(), + right_hip_roll: values[18].clone(), + right_hip_pitch: values[19].clone(), + right_knee_pitch: values[20].clone(), + right_ankle_pitch: values[21].clone(), + right_ankle_roll: values[22].clone(), + left_hand: values[23].clone(), + right_hand: values[24].clone(), + }) + } +} + impl JointArrayBuilder { /// Set all the joint values to the corresponding values from the provided [`JointArray`]. pub fn joints(mut self, joints: JointArray) -> Self { @@ -573,7 +745,7 @@ impl<'a, T> IntoIterator for &'a JointArray { fn into_iter(self) -> Self::IntoIter { JointArrayIterator { - jointarray: self, + inner: self, index: 0, } } @@ -581,7 +753,7 @@ impl<'a, T> IntoIterator for &'a JointArray { #[derive(Debug)] pub struct JointArrayIterator<'a, T> { - jointarray: &'a JointArray, + inner: &'a JointArray, index: usize, } @@ -589,31 +761,31 @@ impl<'a, T> Iterator for JointArrayIterator<'a, T> { type Item = &'a T; fn next(&mut self) -> Option<&'a T> { let result = match self.index { - 0 => &self.jointarray.head_yaw, - 1 => &self.jointarray.head_pitch, - 2 => &self.jointarray.left_shoulder_pitch, - 3 => &self.jointarray.left_shoulder_roll, - 4 => &self.jointarray.left_elbow_yaw, - 5 => &self.jointarray.left_elbow_roll, - 6 => &self.jointarray.left_wrist_yaw, - 7 => &self.jointarray.left_hip_yaw_pitch, - 8 => &self.jointarray.left_hip_roll, - 9 => &self.jointarray.left_hip_pitch, - 10 => &self.jointarray.left_knee_pitch, - 11 => &self.jointarray.left_ankle_pitch, - 12 => &self.jointarray.left_ankle_roll, - 13 => &self.jointarray.right_shoulder_pitch, - 14 => &self.jointarray.right_shoulder_roll, - 15 => &self.jointarray.right_elbow_yaw, - 16 => &self.jointarray.right_elbow_roll, - 17 => &self.jointarray.right_wrist_yaw, - 18 => &self.jointarray.right_hip_roll, - 19 => &self.jointarray.right_hip_pitch, - 20 => &self.jointarray.right_knee_pitch, - 21 => &self.jointarray.right_ankle_pitch, - 22 => &self.jointarray.right_ankle_roll, - 23 => &self.jointarray.left_hand, - 24 => &self.jointarray.right_hand, + 0 => &self.inner.head_yaw, + 1 => &self.inner.head_pitch, + 2 => &self.inner.left_shoulder_pitch, + 3 => &self.inner.left_shoulder_roll, + 4 => &self.inner.left_elbow_yaw, + 5 => &self.inner.left_elbow_roll, + 6 => &self.inner.left_wrist_yaw, + 7 => &self.inner.left_hip_yaw_pitch, + 8 => &self.inner.left_hip_roll, + 9 => &self.inner.left_hip_pitch, + 10 => &self.inner.left_knee_pitch, + 11 => &self.inner.left_ankle_pitch, + 12 => &self.inner.left_ankle_roll, + 13 => &self.inner.right_shoulder_pitch, + 14 => &self.inner.right_shoulder_roll, + 15 => &self.inner.right_elbow_yaw, + 16 => &self.inner.right_elbow_roll, + 17 => &self.inner.right_wrist_yaw, + 18 => &self.inner.right_hip_roll, + 19 => &self.inner.right_hip_pitch, + 20 => &self.inner.right_knee_pitch, + 21 => &self.inner.right_ankle_pitch, + 22 => &self.inner.right_ankle_roll, + 23 => &self.inner.left_hand, + 24 => &self.inner.right_hand, _ => return None, }; self.index += 1; @@ -643,4 +815,120 @@ mod tests { assert_eq!(t3.head_pitch, (1, 2)); assert_eq!(t3.left_elbow_yaw, (1, 2)); } + + #[test] + fn test_get() { + let joints = JointArray::::fill(5); + + // Test valid indices + assert_eq!(*joints.get(0).unwrap(), 5); // head_yaw + assert_eq!(*joints.get(7).unwrap(), 5); // left_hip_yaw_pitch + assert_eq!(*joints.get(24).unwrap(), 5); // right_hand + + assert_eq!(*joints.get(0).unwrap(), 5); // First element + assert_eq!(*joints.get(24).unwrap(), 5); // Last element + assert!(joints.get(25).is_none()); // Out of bounds + assert!(joints.get(100).is_none()); // Far out of bounds + } + + #[test] + fn test_get_mut() { + let mut joints = JointArray::::fill(5); + + if let Some(value) = joints.get_mut(0) { + *value = 10; + } + assert_eq!(joints.head_yaw, 10); + if let Some(value) = joints.get_mut(13) { + *value = 20; + } + + assert_eq!(joints.right_shoulder_pitch, 20); + assert!(joints.get_mut(25).is_none()); + } + + #[test] + fn test_to_vec() { + let joints = JointArray::::fill(3); + let vec = joints.to_vec(); + + assert_eq!(vec.len(), 25); + assert!(vec.iter().all(|&v| v == 3)); + + let mut custom_joints = JointArray::::default(); + custom_joints.head_yaw = 10; + custom_joints.left_hand = 20; + custom_joints.right_knee_pitch = 30; + + let custom_vec = custom_joints.to_vec(); + assert_eq!(custom_vec[0], 10); // head_yaw + assert_eq!(custom_vec[23], 20); // left_hand + assert_eq!(custom_vec[20], 30); // right_knee_pitch + } + + #[test] + fn test_try_from_slice_too_long() { + let long_slice = [3; 26]; + let long_result = JointArray::::try_from(&long_slice[..]); + assert!(long_result.is_err()); + assert_eq!( + long_result.unwrap_err(), + "Slice must contain exactly 25 elements to convert to JointArray" + ); + } + + #[test] + fn test_try_from_slice_custom_values() { + // Test with custom values + let custom_slice = [ + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, + ]; + let custom_result = JointArray::::try_from(&custom_slice[..]); + assert!(custom_result.is_ok()); + let custom_joints = custom_result.unwrap(); + + assert_eq!(custom_joints.head_yaw, 10); + assert_eq!(custom_joints.head_pitch, 11); + assert_eq!(custom_joints.left_shoulder_pitch, 12); + assert_eq!(custom_joints.right_hand, 34); + } + + #[test] + fn test_get_specific_joints() { + let mut joints = JointArray::::default(); + + joints.head_yaw = 1; + joints.head_pitch = 2; + joints.left_shoulder_pitch = 3; + joints.left_hand = 4; + joints.right_hand = 5; + + assert_eq!(*joints.get(0).unwrap(), 1); // head_yaw + assert_eq!(*joints.get(1).unwrap(), 2); // head_pitch + assert_eq!(*joints.get(2).unwrap(), 3); // left_shoulder_pitch + assert_eq!(*joints.get(23).unwrap(), 4); // left_hand + assert_eq!(*joints.get(24).unwrap(), 5); // right_hand + } + + #[test] + fn test_to_vec_and_try_from_roundtrip() { + let mut original = JointArray::::default(); + original.head_yaw = 42; + original.left_knee_pitch = 100; + original.right_hand = 200; + + let vec = original.clone().to_vec(); + let reconstructed = JointArray::::try_from(&vec[..]).unwrap(); + + // Verify the reconstructed array matches the original + assert_eq!(reconstructed.head_yaw, 42); + assert_eq!(reconstructed.left_knee_pitch, 100); + assert_eq!(reconstructed.right_hand, 200); + + // Verify all fields are equal + for i in 0..25 { + assert_eq!(original.get(i), reconstructed.get(i)); + } + } } From d0725ce44de41380c859858f4ca8235b7ba5cc7d Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Wed, 2 Apr 2025 21:54:41 +0200 Subject: [PATCH 2/4] bump version --- nidhogg/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nidhogg/Cargo.toml b/nidhogg/Cargo.toml index cfb328a..819dac2 100644 --- a/nidhogg/Cargo.toml +++ b/nidhogg/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "nidhogg" -version = "0.5.0" +version = "0.6.0" edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html From dbef972d2723ffe39f22c1764102d25d2d5b02d5 Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Wed, 2 Apr 2025 21:57:08 +0200 Subject: [PATCH 3/4] clipper part 1 --- nidhogg/src/types/joint_array.rs | 36 ++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/nidhogg/src/types/joint_array.rs b/nidhogg/src/types/joint_array.rs index db1212c..54fb61b 100644 --- a/nidhogg/src/types/joint_array.rs +++ b/nidhogg/src/types/joint_array.rs @@ -855,11 +855,12 @@ mod tests { assert_eq!(vec.len(), 25); assert!(vec.iter().all(|&v| v == 3)); - let mut custom_joints = JointArray::::default(); - custom_joints.head_yaw = 10; - custom_joints.left_hand = 20; - custom_joints.right_knee_pitch = 30; - + let custom_joints = JointArray:: { + head_yaw: 10, + left_hand: 20, + right_knee_pitch: 30, + ..Default::default() + }; let custom_vec = custom_joints.to_vec(); assert_eq!(custom_vec[0], 10); // head_yaw assert_eq!(custom_vec[23], 20); // left_hand @@ -896,13 +897,14 @@ mod tests { #[test] fn test_get_specific_joints() { - let mut joints = JointArray::::default(); - - joints.head_yaw = 1; - joints.head_pitch = 2; - joints.left_shoulder_pitch = 3; - joints.left_hand = 4; - joints.right_hand = 5; + let joints = JointArray:: { + head_yaw: 1, + head_pitch: 2, + left_shoulder_pitch: 3, + left_hand: 4, + right_hand: 5, + ..Default::default() + }; assert_eq!(*joints.get(0).unwrap(), 1); // head_yaw assert_eq!(*joints.get(1).unwrap(), 2); // head_pitch @@ -913,10 +915,12 @@ mod tests { #[test] fn test_to_vec_and_try_from_roundtrip() { - let mut original = JointArray::::default(); - original.head_yaw = 42; - original.left_knee_pitch = 100; - original.right_hand = 200; + let original = JointArray:: { + head_yaw: 42, + left_knee_pitch: 100, + right_hand: 200, + ..Default::default() + }; let vec = original.clone().to_vec(); let reconstructed = JointArray::::try_from(&vec[..]).unwrap(); From 8c72741f56b6343882ddc4ebf6f6c9da73bf75b5 Mon Sep 17 00:00:00 2001 From: Gijs de Jong Date: Wed, 2 Apr 2025 22:09:59 +0200 Subject: [PATCH 4/4] Add more methods --- nidhogg/src/types/joint_array.rs | 200 ++++++++++++++++++++++++------- 1 file changed, 158 insertions(+), 42 deletions(-) diff --git a/nidhogg/src/types/joint_array.rs b/nidhogg/src/types/joint_array.rs index 54fb61b..6a30bee 100644 --- a/nidhogg/src/types/joint_array.rs +++ b/nidhogg/src/types/joint_array.rs @@ -182,47 +182,88 @@ impl JointArray { } } - /// Converts the [`JointArray`] into a [`Vec`] + /// Returns a reference to all joint values as a fixed-size array. /// /// # Example /// /// ``` /// use nidhogg::types::JointArray; - /// use nidhogg::types::FillExt; /// - /// let joints = JointArray::::fill(5); - /// let vec = joints.to_vec(); + /// let joints = JointArray::::default(); + /// let values = joints.as_ref(); + /// assert_eq!(values.len(), 25); + /// assert!(values.iter().all(|&v| v == 0)); + /// ``` + pub fn as_array(&self) -> [&T; 25] { + [ + &self.head_yaw, + &self.head_pitch, + &self.left_shoulder_pitch, + &self.left_shoulder_roll, + &self.left_elbow_yaw, + &self.left_elbow_roll, + &self.left_wrist_yaw, + &self.left_hip_yaw_pitch, + &self.left_hip_roll, + &self.left_hip_pitch, + &self.left_knee_pitch, + &self.left_ankle_pitch, + &self.left_ankle_roll, + &self.right_shoulder_pitch, + &self.right_shoulder_roll, + &self.right_elbow_yaw, + &self.right_elbow_roll, + &self.right_wrist_yaw, + &self.right_hip_roll, + &self.right_hip_pitch, + &self.right_knee_pitch, + &self.right_ankle_pitch, + &self.right_ankle_roll, + &self.left_hand, + &self.right_hand, + ] + } + + /// Returns a mutable reference to all joint values as a fixed-size array. + /// + /// # Example /// - /// assert_eq!(vec.len(), 25); - /// assert!(vec.iter().all(|&v| v == 5)); /// ``` - pub fn to_vec(self) -> Vec { - vec![ - self.head_yaw, - self.head_pitch, - self.left_shoulder_pitch, - self.left_shoulder_roll, - self.left_elbow_yaw, - self.left_elbow_roll, - self.left_wrist_yaw, - self.left_hip_yaw_pitch, - self.left_hip_roll, - self.left_hip_pitch, - self.left_knee_pitch, - self.left_ankle_pitch, - self.left_ankle_roll, - self.right_shoulder_pitch, - self.right_shoulder_roll, - self.right_elbow_yaw, - self.right_elbow_roll, - self.right_wrist_yaw, - self.right_hip_roll, - self.right_hip_pitch, - self.right_knee_pitch, - self.right_ankle_pitch, - self.right_ankle_roll, - self.left_hand, - self.right_hand, + /// use nidhogg::types::JointArray; + /// + /// let mut joints = JointArray::::default(); + /// for joint in joints.as_mut() { + /// *joint = 42; + /// } + /// assert!(joints.as_ref().iter().all(|&v| v == 42)); + /// ``` + pub fn as_array_mut(&mut self) -> [&mut T; 25] { + [ + &mut self.head_yaw, + &mut self.head_pitch, + &mut self.left_shoulder_pitch, + &mut self.left_shoulder_roll, + &mut self.left_elbow_yaw, + &mut self.left_elbow_roll, + &mut self.left_wrist_yaw, + &mut self.left_hip_yaw_pitch, + &mut self.left_hip_roll, + &mut self.left_hip_pitch, + &mut self.left_knee_pitch, + &mut self.left_ankle_pitch, + &mut self.left_ankle_roll, + &mut self.right_shoulder_pitch, + &mut self.right_shoulder_roll, + &mut self.right_elbow_yaw, + &mut self.right_elbow_roll, + &mut self.right_wrist_yaw, + &mut self.right_hip_roll, + &mut self.right_hip_pitch, + &mut self.right_knee_pitch, + &mut self.right_ankle_pitch, + &mut self.right_ankle_roll, + &mut self.left_hand, + &mut self.right_hand, ] } @@ -404,6 +445,18 @@ impl JointArray { .map(|(curr, target)| (curr - target).abs()) } + /// Creates a new [`JointArray`] containing references to each joint value. + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// + /// let joints = JointArray::::default(); + /// let refs = joints.as_ref(); + /// assert_eq!(*refs.head_yaw, 0); + /// assert_eq!(*refs.left_hand, 0); + /// ``` pub fn as_ref(&self) -> JointArray<&T> { JointArray { head_yaw: &self.head_yaw, @@ -433,6 +486,22 @@ impl JointArray { right_hand: &self.right_hand, } } + + /// Creates a new [`JointArray`] containing mutable references to each joint value. + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// + /// let mut joints = JointArray::::default(); + /// let mut refs = joints.as_mut(); + /// *refs.head_yaw = 42; + /// *refs.left_hand = 17; + /// + /// assert_eq!(joints.head_yaw, 42); + /// assert_eq!(joints.left_hand, 17); + /// ``` pub fn as_mut(&mut self) -> JointArray<&mut T> { JointArray { head_yaw: &mut self.head_yaw, @@ -462,6 +531,50 @@ impl JointArray { right_hand: &mut self.right_hand, } } + + /// Converts the [`JointArray`] into a [`Vec`] + /// + /// # Example + /// + /// ``` + /// use nidhogg::types::JointArray; + /// use nidhogg::types::FillExt; + /// + /// let joints = JointArray::::fill(5); + /// let vec = joints.to_vec(); + /// + /// assert_eq!(vec.len(), 25); + /// assert!(vec.iter().all(|&v| v == 5)); + /// ``` + pub fn to_vec(self) -> Vec { + vec![ + self.head_yaw, + self.head_pitch, + self.left_shoulder_pitch, + self.left_shoulder_roll, + self.left_elbow_yaw, + self.left_elbow_roll, + self.left_wrist_yaw, + self.left_hip_yaw_pitch, + self.left_hip_roll, + self.left_hip_pitch, + self.left_knee_pitch, + self.left_ankle_pitch, + self.left_ankle_roll, + self.right_shoulder_pitch, + self.right_shoulder_roll, + self.right_elbow_yaw, + self.right_elbow_roll, + self.right_wrist_yaw, + self.right_hip_roll, + self.right_hip_pitch, + self.right_knee_pitch, + self.right_ankle_pitch, + self.right_ankle_roll, + self.left_hand, + self.right_hand, + ] + } } impl<'a, T> From<&'a JointArray> for JointArray<&'a T> { @@ -846,25 +959,28 @@ mod tests { assert_eq!(joints.right_shoulder_pitch, 20); assert!(joints.get_mut(25).is_none()); } - #[test] - fn test_to_vec() { + fn test_as_array() { let joints = JointArray::::fill(3); - let vec = joints.to_vec(); + let array = joints.as_array(); - assert_eq!(vec.len(), 25); - assert!(vec.iter().all(|&v| v == 3)); + assert_eq!(array.len(), 25); + assert!(array.iter().all(|&v| *v == 3)); + } + #[test] + fn test_to_vec() { let custom_joints = JointArray:: { head_yaw: 10, left_hand: 20, right_knee_pitch: 30, ..Default::default() }; - let custom_vec = custom_joints.to_vec(); - assert_eq!(custom_vec[0], 10); // head_yaw - assert_eq!(custom_vec[23], 20); // left_hand - assert_eq!(custom_vec[20], 30); // right_knee_pitch + let vec = custom_joints.to_vec(); + + assert_eq!(vec[0], 10); // head_yaw + assert_eq!(vec[23], 20); // left_hand + assert_eq!(vec[20], 30); // right_knee_pitch } #[test]