Updating to heapless 0.7

- Breaking api change to use const generics
- Due to some limitations 2 extra parameters are needed
  (which can be removed in the future once const generic expressions are
  added)

Author: haata

Cargo.toml

@@ -97,7 +97,7 @@ flexi_logger    = "^0.17"
 futures         = { version = "^0.3", optional = true }
 futures-util    = { version = "^0.3", optional = true }
 glob            = { version = "^0.3", optional = true }
-heapless        = { version = "^0.6" }
+heapless        = { version = "^0.7" }
 hidapi          = { version = "1.2.4", default-features = false, features = ["linux-static-hidraw"], optional = true }
 hid-io-protocol = { path = "hid-io-protocol", version = "0.1.0" }
 libc            = { version = "^0.2", optional = true }

hid-io-protocol/Cargo.toml

@@ -36,7 +36,7 @@ server = ["log", "bincode_core/std"]
 [dependencies]
 arraydeque      = { version = "^0.4", default-features = false }
 bincode_core    = { git = "https://github.com/bincode-org/bincode-core.git", version = "0.1.0" }
-heapless        = { version = "^0.6" }
+heapless        = { version = "^0.7" }
 log             = { version = "^0.4", default-features = false, optional = true }
 num_enum        = { version = "^0.5", default-features = false }
 serde           = { version = "^1.0", default-features = false }

hid-io-protocol/README.md

@@ -56,20 +56,20 @@ In each way a CommandInterface struct is created and the Commands trait is imple
 Option 1 is simpler as hid-io-protocol can handle all processing from a hidraw interface. Device libraries usually go for this.
 
 ```rust
-type BufChunk = U64;
-type IdLen = U10;
-type MessageLen = U256;
-type RxBuf = U8;
-type SerializationLen = U276;
-type TxBuf = U8;
+const BufChunk: usize = U64;
+const IdLen: usize = U10;
+const MessageLen: usize = U256;
+const RxBuf: usize = U8;
+const SerializationLen: usize = U276;
+const TxBuf: usize = U8;
 
 let ids = [
     HidIoCommandID::SupportedIDs,
     /* Add supported ids */
     /* This is the master list, if it's not listed here comamnds will not work */
 ];
 
-let intf = CommandInterface::<TxBuf, RxBuf, BufChunk, MessageLen, SerializationLen, IdLen>::new(&ids).unwrap();
+let intf = CommandInterface::<TxBuf, RxBuf, BufChunk, MessageLen, {MessageLen - 1}, {MessageLen - 4}, SerializationLen, IdLen>::new(&ids).unwrap();
 }
 
 // The max length must equal BufChunk (e.g. 64 bytes)
@@ -101,16 +101,15 @@ match intf.tx_bytebuf.dequeue() {
 }
 
 struct CommandInterface<
-    TX: ArrayLength<Vec<u8, N>>,
-    RX: ArrayLength<Vec<u8, N>>,
-    N: ArrayLength<u8>,
-    H: ArrayLength<u8>,
-    S: ArrayLength<u8>,
-    ID: ArrayLength<HidIoCommandID> + ArrayLength<u8>,
-> where
-    H: core::fmt::Debug,
-    H: Sub<B1>,
-{
+    const TX: usize,
+    const RX: usize,
+    const N: usize,
+    const H: usize,
+    const HSUB1: usize,
+    const HSUB4: usize,
+    const S: usize,
+    const ID: usize,
+> {
     ids: Vec<HidIoCommandID, ID>,
     rx_bytebuf: buffer::Buffer<RX, N>,
     rx_packetbuf: HidIoPacketBuffer<H>,
@@ -119,20 +118,19 @@ struct CommandInterface<
 }
 
 impl<
-        TX: ArrayLength<Vec<u8, N>>,
-        RX: ArrayLength<Vec<u8, N>>,
-        N: ArrayLength<u8>,
-        H: ArrayLength<u8>,
-        S: ArrayLength<u8>,
-        ID: ArrayLength<HidIoCommandID> + ArrayLength<u8>,
-    > CommandInterface<TX, RX, N, H, S, ID>
-where
-    H: core::fmt::Debug,
-    H: Sub<B1>,
+        const TX: usize,
+        const RX: usize,
+        const N: usize,
+        const H: usize,
+        const HSUB1: usize,
+        const HSUB4: usize,
+        const S: usize,
+        const ID: usize,
+    > CommandInterface<TX, RX, N, H, HSUB1, HSUB4, S, ID>
 {
     fn new(
         ids: &[HidIoCommandID],
-    ) -> Result<CommandInterface<TX, RX, N, H, S, ID>, CommandError> {
+    ) -> Result<CommandInterface<TX, RX, N, H, HSUB1, HSUB4, S, ID>, CommandError> {
         // Make sure we have a large enough id vec
         let ids = match Vec::from_slice(ids) {
             Ok(ids) => ids,
@@ -191,10 +189,7 @@ where
     /// Process rx buffer until empty
     /// Handles flushing tx->rx, decoding, then processing buffers
     /// Returns the number of buffers processed
-    pub fn process_rx(&mut self) -> Result<u8, CommandError>
-    where
-        <H as Sub<B1>>::Output: ArrayLength<u8>,
-    {
+    pub fn process_rx(&mut self) -> Result<u8, CommandError> {
         // Decode bytes into buffer
         while (self.rx_packetbuffer_decode()? {
             // Process rx buffer
@@ -216,18 +211,17 @@ where
 /// S - Serialization buffer size
 /// ID - Max number of HidIoCommandIDs
 impl<
-        TX: ArrayLength<Vec<u8, N>>,
-        RX: ArrayLength<Vec<u8, N>>,
-        N: ArrayLength<u8>,
-        H: ArrayLength<u8>,
-        S: ArrayLength<u8>,
-        ID: ArrayLength<HidIoCommandID> + ArrayLength<u8>,
-    > Commands<H, ID> for CommandInterface<TX, RX, N, H, S, ID>
-where
-    H: core::fmt::Debug + Sub<B1>,
-{
+        const TX: usize,
+        const RX: usize,
+        const N: usize,
+        const H: usize,
+        const HSUB1: usize,
+        const HSUB4: usize,
+        const S: usize,
+        const ID: usize,
+    > Commands<H, ID> for CommandInterface<TX, RX, N, H, HSUB1, HSUB4, S, ID> {
     fn default_packet_chunk(&self) -> u32 {
-        <N as Unsigned>::to_u32()
+        N as u32
     }
 
     fn tx_packetbuffer_send(&mut self, buf: &mut HidIoPacketBuffer<H>) -> Result<(), CommandError> {
@@ -247,8 +241,8 @@ where
         // was serialized
         // The first byte is a serde type and is dropped
         let data = &self.serial_buf;
-        for pos in (1..data.len()).step_by(<N as Unsigned>::to_usize()) {
-            let len = core::cmp::min(<N as Unsigned>::to_usize(), data.len() - pos);
+        for pos in (1..data.len()).step_by(N) {
+            let len = core::cmp::min(N, data.len() - pos);
             match self
                 .tx_bytebuf
                 .enqueue(match Vec::from_slice(&data[pos..len + pos]) {
@@ -279,7 +273,7 @@ hid-io-core uses Option 2 as different threads handle byte ingest and message ha
 
 ```rust
         struct CommandInterface {}
-        impl Commands<mailbox::HidIoPacketBufferDataSize, U0> for CommandInterface {
+        impl Commands<mailbox::HidIoPacketBufferDataSize, 0> for CommandInterface {
             fn tx_packetbuffer_send(
                 &mut self,
                 buf: &mut mailbox::HidIoPacketBuffer,

hid-io-protocol/src/buffer.rs

@@ -21,7 +21,6 @@
 
 // ----- Crates -----
 
-use super::*;
 use heapless::spsc::Queue;
 use heapless::Vec;
 
@@ -47,23 +46,21 @@ use heapless::Vec;
 /// - 1024 bytes (USB 2.0 HS)
 ///
 /// The maximum queue size is 255
-pub struct Buffer<Q: ArrayLength<Vec<u8, N>>, N: ArrayLength<u8>> {
-    queue: Queue<Vec<u8, N>, Q, u8>,
+pub struct Buffer<const Q: usize, const N: usize> {
+    queue: Queue<Vec<u8, N>, Q>,
 }
 
 // ----- Implementations -----
 
-impl<Q, N> Default for Buffer<Q, N>
-where
-    Q: ArrayLength<Vec<u8, N>>,
-    N: ArrayLength<u8>,
-{
+impl<const Q: usize, const N: usize> Default for Buffer<Q, N> {
     fn default() -> Self {
-        Buffer { queue: Queue::u8() }
+        Buffer {
+            queue: Queue::new(),
+        }
     }
 }
 
-impl<Q: ArrayLength<Vec<u8, N>>, N: ArrayLength<u8>> Buffer<Q, N> {
+impl<const Q: usize, const N: usize> Buffer<Q, N> {
     /// Constructor for Buffer
     ///
     /// # Remarks
@@ -103,12 +100,12 @@ impl<Q: ArrayLength<Vec<u8, N>>, N: ArrayLength<u8>> Buffer<Q, N> {
     }
 
     /// Capacity of buffer
-    pub fn capacity(&self) -> u8 {
+    pub fn capacity(&self) -> usize {
         self.queue.capacity()
     }
 
     /// Number of elements stored in the buffer
-    pub fn len(&self) -> u8 {
+    pub fn len(&self) -> usize {
         self.queue.len()
     }