Implement TryFrom<Box<str>> for FixedString

Author: GnomedDev

src/length.rs

@@ -42,6 +42,50 @@ impl<T> std::fmt::Display for InvalidLength<T> {
     }
 }
 
+#[derive(Debug)]
+pub struct InvalidStrLength {
+    pub(crate) backtrace: std::backtrace::Backtrace,
+    type_name: &'static str,
+    original: Box<str>,
+}
+
+impl InvalidStrLength {
+    /// Returns the original [`Box<str>`] that could not be converted from.
+    pub fn get_inner(self) -> Box<str> {
+        self.original
+    }
+}
+
+impl std::fmt::Display for InvalidStrLength {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Cannot fit {} into {}:\n\n{}",
+            self.original.len(),
+            self.type_name,
+            self.backtrace
+        )
+    }
+}
+
+impl TryFrom<InvalidLength<u8>> for InvalidStrLength {
+    type Error = std::str::Utf8Error;
+
+    fn try_from(value: InvalidLength<u8>) -> Result<Self, Self::Error> {
+        let original = if let Err(err) = std::str::from_utf8(&value.original) {
+            return Err(err);
+        } else {
+            unsafe { std::str::from_boxed_utf8_unchecked(value.original) }
+        };
+
+        Ok(Self {
+            original,
+            type_name: value.type_name,
+            backtrace: value.backtrace,
+        })
+    }
+}
+
 pub(crate) const fn get_heap_threshold<LenT>() -> usize {
     std::mem::size_of::<usize>() + std::mem::size_of::<LenT>() - 1
 }

src/string.rs

@@ -3,7 +3,7 @@ use std::{cmp::PartialEq, fmt::Write as _, hash::Hash};
 use crate::{
     array::FixedArray,
     inline::InlineString,
-    length::{get_heap_threshold, SmallLen, ValidLength},
+    length::{get_heap_threshold, InvalidStrLength, SmallLen, ValidLength},
 };
 
 #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
@@ -165,6 +165,24 @@ impl<LenT: ValidLength> std::fmt::Debug for FixedString<LenT> {
     }
 }
 
+impl<LenT: ValidLength> TryFrom<Box<str>> for FixedString<LenT> {
+    type Error = InvalidStrLength;
+
+    fn try_from(value: Box<str>) -> Result<Self, Self::Error> {
+        if value.len() <= get_heap_threshold::<LenT>() {
+            let inner = InlineString::from_str(&value);
+            return Ok(Self(FixedStringRepr::Inline(inner)));
+        }
+
+        match value.into_boxed_bytes().try_into() {
+            Ok(val) => Ok(Self(FixedStringRepr::Heap(val))),
+            Err(err) => Err(err
+                .try_into()
+                .expect("Box<str> -> Box<[u8]> should stay valid UTF8")),
+        }
+    }
+}
+
 #[cfg(any(feature = "log_using_log", feature = "log_using_tracing"))]
 impl<LenT: ValidLength> From<String> for FixedString<LenT> {
     fn from(value: String) -> Self {
@@ -228,15 +246,15 @@ impl<LenT: ValidLength> serde::Serialize for FixedString<LenT> {
     }
 }
 
-#[cfg(all(test, any(feature = "log_using_log", feature = "log_using_tracing")))]
+#[cfg(test)]
 mod test {
     use super::*;
 
     #[test]
     fn check_u8_roundtrip() {
         for i in 0..=u8::MAX {
-            let original = "a".repeat(i.into());
-            let fixed = FixedString::<u8>::from(original);
+            let original = "a".repeat(i.into()).into_boxed_str();
+            let fixed = FixedString::<u8>::try_from(original).unwrap();
 
             assert!(fixed.bytes().all(|c| c == b'a'));
             assert_eq!(fixed.len(), i.into());