+borsh = { version = "1.4.0", optional = true, default-features = false }

+std = ["serde?/std", "borsh?/std"]

+use crate::{Repr, SmolStr, INLINE_CAP};

+use alloc::string::{String, ToString};

+use borsh::io::{Error, ErrorKind, Read, Write};

+use borsh::{BorshDeserialize, BorshSerialize};

+use core::intrinsics::transmute;

+

+impl BorshSerialize for SmolStr {

+ fn serialize<W: Write>(&self, writer: &mut W) -> borsh::io::Result<()> {

+ self.as_str().serialize(writer)

+ }

+}

+

+impl BorshDeserialize for SmolStr {

+ #[inline]

+ fn deserialize_reader<R: Read>(reader: &mut R) -> borsh::io::Result<Self> {

+ let len = u32::deserialize_reader(reader)?;

+ if (len as usize) < INLINE_CAP {

+ let mut buf = [0u8; INLINE_CAP];

+ reader.read_exact(&mut buf[..len as usize])?;

+ _ = core::str::from_utf8(&buf[..len as usize]).map_err(|err| {

+ let msg = err.to_string();

+ Error::new(ErrorKind::InvalidData, msg)

+ })?;

+ Ok(SmolStr(Repr::Inline {

+ len: unsafe { transmute(len as u8) },

+ buf,

+ }))

+ } else {

+ // u8::vec_from_reader always returns Some on success in current implementation

+ let vec = u8::vec_from_reader(len, reader)?.ok_or_else(|| {

+ Error::new(

+ ErrorKind::Other,

+ "u8::vec_from_reader unexpectedly returned None".to_string(),

+ )

+ })?;

+ Ok(SmolStr::from(String::from_utf8(vec).map_err(|err| {

+ let msg = err.to_string();

+ Error::new(ErrorKind::InvalidData, msg)

+ })?))

+ }

+ }

+}

+

+#[cfg(feature = "borsh/unstable__schema")]

+mod schema {

+ use alloc::collections::BTreeMap;

+ use borsh::schema::{Declaration, Definition};

+ use borsh::BorshSchema;

+ impl BorshSchema for SmolStr {

+ fn add_definitions_recursively(definitions: &mut BTreeMap<Declaration, Definition>) {

+ str::add_definitions_recursively(definitions)

+ }

+

+ fn declaration() -> Declaration {

+ str::declaration()

+ }

+ }

+}

+#[cfg(feature = "borsh")]

+mod borsh;

+#[cfg(feature = "borsh")]

+

+mod borsh_tests {

+ use borsh::BorshDeserialize;

+ use smol_str::{SmolStr, ToSmolStr};

+ use std::io::Cursor;

+

+ #[test]

+ fn borsh_serialize_stack() {

+ let smolstr_on_stack = "aßΔCaßδc".to_smolstr();

+ let mut buffer = Vec::new();

+ borsh::BorshSerialize::serialize(&smolstr_on_stack, &mut buffer).unwrap();

+ let mut cursor = Cursor::new(buffer);

+ let decoded: SmolStr = borsh::BorshDeserialize::deserialize_reader(&mut cursor).unwrap();

+ assert_eq!(smolstr_on_stack, decoded);

+ }

+ #[test]

+ fn borsh_serialize_heap() {

+ let smolstr_on_heap = "aßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδcaßΔCaßδc".to_smolstr();

+ let mut buffer = Vec::new();

+ borsh::BorshSerialize::serialize(&smolstr_on_heap, &mut buffer).unwrap();

+ let mut cursor = Cursor::new(buffer);

+ let decoded: SmolStr = borsh::BorshDeserialize::deserialize_reader(&mut cursor).unwrap();

+ assert_eq!(smolstr_on_heap, decoded);

+ }

+ #[test]

+ fn borsh_non_utf8_stack() {

+ let invalid_utf8: Vec<u8> = vec![0xF0, 0x9F, 0x8F]; // Incomplete UTF-8 sequence

+

+ let wrong_utf8 = SmolStr::from(unsafe { String::from_utf8_unchecked(invalid_utf8) });

+ let mut buffer = Vec::new();

+ borsh::BorshSerialize::serialize(&wrong_utf8, &mut buffer).unwrap();

+ let mut cursor = Cursor::new(buffer);

+ let result = SmolStr::deserialize_reader(&mut cursor);

+ assert!(result.is_err());

+ }

+

+ #[test]

+ fn borsh_non_utf8_heap() {

+ let invalid_utf8: Vec<u8> = vec![

+ 0xC1, 0x8A, 0x5F, 0xE2, 0x3A, 0x9E, 0x3B, 0xAA, 0x01, 0x08, 0x6F, 0x2F, 0xC0, 0x32,

+ 0xAB, 0xE1, 0x9A, 0x2F, 0x4A, 0x3F, 0x25, 0x0D, 0x8A, 0x2A, 0x19, 0x11, 0xF0, 0x7F,

+ 0x0E, 0x80,

+ ];

+ let wrong_utf8 = SmolStr::from(unsafe { String::from_utf8_unchecked(invalid_utf8) });

+ let mut buffer = Vec::new();

+ borsh::BorshSerialize::serialize(&wrong_utf8, &mut buffer).unwrap();

+ let mut cursor = Cursor::new(buffer);

+ let result = SmolStr::deserialize_reader(&mut cursor);

+ assert!(result.is_err());

+ }

+}