Add generic LenType to String

Author: GnomedDev

CHANGELOG.md

@@ -49,6 +49,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Added `get_index` and `get_index_mut` to `IndexMap`.
 - Added `String::uDisplay`.
 - Added `LenT` generic to `Vec<T, N>` and `VecView<T>` to save memory when using a sane capacity value.
+- Added similar `LenT` generic to `String`.
 
 ### Changed
 

src/de.rs

@@ -299,15 +299,15 @@ where
 
 // String containers
 
-impl<'de, const N: usize> Deserialize<'de> for String<N> {
+impl<'de, LenT: LenType, const N: usize> Deserialize<'de> for String<N, LenT> {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
-        struct ValueVisitor<'de, const N: usize>(PhantomData<&'de ()>);
+        struct ValueVisitor<'de, LenT: LenType, const N: usize>(PhantomData<(&'de (), LenT)>);
 
-        impl<'de, const N: usize> de::Visitor<'de> for ValueVisitor<'de, N> {
-            type Value = String<N>;
+        impl<'de, LenT: LenType, const N: usize> de::Visitor<'de> for ValueVisitor<'de, LenT, N> {
+            type Value = String<N, LenT>;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                 write!(formatter, "a string no more than {} bytes long", N as u64)
@@ -339,6 +339,6 @@ impl<'de, const N: usize> Deserialize<'de> for String<N> {
             }
         }
 
-        deserializer.deserialize_str(ValueVisitor::<'de, N>(PhantomData))
+        deserializer.deserialize_str(ValueVisitor(PhantomData))
     }
 }

src/defmt.rs

@@ -12,14 +12,11 @@ where
     T: defmt::Format,
 {
     fn format(&self, fmt: Formatter<'_>) {
-        defmt::write!(fmt, "{=[?]}", self.as_slice())
+        defmt::write!(fmt, "{=[?]}", self.as_slice());
     }
 }
 
-impl<S: StringStorage + ?Sized> defmt::Format for StringInner<S>
-where
-    u8: defmt::Format,
-{
+impl<LenT: LenType, S: StringStorage + ?Sized> defmt::Format for StringInner<LenT, S> {
     fn format(&self, fmt: Formatter<'_>) {
         defmt::write!(fmt, "{=str}", self.as_str());
     }

src/lib.rs

@@ -243,6 +243,7 @@ mod ufmt;
 /// Do not use. Used for macros only. Not covered by semver guarantees.
 #[doc(hidden)]
 pub mod _export {
+    pub use crate::len_type::DefaultLenType;
     pub use crate::string::format;
 }
 

src/ser.rs

@@ -136,11 +136,11 @@ where
 
 // String containers
 
-impl<S: StringStorage + ?Sized> Serialize for StringInner<S> {
+impl<LenT: LenType, S: StringStorage + ?Sized> Serialize for StringInner<LenT, S> {
     fn serialize<SER>(&self, serializer: SER) -> Result<SER::Ok, SER::Error>
     where
         SER: Serializer,
     {
-        serializer.serialize_str(&*self)
+        serializer.serialize_str(self)
     }
 }

src/string/drain.rs

@@ -1,5 +1,7 @@
 use core::{fmt, iter::FusedIterator, str::Chars};
 
+use crate::LenType;
+
 use super::StringView;
 
 /// A draining iterator for `String`.
@@ -8,40 +10,40 @@ use super::StringView;
 /// documentation for more.
 ///
 /// [`drain`]: crate::String::drain
-pub struct Drain<'a> {
+pub struct Drain<'a, LenT: LenType> {
     /// Will be used as &'a mut String in the destructor
-    pub(super) string: *mut StringView,
+    pub(super) string: *mut StringView<LenT>,
     /// Stast of part to remove
-    pub(super) start: usize,
+    pub(super) start: LenT,
     /// End of part to remove
-    pub(super) end: usize,
+    pub(super) end: LenT,
     /// Current remaining range to remove
     pub(super) iter: Chars<'a>,
 }
 
-impl fmt::Debug for Drain<'_> {
+impl<LenT: LenType> fmt::Debug for Drain<'_, LenT> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Drain").field(&self.as_str()).finish()
     }
 }
 
-unsafe impl Sync for Drain<'_> {}
-unsafe impl Send for Drain<'_> {}
+unsafe impl<LenT: LenType> Sync for Drain<'_, LenT> {}
+unsafe impl<LenT: LenType> Send for Drain<'_, LenT> {}
 
-impl Drop for Drain<'_> {
+impl<LenT: LenType> Drop for Drain<'_, LenT> {
     fn drop(&mut self) {
         unsafe {
             // Use `Vec::drain`. “Reaffirm” the bounds checks to avoid
             // panic code being inserted again.
             let self_vec = (*self.string).as_mut_vec();
-            if self.start <= self.end && self.end <= self_vec.len() {
-                self_vec.drain(self.start..self.end);
+            if self.start <= self.end && self.end <= self_vec.length() {
+                self_vec.drain(self.start.into_usize()..self.end.into_usize());
             }
         }
     }
 }
 
-impl Drain<'_> {
+impl<LenT: LenType> Drain<'_, LenT> {
     /// Returns the remaining (sub)string of this iterator as a slice.
     ///
     /// # Examples
@@ -61,19 +63,19 @@ impl Drain<'_> {
     }
 }
 
-impl AsRef<str> for Drain<'_> {
+impl<LenT: LenType> AsRef<str> for Drain<'_, LenT> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-impl AsRef<[u8]> for Drain<'_> {
+impl<LenT: LenType> AsRef<[u8]> for Drain<'_, LenT> {
     fn as_ref(&self) -> &[u8] {
         self.as_str().as_bytes()
     }
 }
 
-impl Iterator for Drain<'_> {
+impl<LenT: LenType> Iterator for Drain<'_, LenT> {
     type Item = char;
 
     #[inline]
@@ -91,14 +93,14 @@ impl Iterator for Drain<'_> {
     }
 }
 
-impl DoubleEndedIterator for Drain<'_> {
+impl<LenT: LenType> DoubleEndedIterator for Drain<'_, LenT> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
         self.iter.next_back()
     }
 }
 
-impl FusedIterator for Drain<'_> {}
+impl<LenT: LenType> FusedIterator for Drain<'_, LenT> {}
 
 #[cfg(test)]
 mod tests {