Add optional support for compact_str crate

Author: mcronce

Cargo.lock

@@ -18,6 +18,7 @@ exclude = ["fuzz/"]
 arrayvec = { version = "0.7", default-features = false, optional = true }
 bitcode_derive = { version = "=0.6.9", path = "./bitcode_derive", optional = true }
 bytemuck = { version = "1.14", features = [ "min_const_generics", "must_cast" ] }
+compact_str = { version = "0.9.0", optional = true }
 glam = { version = ">=0.21", default-features = false, optional = true }
 rust_decimal = { version = "1.36", default-features = false, optional = true }
 serde = { version = "1.0", default-features = false, features = [ "alloc" ], optional = true }

Cargo.toml

@@ -0,0 +1,63 @@
+use crate::coder::{Decoder, Encoder};
+use crate::derive::{Decode, Encode};
+use crate::str::{StrDecoder, StrEncoder};
+use compact_str::CompactString;
+
+impl Encoder<CompactString> for StrEncoder {
+    #[inline(always)]
+    fn encode(&mut self, t: &CompactString) {
+        self.encode(t.as_str())
+    }
+}
+
+impl Encode for CompactString {
+    type Encoder = StrEncoder;
+}
+
+// TODO:  Can we optimize out copying from the reference?  Just construct a CompactString from pointer/capacity/length if it exceeds the inline capacity?
+impl<'a> Decoder<'a, CompactString> for StrDecoder<'a> {
+    #[inline(always)]
+    fn decode(&mut self) -> CompactString {
+        let s: &str = self.decode();
+        s.into()
+    }
+}
+
+impl<'a> Decode<'a> for CompactString {
+    type Decoder = StrDecoder<'a>;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{decode, encode};
+    use alloc::vec::Vec;
+    use compact_str::CompactString;
+
+    #[test]
+    fn compact_string() {
+        let mut v = CompactString::default();
+        v.push('0');
+        v.push('1');
+        let b = encode(&v);
+        assert_eq!(decode::<CompactString>(&b).unwrap(), v);
+    }
+
+    #[test]
+    fn compact_string_long() {
+        // CompactString inlines up to 23 bytes on 64-bit platforms; the English alphabet exceeds that at 26 bytes.
+        let v = CompactString::new("abcdefghijklmnopqrstuvwxyz");
+        let b = encode(&v);
+        assert_eq!(decode::<CompactString>(&b).unwrap(), v);
+    }
+
+    #[test]
+    fn compact_string_vec() {
+        let v = vec![
+            CompactString::new("01"),
+            CompactString::new("abcdefghijklmnopqrstuvwxyz"),
+        ];
+        let b = encode(&v);
+        let v2 = decode::<Vec<CompactString>>(&b).unwrap();
+        assert_eq!(v, v2);
+    }
+}

src/ext/compact_str.rs

@@ -1,5 +1,7 @@
 #[cfg(feature = "arrayvec")]
 mod arrayvec;
+#[cfg(feature = "compact_str")]
+mod compact_str;
 #[cfg(feature = "glam")]
 #[rustfmt::skip] // Makes impl_struct! calls way longer.
 mod glam;