From 75dcfb25061d187b3769f856d08618e412224286 Mon Sep 17 00:00:00 2001 From: kmaasrud Date: Wed, 15 Mar 2023 09:44:02 +0100 Subject: [PATCH] feat: add custom CowStr type Related issue: #20 --- src/attr.rs | 5 ++- src/lib.rs | 10 +++++- src/string.rs | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+), 4 deletions(-) create mode 100644 src/string.rs diff --git a/src/attr.rs b/src/attr.rs index 9980f69b..9f46dc42 100644 --- a/src/attr.rs +++ b/src/attr.rs @@ -1,7 +1,6 @@ use crate::CowStr; use crate::DiscontinuousString; use crate::Span; -use std::borrow::Cow; use std::fmt; use State::*; @@ -117,8 +116,8 @@ impl<'s> Attributes<'s> { #[inline] fn borrow(cow: CowStr) -> &str { match cow { - Cow::Owned(_) => panic!(), - Cow::Borrowed(s) => s, + CowStr::Owned(_) | CowStr::Inlined(_, _) => panic!(), + CowStr::Borrowed(s) => s, } } diff --git a/src/lib.rs b/src/lib.rs index 100a9c19..d81c07e8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -58,14 +58,16 @@ mod block; mod inline; mod lex; mod span; +mod string; mod tree; use span::DiscontinuousString; use span::Span; pub use attr::{AttributeValue, AttributeValueParts, Attributes}; +pub use string::CowStr; -type CowStr<'s> = std::borrow::Cow<'s, str>; +// type CowStr<'s> = std::borrow::Cow<'s, str>; pub trait Render { /// Push [`Event`]s to a unicode-accepting buffer or stream. @@ -698,6 +700,7 @@ impl<'s> Parser<'s> { format: match self.inlines.src(inline.span) { CowStr::Owned(_) => panic!(), CowStr::Borrowed(s) => s, + CowStr::Inlined(..) => todo!(), }, }, inline::Container::Subscript => Container::Subscript, @@ -711,6 +714,7 @@ impl<'s> Parser<'s> { match self.inlines.src(inline.span) { CowStr::Owned(s) => s.replace('\n', "").into(), s @ CowStr::Borrowed(_) => s, + CowStr::Inlined(..) => todo!(), }, LinkType::Span(SpanLinkType::Inline), ), @@ -718,6 +722,7 @@ impl<'s> Parser<'s> { match self.inlines.src(inline.span) { CowStr::Owned(s) => s.replace('\n', "").into(), s @ CowStr::Borrowed(_) => s, + CowStr::Inlined(..) => todo!(), }, SpanLinkType::Inline, ), @@ -725,6 +730,7 @@ impl<'s> Parser<'s> { let tag = match self.inlines.src(inline.span) { CowStr::Owned(s) => s.replace('\n', " ").into(), s @ CowStr::Borrowed(_) => s, + CowStr::Inlined(..) => todo!(), }; let link_def = self.pre_pass.link_definitions.get(tag.as_ref()).cloned(); @@ -765,6 +771,7 @@ impl<'s> Parser<'s> { let tag = match self.inlines.src(inline.span) { CowStr::Borrowed(s) => s, CowStr::Owned(..) => panic!(), + CowStr::Inlined(..) => todo!(), }; let number = self .footnote_references @@ -781,6 +788,7 @@ impl<'s> Parser<'s> { match self.inlines.src(inline.span) { CowStr::Borrowed(s) => s, CowStr::Owned(..) => panic!(), + CowStr::Inlined(..) => todo!(), }, number, ) diff --git a/src/string.rs b/src/string.rs new file mode 100644 index 00000000..6920afdc --- /dev/null +++ b/src/string.rs @@ -0,0 +1,94 @@ +use std::{borrow::Borrow, fmt::Display, ops::Deref, str::from_utf8}; + +// Largest CowStr variant is Owned(String). A String uses 3 words of memory, but a fourth word is +// needed to hold the tag (the tag takes a byte, but a full word is used for alignment reasons.) +// This means that the available space we have for an inline string is 4 words - 1 byte for the tag +// and 1 word for encoding the length. +const MAX_INLINE_STR_LEN: usize = 4 * std::mem::size_of::() - 2; + +#[derive(Debug)] +pub enum CowStr<'s> { + Owned(String), + Borrowed(&'s str), + Inlined([u8; MAX_INLINE_STR_LEN], u8), +} + +impl<'s> Deref for CowStr<'s> { + type Target = str; + + fn deref(&self) -> &Self::Target { + match *self { + Self::Owned(ref s) => s.borrow(), + Self::Borrowed(s) => s, + // NOTE: Inlined strings can only be constructed from strings or chars, which means they + // are guaranteed to be valid UTF-8. We could consider unchecked conversion as well, but + // a benchmark should be done before introducing unsafes. + Self::Inlined(ref inner, len) => from_utf8(&inner[..len as usize]).unwrap(), + } + } +} + +impl<'s> AsRef for CowStr<'s> { + fn as_ref(&self) -> &str { + self.deref() + } +} + +impl<'s> From for CowStr<'s> { + fn from(value: char) -> Self { + let mut inner = [0u8; MAX_INLINE_STR_LEN]; + value.encode_utf8(&mut inner); + CowStr::Inlined(inner, value.len_utf8() as u8) + } +} + +impl<'s> From<&'s str> for CowStr<'s> { + fn from(value: &'s str) -> Self { + CowStr::Borrowed(value) + } +} + +impl<'s> From for CowStr<'s> { + fn from(value: String) -> Self { + CowStr::Owned(value) + } +} + +impl<'s> Clone for CowStr<'s> { + fn clone(&self) -> Self { + match self { + CowStr::Owned(s) => { + let len = s.len(); + if len > MAX_INLINE_STR_LEN { + CowStr::Owned(s.clone()) + } else { + let mut inner = [0u8; MAX_INLINE_STR_LEN]; + inner[..len].copy_from_slice(s.as_bytes()); + CowStr::Inlined(inner, len as u8) + } + } + CowStr::Borrowed(s) => CowStr::Borrowed(s), + CowStr::Inlined(inner, len) => CowStr::Inlined(*inner, *len), + } + } +} + +impl<'s> PartialEq for CowStr<'s> { + fn eq(&self, other: &Self) -> bool { + self.deref() == other.deref() + } +} + +impl<'s> Eq for CowStr<'s> {} + +impl<'s> Display for CowStr<'s> { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(self.deref()) + } +} + +impl<'s, 'a> FromIterator<&'a str> for CowStr<'s> { + fn from_iter>(iter: T) -> Self { + CowStr::Owned(FromIterator::from_iter(iter)) + } +}