added no panic check, refactored so there is no panic in push_str and push_str_truncate

Author: Wicpar

Cargo.toml

@@ -27,11 +27,11 @@ criterion = { version = "0.4", features = ["html_reports"] }
 env_logger = "0.10"
 serde = { version = "1.0", features = ["derive"] }
 diesel = { version = "2", features = ["sqlite", "postgres", "mysql"] }
-
 [dependencies]
 log = { version = "0.4", optional = true }
 serde = { version = "1", optional = true }
 diesel = { version = "2", optional = true }
+no-panic = "0.1"
 
 [features]
 default = ["std"]
@@ -43,3 +43,6 @@ diesel-traits = ["diesel"]
 [package.metadata.docs.rs]
 rustdoc-args = ["--cfg", "docs_rs_workaraound"]
 features = ["logs", "serde-traits", "std", "diesel-traits"]
+
+[profile.dev]
+opt-level = 3

src/arraystring.rs

@@ -9,7 +9,8 @@ use core::str::from_utf8;
 use core::{cmp::min, ops::*};
 #[cfg(feature = "logs")]
 use log::{debug, trace};
-use std::usize;
+use no_panic::no_panic;
+use std::{ptr, usize};
 
 /// String based on a generic array (size defined at compile time through `const generics`)
 ///
@@ -470,15 +471,21 @@ where
     /// # }
     /// ```
     #[inline]
+    #[cfg_attr(not(debug_assertions), no_panic)]
     pub fn try_push_str(&mut self, string: impl AsRef<str>) -> Result<(), OutOfBounds> {
         trace!("Push str: {}", string.as_ref());
         let str = string.as_ref().as_bytes();
         if str.len() == 0 {
             return Ok(());
         }
         is_inside_boundary(str.len() + self.len(), Self::capacity())?;
-        let this_len = self.len();
-        self.array[this_len..this_len + str.len()].copy_from_slice(str);
+        unsafe {
+            ptr::copy_nonoverlapping(
+                str.as_ptr(),
+                self.array.as_mut_ptr().add(self.len()),
+                str.len(),
+            );
+        }
         self.size += str.len() as u8;
         return Ok(());
     }
@@ -502,17 +509,22 @@ where
     /// # }
     /// ```
     #[inline]
+    #[cfg_attr(not(debug_assertions), no_panic)]
     pub fn push_str_truncate(&mut self, string: impl AsRef<str>) {
         trace!("Push str truncate: {}", string.as_ref());
+        let str = string.as_ref().as_bytes();
         let size = Self::capacity() - self.len();
-        if size == 0 {
+        if size == 0 || str.len() == 0 {
             return;
         }
-        let str = truncate_str(string.as_ref().as_bytes(), size.into());
-        if str.len() == 0 {
-            return;
+        let str = truncate_str(str, size);
+        unsafe {
+            ptr::copy_nonoverlapping(
+                str.as_ptr(),
+                self.array.as_mut_ptr().add(self.len()),
+                str.len(),
+            );
         }
-        self.array[self.size as usize..self.size as usize + str.len()].copy_from_slice(str);
         self.size += str.len() as u8;
     }
 
@@ -983,15 +995,6 @@ where
             Bound::Excluded(t) => *t,
             Bound::Unbounded => self.len(),
         };
-        is_inside_boundary(start, end)?;
-        is_inside_boundary(end, self.len())?;
-        is_char_boundary(self, start)?;
-        is_char_boundary(self, end)?;
-        let r_len = end - start;
-        is_inside_boundary(start + str.len() + self.len() - end, Self::capacity())?;
-        if start == end && with.as_ref().len() == 0 {
-            return Ok(());
-        }
         debug!(
             "Replace range (len: {}) ({}..{}) with (len: {}) {}",
             self.len(),
@@ -1000,13 +1003,21 @@ where
             with.as_ref().len(),
             with.as_ref()
         );
+        if start == end && str.len() == 0 {
+            return Ok(());
+        }
+        is_inside_boundary(start, end)?;
+        is_inside_boundary(end, self.len())?;
+        is_char_boundary(self, start)?;
+        is_char_boundary(self, end)?;
+        is_inside_boundary(start + str.len() + self.len() - end, Self::capacity())?;
         let dest = start + str.len();
         let this_len = self.len();
         self.array.copy_within(end..this_len, dest);
         if str.len() > 0 {
             self.array[start..start + str.len()].copy_from_slice(str);
         }
-        self.size -= r_len as u8;
+        self.size -= (end - start) as u8;
         self.size += str.len() as u8;
         Ok(())
     }

src/utils.rs

@@ -3,21 +3,18 @@
 use crate::{arraystring::sealed::ValidCapacity, prelude::*};
 #[cfg(feature = "logs")]
 use log::{debug, trace};
+use no_panic::no_panic;
 
 pub(crate) trait IntoLossy<T>: Sized {
     fn into_lossy(self) -> T;
 }
 
 /// Returns error if size is outside of specified boundary
+#[cfg_attr(not(debug_assertions), no_panic)]
 #[inline]
-pub fn is_inside_boundary<S, L>(size: S, limit: L) -> Result<(), OutOfBounds>
-where
-    S: Into<usize>,
-    L: Into<usize>,
-{
-    let (s, l) = (size.into(), limit.into());
-    trace!("Out of bounds: ensures {} < {}", s, l);
-    Some(()).filter(|_| s <= l).ok_or(OutOfBounds)
+pub fn is_inside_boundary(size: usize, limit: usize) -> Result<(), OutOfBounds> {
+    trace!("Out of bounds: ensures {} <= {}", size, limit);
+    (size <= limit).then_some(()).ok_or(OutOfBounds)
 }
 
 /// Returns error if index is not at a valid utf-8 char boundary
@@ -47,6 +44,7 @@ pub unsafe fn is_char_boundary_at(arr: &[u8], index: usize) -> bool {
 
 /// Truncates string to specified size (ignoring last bytes if they form a partial `char`)
 #[inline]
+#[cfg_attr(not(debug_assertions), no_panic)]
 pub(crate) fn truncate_str(slice: &[u8], mut size: usize) -> &[u8] {
     trace!(
         "Truncate str: {} at {}",