Replace packing and unpacking with bitvec (#7)

Author: marcelbuesing

Cargo.lock

@@ -59,7 +59,10 @@ fn main() -> Result<()> {
     writeln!(&mut w, "//!")?;
     writeln!(&mut w, "//! - Version: `{:?}`", dbc.version())?;
     writeln!(&mut w)?;
-    writeln!(&mut w, "use bitsh::Pack;")?;
+    writeln!(
+        &mut w,
+        "use bitvec::prelude::{{BitField, BitStore, BitView, LocalBits}};"
+    )?;
     writeln!(w, r##"#[cfg(feature = "arb")]"##)?;
     writeln!(&mut w, "use arbitrary::{{Arbitrary, Unstructured}};")?;
     writeln!(&mut w)?;
@@ -407,22 +410,30 @@ fn render_signal(mut w: impl Write, signal: &Signal, dbc: &DBC, msg: &Message) -
 fn signal_from_payload(mut w: impl Write, signal: &Signal) -> Result<()> {
     let read_fn = match signal.byte_order() {
         can_dbc::ByteOrder::LittleEndian => format!(
-            "{typ}::unpack_le_bits(&self.raw, {start}, {size})",
-            typ = signal_to_rust_int(signal),
+            "self.raw.view_bits::<LocalBits>()[{start}..{end}].load_le::<{typ}>()",
+            typ = signal_to_rust_uint(signal),
             start = signal.start_bit,
-            size = signal.signal_size,
+            end = signal.start_bit + signal.signal_size
         ),
         can_dbc::ByteOrder::BigEndian => format!(
-            "{typ}::unpack_be_bits(&self.raw, ({start} - ({size} - 1)), {size})",
-            typ = signal_to_rust_int(signal),
-            start = signal.start_bit,
-            size = signal.signal_size,
+            "self.raw.view_bits::<LocalBits>()[{start}..{end}].load_be::<{typ}>()",
+            typ = signal_to_rust_uint(signal),
+            start = signal.start_bit + 1 - signal.signal_size,
+            end = signal.start_bit + 1,
         ),
     };
 
     writeln!(&mut w, r#"let signal = {};"#, read_fn)?;
     writeln!(&mut w)?;
 
+    if *signal.value_type() == can_dbc::ValueType::Signed {
+        writeln!(
+            &mut w,
+            "let signal  = {}::from_ne_bytes(signal.to_ne_bytes());",
+            signal_to_rust_int(signal)
+        )?;
+    };
+
     if signal.signal_size == 1 {
         writeln!(&mut w, "signal == 1")?;
     } else if signal_is_float_in_rust(signal) {
@@ -452,18 +463,32 @@ fn signal_to_payload(mut w: impl Write, signal: &Signal) -> Result<()> {
         writeln!(&mut w)?;
     }
 
-    writeln!(&mut w, "let start_bit = {};", signal.start_bit)?;
-    writeln!(&mut w, "let bits = {};", signal.signal_size)?;
-    let endianness = match signal.byte_order() {
-        can_dbc::ByteOrder::LittleEndian => "le",
-        can_dbc::ByteOrder::BigEndian => "be",
+    if *signal.value_type() == can_dbc::ValueType::Signed {
+        writeln!(
+            &mut w,
+            "let value = {}::from_ne_bytes(value.to_ne_bytes());",
+            signal_to_rust_uint(signal)
+        )?;
     };
 
-    writeln!(
-        &mut w,
-        r#"value.pack_{}_bits(&mut self.raw, start_bit, bits);"#,
-        endianness
-    )?;
+    match signal.byte_order() {
+        can_dbc::ByteOrder::LittleEndian => {
+            writeln!(
+                &mut w,
+                r#"self.raw.view_bits_mut::<LocalBits>()[{start_bit}..{end_bit}].store_le(value);"#,
+                start_bit = signal.start_bit,
+                end_bit = signal.start_bit + signal.signal_size,
+            )?;
+        }
+        can_dbc::ByteOrder::BigEndian => {
+            writeln!(
+                &mut w,
+                r#"self.raw.view_bits_mut::<LocalBits>()[{start_bit}..{end_bit}].store_be(value);"#,
+                start_bit = signal.start_bit + 1 - signal.signal_size,
+                end_bit = signal.start_bit + 1,
+            )?;
+        }
+    };
 
     writeln!(&mut w, "Ok(())")?;
     Ok(())
@@ -506,6 +531,17 @@ fn signal_to_rust_int(signal: &Signal) -> String {
     format!("{}{}", sign, size)
 }
 
+fn signal_to_rust_uint(signal: &Signal) -> String {
+    let size = match *signal.signal_size() {
+        n if n <= 8 => "8",
+        n if n <= 16 => "16",
+        n if n <= 32 => "32",
+        _ => "64",
+    };
+
+    format!("u{}", size)
+}
+
 #[allow(clippy::float_cmp)]
 fn signal_is_float_in_rust(signal: &Signal) -> bool {
     *signal.offset() != 0.0 || *signal.factor() != 1.0

src/main.rs

@@ -6,7 +6,7 @@ edition = "2018"
 
 [dependencies]
 arbitrary = { version = "1.0", optional = true }
-bitsh = { git = "https://github.com/bitbleep/bitsh/" }
+bitvec = { version = "0.21", default-features = false }
 
 [features]
 default = ["debug", "arb"]

testing/can-messages/Cargo.toml

@@ -17,3 +17,27 @@ fn check_range_value_valid() {
     let result = messages::Bar::new(1, 2.0, 3, 3);
     assert!(result.is_ok());
 }
+
+#[test]
+fn pack_unpack_message() {
+    let result = messages::Foo::new(63.99899, 10.0).unwrap();
+    assert_eq!(result.voltage_raw(), 63.99899);
+    assert_eq!(result.current_raw(), 10.0);
+}
+
+#[test]
+fn pack_unpack_message_negative() {
+    let result = messages::Foo::new(0.000976562, -3.0 * 0.0625).unwrap();
+    assert_eq!(result.voltage_raw(), 0.000976562);
+    assert_eq!(result.current_raw(), -3.0 * 0.0625);
+}
+
+#[test]
+fn pack_unpack_message2() {
+    let result = messages::Amet::new(1, 0.39, 3, 3, true).unwrap();
+    assert_eq!(result.one_raw(), 1);
+    assert_eq!(result.two_raw(), 0.39);
+    assert_eq!(result.three_raw(), 3);
+    assert_eq!(result.four_raw(), 3);
+    assert_eq!(result.five_raw(), true);
+}