Merge branch 'main' into impl-alloc-interop

Author: newAM

.github/workflows/build.yml

@@ -165,7 +165,7 @@ jobs:
         run: |
           cargo check --target=${{ matrix.target }}
           cargo check --target=${{ matrix.target }} --features="portable-atomic-critical-section"
-          cargo check --target=${{ matrix.target }} --features="ufmt serde defmt-03 mpmc_large alloc"
+          cargo check --target=${{ matrix.target }} --features="ufmt serde defmt mpmc_large alloc"
 
   doc:
     name: doc
@@ -208,7 +208,7 @@ jobs:
 
       - name: cargo rustdoc
         env: {"RUSTDOCFLAGS": "-D warnings --cfg docsrs"}
-        run: cargo rustdoc --target=${{ matrix.target }} --features="ufmt serde defmt-03 mpmc_large portable-atomic-critical-section alloc"
+        run: cargo rustdoc --target=${{ matrix.target }} --features="ufmt serde defmt mpmc_large portable-atomic-critical-section alloc"
 
   # Run cpass tests
   testcpass:

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
+- Added `bytes::Buf` and `bytes::BufMut` implementations for `Vec`.
 - Added `format` macro.
 - Added `String::from_utf16`.
 - Added `is_full`, `recent_index`, `oldest`, and `oldest_index` to `HistoryBuffer`
@@ -44,10 +45,27 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `alloc` feature to enable `alloc`-Vec interoperability.
 - Added `TryFrom<alloc::vec::Vec>` impl for `Vec`.
 - Added `TryFrom<Vec>` impl for `alloc::vec::Vec`.
+- Added `truncate` to `IndexMap`.
+- Added `get_index` and `get_index_mut` to `IndexMap`.
+- Added `String::uDisplay`.
 
 ### Changed
 
+- Updated defmt from 0.3 to 1.0.1
+  - Changed the feature name from `defmt-03` to `defmt`.
+- Changed the error type of these methods from `()` to `CapacityError`.
+  - `String::push_str`
+  - `String::push`
+  - `Vec::extend_from_slice`
+  - `Vec::from_slice`
+  - `Vec::resize_default`
+  - `Vec::resize`
+- Renamed `FromUtf16Error::DecodeUtf16Error` to `FromUtf16Error::DecodeUtf16`.
 - Changed `stable_deref_trait` to a platform-dependent dependency.
+- Changed `SortedLinkedList::pop` return type from `Result<T, ()>` to `Option<T>` to match `std::vec::pop`.
+- `Vec::capacity` is no longer a `const` function.
+- Relaxed bounds on `PartialEq` for `IndexMap` from `V: Eq` to `V1: PartialEq<V2>`.
+- Relaxed bounds on `PartialEq` for `LinearMap` from `V: PartialEq` to `V1: PartialEq<V2>`.
 
 ### Fixed
 
@@ -58,6 +76,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Fixed `MpMcQueue` with `mpmc_large` feature.
 - Fix missing `Drop` for `MpMcQueue`
 
+### Removed
+
+- `Vec::storage_capacity` has been removed and `Vec::capacity` must be used instead.
+
 ## [v0.8.0] - 2023-11-07
 
 ### Added
@@ -93,6 +115,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
   - `ufmt-impl` is now `ufmt`
   - `cas` is removed, atomic polyfilling is now opt-in via the `portable-atomic` feature.
 - `Vec::as_mut_slice` is now a public method.
+- `ufmt` functions are annotated with `inline`.
 
 ### Fixed
 

Cargo.toml

@@ -15,6 +15,8 @@ repository = "https://github.com/rust-embedded/heapless"
 version = "0.8.0"
 
 [features]
+bytes = ["dep:bytes"]
+
 # Enable polyfilling of atomics via `portable-atomic`.
 # `portable-atomic` polyfills some functionality by default, but to get full atomics you must
 # enable one of its features to tell it how to do it. See `portable-atomic` documentation for details.
@@ -31,10 +33,10 @@ portable-atomic-unsafe-assume-single-core = ["dep:portable-atomic", "portable-at
 serde = ["dep:serde"]
 
 # implement ufmt traits.
-ufmt = ["dep:ufmt-write"]
+ufmt = ["dep:ufmt", "dep:ufmt-write"]
 
-# Implement defmt::Format from defmt v0.3
-defmt-03 = ["dep:defmt"]
+# Implement `defmt::Format`.
+defmt = ["dep:defmt"]
 
 # Enable larger MPMC sizes.
 mpmc_large = []
@@ -45,22 +47,31 @@ alloc = []
 nightly = []
 
 [dependencies]
+bytes = { version = "1", default-features = false, optional = true }
 portable-atomic = { version = "1.0", optional = true }
 hash32 = "0.3.0"
 serde = { version = "1", optional = true, default-features = false }
+ufmt = { version = "0.2", optional = true }
 ufmt-write = { version = "0.1", optional = true }
-defmt = { version = ">=0.2.0,<0.4", optional = true }
+defmt = { version = "1.0.1", optional = true }
 
 # for the pool module
 [target.'cfg(any(target_arch = "arm", target_pointer_width = "32", target_pointer_width = "64"))'.dependencies]
 stable_deref_trait = { version = "1", default-features = false }
 
 [dev-dependencies]
-ufmt = "0.2"
 static_assertions = "1.1.0"
 
 [package.metadata.docs.rs]
-features = ["ufmt", "serde", "defmt-03", "mpmc_large", "portable-atomic-critical-section", "alloc"]
+features = [
+  "bytes",
+  "ufmt",
+  "serde",
+  "defmt",
+  "mpmc_large",
+  "portable-atomic-critical-section",
+  "alloc",
+]
 # for the pool module
 targets = ["i686-unknown-linux-gnu"]
 rustdoc-args = ["--cfg", "docsrs"]

src/binary_heap.rs

@@ -159,7 +159,7 @@ pub type BinaryHeapView<T, K> = BinaryHeapInner<T, K, ViewVecStorage<T>>;
 
 impl<T, K, const N: usize> BinaryHeap<T, K, N> {
     /* Constructors */
-    /// Creates an empty BinaryHeap as a $K-heap.
+    /// Creates an empty `BinaryHeap` as a $K-heap.
     ///
     /// ```
     /// use heapless::binary_heap::{BinaryHeap, Max};
@@ -184,14 +184,16 @@ impl<T, K, const N: usize> BinaryHeap<T, K, N> {
     pub fn into_vec(self) -> Vec<T, N> {
         self.data
     }
+}
 
+impl<T, K, S: VecStorage<T>> BinaryHeapInner<T, K, S> {
     /// Get a reference to the `BinaryHeap`, erasing the `N` const-generic.
     pub fn as_view(&self) -> &BinaryHeapView<T, K> {
-        self
+        S::as_binary_heap_view(self)
     }
     /// Get a mutable reference to the `BinaryHeap`, erasing the `N` const-generic.
     pub fn as_mut_view(&mut self) -> &mut BinaryHeapView<T, K> {
-        self
+        S::as_binary_heap_mut_view(self)
     }
 }
 
@@ -203,7 +205,7 @@ where
     /* Public API */
     /// Returns the capacity of the binary heap.
     pub fn capacity(&self) -> usize {
-        self.data.storage_capacity()
+        self.data.capacity()
     }
 
     /// Drops all items from the binary heap.
@@ -222,7 +224,7 @@ where
     /// assert!(heap.is_empty());
     /// ```
     pub fn clear(&mut self) {
-        self.data.clear()
+        self.data.clear();
     }
 
     /// Returns the length of the binary heap.
@@ -386,7 +388,24 @@ where
 
     /// Removes the *top* (greatest if max-heap, smallest if min-heap) item from the binary heap and
     /// returns it, without checking if the binary heap is empty.
-    #[allow(clippy::missing_safety_doc)] // TODO
+    ///
+    /// # Safety
+    ///
+    /// The binary heap must not be empty.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use heapless::binary_heap::{BinaryHeap, Max};
+    ///
+    /// let mut heap: BinaryHeap<_, Max, 8> = BinaryHeap::new();
+    /// heap.push(42)?;
+    ///
+    /// // SAFETY: We just pushed a number onto the heap, so it cannot be empty.
+    /// let val = unsafe { heap.pop_unchecked() };
+    /// assert_eq!(val, 42);
+    /// # Ok::<(), u8>(())
+    /// ```
     pub unsafe fn pop_unchecked(&mut self) -> T {
         let mut item = self.data.pop_unchecked();
 
@@ -420,7 +439,23 @@ where
     }
 
     /// Pushes an item onto the binary heap without first checking if it's full.
-    #[allow(clippy::missing_safety_doc)] // TODO
+    ///
+    /// # Safety
+    ///
+    /// The binary heap must not be full.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use heapless::binary_heap::{BinaryHeap, Max};
+    ///
+    /// let mut heap: BinaryHeap<_, Max, 8> = BinaryHeap::new();
+    ///
+    /// // SAFETY: We just created an empty heap of size 8, so it cannot be full.
+    /// unsafe { heap.push_unchecked(42) };
+    /// assert_eq!(heap.len(), 1);
+    /// assert_eq!(heap.peek(), Some(&42));
+    /// ```
     pub unsafe fn push_unchecked(&mut self, item: T) {
         let old_len = self.len();
         self.data.push_unchecked(item);
@@ -596,14 +631,14 @@ where
     }
 }
 
-impl<'a, T, K, S> PeekMutInner<'a, T, K, S>
+impl<T, K, S> PeekMutInner<'_, T, K, S>
 where
     T: Ord,
     K: Kind,
     S: VecStorage<T> + ?Sized,
 {
     /// Removes the peeked value from the heap and returns it.
-    pub fn pop(mut this: PeekMutInner<'a, T, K, S>) -> T {
+    pub fn pop(mut this: Self) -> T {
         let value = this.heap.pop().unwrap();
         this.sift = false;
         value

src/bytes.rs

@@ -0,0 +1,107 @@
+//! Bytes implementations for heapless types
+
+use crate::Vec;
+use bytes::{buf::UninitSlice, Buf, BufMut};
+
+unsafe impl<const N: usize> Buf for Vec<u8, N> {
+    #[inline]
+    fn remaining(&self) -> usize {
+        self.len()
+    }
+
+    #[inline]
+    fn chunk(&mut self) -> &[u8] {
+        self.as_slice()
+    }
+
+    #[inline]
+    unsafe fn advance(&mut self, cnt: usize) {
+        assert!(
+            cnt <= self.remaining(),
+            "cannot advance past `remaining`: {:?} <= {:?}",
+            cnt,
+            self.remaining(),
+        );
+        unsafe {
+            // SAFETY: We've checked that `cnt` <= `self.remaining()` and we know that
+            // `self.remaining()` <= `self.cap`.
+            self.advance_unchecked(cnt);
+        }
+    }
+}
+
+unsafe impl<const N: usize> BufMut for Vec<u8, N> {
+    #[inline]
+    fn remaining_mut(&self) -> usize {
+        N - self.len()
+    }
+
+    #[inline]
+    unsafe fn advance_mut(&mut self, cnt: usize) {
+        let len = self.len();
+        let pos = len + cnt;
+        if pos >= N {
+            panic!("Advance out of range");
+        }
+        self.set_len(pos);
+    }
+
+    #[inline]
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
+        let len = self.len();
+        let ptr = self.as_mut_ptr();
+        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, N)[len..] }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::Vec;
+    use bytes::BufMut;
+
+    #[test]
+    #[should_panic]
+    fn buf_advance_out_of_bounds() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        vec.advance(9)
+    }
+
+    #[test]
+    fn buf_remaining() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        assert_eq!(vec.remaining(), 8);
+        vec.push(42).unwrap();
+        assert_eq!(vec.remaining(), 7);
+    }
+
+    #[test]
+    fn buf_chunk() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        assert_eq!(vec.chunk().len(), 8);
+        unsafe { vec.advance_mut(1) };
+        assert_eq!(vec.chunk().len(), 7);
+    }
+
+    #[test]
+    #[should_panic]
+    fn buf_mut_advance_mut_out_of_bounds() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        unsafe { vec.advance_mut(9) };
+    }
+
+    #[test]
+    fn buf_mut_remaining_mut() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        assert_eq!(vec.remaining_mut(), 8);
+        vec.push(42).unwrap();
+        assert_eq!(vec.remaining_mut(), 7);
+    }
+
+    #[test]
+    fn buf_mut_chunk_mut() {
+        let mut vec: Vec<u8, 8> = Vec::new();
+        assert_eq!(vec.chunk_mut().len(), 8);
+        unsafe { vec.advance_mut(1) };
+        assert_eq!(vec.chunk_mut().len(), 7);
+    }
+}

src/defmt.rs

@@ -1,7 +1,7 @@
 //! Defmt implementations for heapless types
 
 use crate::{
-    string::StringInner,
+    string::{StringInner, StringStorage},
     vec::{VecInner, VecStorage},
 };
 use defmt::Formatter;
@@ -15,7 +15,7 @@ where
     }
 }
 
-impl<S: VecStorage<u8> + ?Sized> defmt::Format for StringInner<S>
+impl<S: StringStorage + ?Sized> defmt::Format for StringInner<S>
 where
     u8: defmt::Format,
 {