Merge pull request #69 from hashmismatch/const_generics

Const generics for byte array types

Author: rudib

README.md

@@ -35,7 +35,7 @@ provide safe packing, unpacking and runtime debugging formatters with per-field
 
 ```toml
 [dependencies]
-packed_struct = "0.6"
+packed_struct = "0.10"
 ```
 ## Importing the library with the the most common traits and the derive macros
 
@@ -55,7 +55,7 @@ use packed_struct::prelude::*;
 #[packed_struct(bit_numbering="msb0")]
 pub struct TestPack {
     #[packed_field(bits="0..=2")]
-    tiny_int: Integer<u8, packed_bits::Bits3>,
+    tiny_int: Integer<u8, packed_bits::Bits::<3>>,
     #[packed_field(bits="3..=4", ty="enum")]
     mode: SelfTestMode,
     #[packed_field(bits="7")]
@@ -176,7 +176,7 @@ use packed_struct::prelude::*;
 #[derive(PackedStruct)]
 #[packed_struct(endian="lsb")]
 pub struct LsbIntExample {
-    int1: Integer<u32, packed_bits::Bits24>,
+    int1: Integer<u32, packed_bits::Bits::<24>>,
 }
 
 fn main() -> Result<(), PackingError> {
@@ -229,9 +229,9 @@ use packed_struct::prelude::*;
 #[derive(PackedStruct, Default, Debug, PartialEq)]
 #[packed_struct(bit_numbering="msb0")]
 pub struct TinyFlags {
-    _reserved: ReservedZero<packed_bits::Bits4>,
+    _reserved: ReservedZero<packed_bits::Bits::<4>>,
     flag1: bool,
-    val1: Integer<u8, packed_bits::Bits2>,
+    val1: Integer<u8, packed_bits::Bits::<2>>,
     flag2: bool
 }
 

packed_struct/Cargo.toml

@@ -3,19 +3,20 @@ name = "packed_struct"
 description = "Binary-level structure packing and unpacking generator"
 repository = "https://github.com/hashmismatch/packed_struct.rs"
 homepage = "http://www.hashmismatch.net/libraries/packed-struct/"
-version = "0.6.1"
+version = "0.10.0"
+rust-version = "1.51"
 authors = ["Rudi Benkovic <[email protected]>"]
-build = "build.rs"
 license = "MIT OR Apache-2.0"
 keywords = ["enum", "packing", "serialization"]
 categories = ["encoding"]
 readme = "../README.md"
 edition = "2018"
 
 [dependencies]
-packed_struct_codegen = { path = "../packed_struct_codegen/", version = "0.6.1" }
+packed_struct_codegen = { path = "../packed_struct_codegen/", version = "0.10.0" }
 serde = { version = "1.0", optional = true, default-features = false }
 serde_derive = { version = "1.0", optional = true }
+bitvec = { version = "0.22.3", default-features = false }
 
 [features]
 default = ["std"]

packed_struct/build.rs

@@ -21,16 +21,9 @@ fn main() {
             32
         };
 
-    // bytes
-    for i in 0..(up_to_bytes + 1) {
-
-        let b = format!("bytes_type!(Bytes{}, {});\r\n", i, i);
-        f.write_all(b.as_bytes()).unwrap();
-    }
-
     // bits
     for i in 1..(up_to_bytes * 8) {
-        let b = format!("bits_type!(Bits{}, {}, Bytes{}, {});\r\n", i, i, (i as f32 / 8.0).ceil() as usize, if (i % 8) == 0 {
+        let b = format!("bits_type!(Bits::<{}>, {}, Bytes::<{}>, {});\r\n", i, i, (i as f32 / 8.0).ceil() as usize, if (i % 8) == 0 {
             "BitsFullBytes"
         } else {
             "BitsPartialBytes"

packed_struct/src/lib.rs

@@ -35,7 +35,7 @@
 //!
 //! ```toml
 //! [dependencies]
-//! packed_struct = "0.6"
+//! packed_struct = "0.10"
 //! ```
 //! ## Importing the library with the the most common traits and the derive macros
 //!
@@ -57,7 +57,7 @@
 //! #[packed_struct(bit_numbering="msb0")]
 //! pub struct TestPack {
 //!     #[packed_field(bits="0..=2")]
-//!     tiny_int: Integer<u8, packed_bits::Bits3>,
+//!     tiny_int: Integer<u8, packed_bits::Bits::<3>>,
 //!     #[packed_field(bits="3..=4", ty="enum")]
 //!     mode: SelfTestMode,
 //!     #[packed_field(bits="7")]
@@ -180,7 +180,7 @@
 //! #[derive(PackedStruct)]
 //! #[packed_struct(endian="lsb")]
 //! pub struct LsbIntExample {
-//!     int1: Integer<u32, packed_bits::Bits24>,
+//!     int1: Integer<u32, packed_bits::Bits::<24>>,
 //! }
 //!
 //! fn main() -> Result<(), PackingError> {
@@ -233,9 +233,9 @@
 //! #[derive(PackedStruct, Default, Debug, PartialEq)]
 //! #[packed_struct(bit_numbering="msb0")]
 //! pub struct TinyFlags {
-//!     _reserved: ReservedZero<packed_bits::Bits4>,
+//!     _reserved: ReservedZero<packed_bits::Bits::<4>>,
 //!     flag1: bool,
-//!     val1: Integer<u8, packed_bits::Bits2>,
+//!     val1: Integer<u8, packed_bits::Bits::<2>>,
 //!     flag2: bool
 //! }
 //!

packed_struct/src/packing.rs

@@ -10,7 +10,9 @@ use crate::types_bits::ByteArray;
 /// 
 /// 10 bits packs into: [0b00000011, 0b11111111]
 pub trait PackedStruct where Self: Sized {
+    /// The appropriately sized byte array into which this structure will be packed, for example [u8; 2]. 
     type ByteArray : ByteArray;
+    
     /// Packs the structure into a byte array.
     fn pack(&self) -> PackingResult<Self::ByteArray>;
     /// Unpacks the structure from a byte array.

packed_struct/src/types_array.rs

@@ -1,61 +1,23 @@
-use super::packing::*;
+use crate::{PackedStruct, PackedStructInfo, PackingError, PackingResult};
 
-macro_rules! packable_u8_array {
-    ($N: expr) => (
+impl<const N: usize> PackedStruct for [u8; N] {
+    type ByteArray = [u8; N];
 
-        impl PackedStruct for [u8; $N] {
-            type ByteArray = [u8; $N];
+    #[inline]
+    fn pack(&self) -> PackingResult<Self::ByteArray> {
+        Ok(*self)
+    }
 
-            #[inline]
-            fn pack(&self) -> PackingResult<Self::ByteArray> {
-                Ok(*self)
-            }
-
-            #[inline]
-            fn unpack(src: &Self::ByteArray) -> Result<Self::ByteArray, PackingError> {
-                Ok(*src)
-            }
-        }
-
-        impl PackedStructInfo for [u8; $N] {
-            #[inline]
-            fn packed_bits() -> usize {
-                $N * 8
-            } 
-        }
-    )
+    #[inline]
+    fn unpack(src: &Self::ByteArray) -> Result<Self::ByteArray, PackingError> {
+        Ok(*src)
+    }    
 }
 
-packable_u8_array!(0);
-packable_u8_array!(1);
-packable_u8_array!(2);
-packable_u8_array!(3);
-packable_u8_array!(4);
-packable_u8_array!(5);
-packable_u8_array!(6);
-packable_u8_array!(7);
-packable_u8_array!(8);
-packable_u8_array!(9);
-packable_u8_array!(10);
-packable_u8_array!(11);
-packable_u8_array!(12);
-packable_u8_array!(13);
-packable_u8_array!(14);
-packable_u8_array!(15);
-packable_u8_array!(16);
-packable_u8_array!(17);
-packable_u8_array!(18);
-packable_u8_array!(19);
-packable_u8_array!(20);
-packable_u8_array!(21);
-packable_u8_array!(22);
-packable_u8_array!(23);
-packable_u8_array!(24);
-packable_u8_array!(25);
-packable_u8_array!(26);
-packable_u8_array!(27);
-packable_u8_array!(28);
-packable_u8_array!(29);
-packable_u8_array!(30);
-packable_u8_array!(31);
-packable_u8_array!(32);
+
+impl<const N: usize> PackedStructInfo for [u8; N] {
+    #[inline]
+    fn packed_bits() -> usize {
+        N * 8
+    } 
+}

packed_struct/src/types_bits.rs

@@ -10,6 +10,10 @@ pub trait NumberOfBits: Copy + Clone + Debug + Default {
 
     /// The numerical number of bits.
     fn number_of_bits() -> usize;
+
+    fn byte_array_len() -> usize {
+        <<Self::Bytes as NumberOfBytes>::AsBytes as ByteArray>::len()
+    }
 }
 
 /// These bits are a multiple of 8
@@ -30,61 +34,57 @@ pub trait NumberOfBytes: Copy + Clone + Debug + Default {
 }
 
 /// Helper that allows us to cast a fixed size array into a byte slice.
-pub trait ByteArray {
+pub trait ByteArray: Clone {
     fn len() -> usize;
     fn as_bytes_slice(&self) -> &[u8];
     fn as_mut_bytes_slice(&mut self) -> &mut [u8];
     fn rotate_right(&mut self, bytes: usize);
     fn new(value: u8) -> Self;
 }
 
-macro_rules! bytes_type {
-    ($T: ident, $N: expr) => {
-        #[derive(Copy, Clone, Debug, Default, PartialEq)]
-        pub struct $T;
+impl<const N: usize> ByteArray for [u8; N] {
+    #[inline]
+    fn len() -> usize {
+        N
+    }
 
-        impl NumberOfBytes for $T {
-            type AsBytes = [u8; $N];
+    #[inline]
+    fn as_bytes_slice(&self) -> &[u8] {
+        &self[..]
+    }
 
-            #[inline]
-            fn number_of_bytes() -> usize {
-                $N
-            }
-        }
+    #[inline]
+    fn as_mut_bytes_slice(&mut self) -> &mut [u8] {
+        &mut self[..]
+    }
 
-        impl ByteArray for [u8; $N] {
-            #[inline]
-            fn len() -> usize {
-                $N
-            }
+    #[inline]
+    fn rotate_right(&mut self, bytes: usize) {
+        bytes_rotate_right(self, bytes)
+    }
 
-            #[inline]
-            fn as_bytes_slice(&self) -> &[u8] {
-                &self[..]
-            }
+    fn new(value: u8) -> Self {
+        [value; N]
+    }
+}
 
-            #[inline]
-            fn as_mut_bytes_slice(&mut self) -> &mut [u8] {
-                &mut self[..]
-            }
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+pub struct Bytes<const N: usize>;
 
-            #[inline]
-            fn rotate_right(&mut self, bytes: usize) {
-                bytes_rotate_right(self, bytes)
-            }
+impl<const N: usize> NumberOfBytes for Bytes<N> {
+    type AsBytes = [u8; N];
 
-            fn new(value: u8) -> Self {
-                [value; $N]
-            }
-        }
+    #[inline]
+    fn number_of_bytes() -> usize {
+        N
     }
 }
 
-macro_rules! bits_type {
-    ($T: ident, $N: expr, $TB: ident, $TBK: ident) => {
-        #[derive(Copy, Clone, Debug, Default, PartialEq)]
-        pub struct $T;
+#[derive(Default, Debug, Copy, Clone, PartialEq)]
+pub struct Bits<const N: usize>;
 
+macro_rules! bits_type {
+    ($T: ty, $N: expr, $TB: ty, $TBK: ident) => {
         impl NumberOfBits for $T {
             type Bytes = $TB;