Move the experimental InliningString to the inlining module
Pantonshire
3 years ago
parent
6d6d35f2e0
commit
5ca54944e8
@ -1,746 +0,0 @@
|
||||
use core::{
|
||||
borrow,
|
||||
cmp::Ordering,
|
||||
convert::Infallible,
|
||||
fmt,
|
||||
hash::{Hash, Hasher},
|
||||
mem::{self, ManuallyDrop, MaybeUninit},
|
||||
num::NonZeroU8,
|
||||
ops,
|
||||
ptr::{self, addr_of, addr_of_mut},
|
||||
slice,
|
||||
str,
|
||||
};
|
||||
|
||||
#[cfg(not(feature = "std"))]
|
||||
use alloc::{
|
||||
borrow::Cow,
|
||||
boxed::Box,
|
||||
rc::Rc,
|
||||
string::String,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::{
|
||||
borrow::Cow,
|
||||
rc::Rc,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
/// A non-growable string where strings 23 bytes or shorter are stored inline and longer strings
|
||||
/// use a separate heap allocation. If maximum inline lengths other than 23 are desired, see the
|
||||
/// more general [InliningString].
|
||||
///
|
||||
/// 23 bytes is chosen because it is optimal for 64-bit architectures; the minimum possible size
|
||||
/// of the data structure on 64-bit architectures which always keeps the data properly aligned is
|
||||
/// 24 bytes (because, when heap-allocated, the data structure contains a 16-byte `Box<[u8]>` with
|
||||
/// 8-byte alignment and a 1-byte discriminant, and the greatest multiple of 8 which is ≥17 is 24),
|
||||
/// so there is space for 23 bytes of string data plus the 1-byte discriminant.
|
||||
pub type InliningString23 = InliningString<23>;
|
||||
|
||||
/// A non-growable string which stores small strings inline; strings of length less than or equal
|
||||
/// to `N` are stored inside the data structure itself, whereas strings of length greater than `N`
|
||||
/// use a separate heap allocation.
|
||||
///
|
||||
/// This type is intended to be used when lots of small strings need to be stored, and these
|
||||
/// strings do not need to grow.
|
||||
///
|
||||
/// For 64-bit targets, `N = 23` allows the greatest amount of inline string data to be stored
|
||||
/// without exceeding the size of a regular [String]. Therefore, [InliningString23] is provided as
|
||||
/// a type alias for `InliningString<23>`.
|
||||
///
|
||||
/// Although `N` is a `usize`, it may be no greater than `u8::MAX`; larger values will result in a
|
||||
/// compile-time error.
|
||||
///
|
||||
/// ```
|
||||
/// # use libshire::strings::InliningString;
|
||||
/// let s1 = InliningString::<23>::new("This string is 23 bytes");
|
||||
/// assert_eq!(&*s1, "This string is 23 bytes");
|
||||
/// assert!(!s1.heap_allocated());
|
||||
///
|
||||
/// let s2 = InliningString::<23>::new("and this one is 24 bytes");
|
||||
/// assert_eq!(&*s2, "and this one is 24 bytes");
|
||||
/// assert!(s2.heap_allocated());
|
||||
/// ```
|
||||
#[repr(C)]
|
||||
pub struct InliningString<const N: usize> {
|
||||
repr: Repr<N>,
|
||||
// When `len - 1` is less than or equal to `MAX_LEN`, `repr.inline` is active and the first
|
||||
// `len - 1` bytes of `repr.inline` contains initialised, valid UTF-8 data. When `len - 1` is
|
||||
// greater than `MAX_LEN`, `repr.boxed` is active. `NonZeroU8` is used to allow for the niche
|
||||
// optimisation (https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#niche).
|
||||
len: NonZeroU8,
|
||||
// A zero-sized field to ensure that `InliningString` has an alignment equal to the alignment
|
||||
// of `Box<str>`, to ensure that `repr.boxed` is properly aligned when it is active.
|
||||
_align: [Box<str>; 0],
|
||||
}
|
||||
|
||||
// `repr(C)` is necessary to ensure that both of the fields start at offset 0. `repr(packed)`
|
||||
// reduces the alignment to 1, which allows `InliningString` to be more compact.
|
||||
#[repr(C, packed)]
|
||||
union Repr<const N: usize> {
|
||||
inline: [MaybeUninit<u8>; N],
|
||||
boxed: ManuallyDrop<MaybeUninit<Box<str>>>,
|
||||
}
|
||||
|
||||
impl<const N: usize> InliningString<N> {
|
||||
const MAX_LEN: u8 = {
|
||||
#[allow(clippy::cast_possible_truncation, clippy::checked_conversions)]
|
||||
// `MAX_LEN` may be no larger than `u8::MAX - 2` to leave at least one bit pattern to
|
||||
// represent the "boxed" case and at least one bit pattern for the niche optimisation.
|
||||
if N <= (u8::MAX - 2) as usize {
|
||||
N as u8
|
||||
} else {
|
||||
panic!("`N` must be no greater than `u8::MAX - 2`")
|
||||
}
|
||||
};
|
||||
|
||||
#[must_use]
|
||||
pub fn new<S>(s: S) -> Self
|
||||
where
|
||||
S: AsRef<str>,
|
||||
Box<str>: From<S>,
|
||||
{
|
||||
let src = s.as_ref().as_bytes();
|
||||
|
||||
match u8::try_from(src.len()) {
|
||||
Ok(len) if len <= Self::MAX_LEN => {
|
||||
unsafe {
|
||||
// SAFETY:
|
||||
// `MaybeUninit::uninit()` is a valid value for `[MaybeUninit<u8>; N]`, since
|
||||
// each element of the array is allowed to be uninitialised.
|
||||
let mut buf = MaybeUninit::<[MaybeUninit<u8>; N]>::uninit()
|
||||
.assume_init();
|
||||
|
||||
// Cast the byte slice to a `MaybeUninit<u8>` pointer. This is valid because
|
||||
// `u8` has the same memory layout as `MaybeUninit<u8>`.
|
||||
let src_ptr = src.as_ptr() as *const MaybeUninit<u8>;
|
||||
|
||||
// Copy the string data provided by the caller into the buffer.
|
||||
// SAFETY:
|
||||
// The source is valid because the source and length are both taken from a
|
||||
// valid `&[u8]`. We have already checked in the match statement that there is
|
||||
// enough space in the buffer to fit the string data (i.e. `len` is less than
|
||||
// or equal to `MAX_LEN`, which is equal to `N`), so the destination is valid.
|
||||
// The source and destination are trivially properly aligned because the
|
||||
// alignment of `MaybeUninit<u8>` is 1. The source and destination do not
|
||||
// overlap; the destination buffer is a new variable completely separate from
|
||||
// the source data.
|
||||
ptr::copy_nonoverlapping(src_ptr, buf.as_mut_ptr(), usize::from(len));
|
||||
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `buf` are copied from a `&str`, so the first `len`
|
||||
// bytes are valid UTF-8. We have already checked that `len` is thess than or
|
||||
// equal to `Self::MAX_LEN`.
|
||||
Self::inline_from_raw_parts(buf, len)
|
||||
}
|
||||
},
|
||||
|
||||
_ => Self::new_boxed(s),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn empty() -> Self {
|
||||
unsafe {
|
||||
// SAFETY:
|
||||
// `MaybeUninit::uninit()` is a valid value for `[MaybeUninit<u8>; N]`, since each
|
||||
// element of the array is allowed to be uninitialised.
|
||||
let buf = MaybeUninit::<[MaybeUninit<u8>; N]>::uninit()
|
||||
.assume_init();
|
||||
|
||||
// SAFETY:
|
||||
// `len` is 0, so the contract that the first `len` bytes of `buf` are initialised and
|
||||
// valid UTF-8 is trivially upheld.
|
||||
Self::inline_from_raw_parts(buf, 0)
|
||||
}
|
||||
}
|
||||
|
||||
/// # Safety
|
||||
/// The first `len` bytes of `buf` must be initialised and valid UTF-8. `len` must be less than
|
||||
/// or equal to `Self::MAX_LEN` (which is equal to `N`).
|
||||
#[inline]
|
||||
unsafe fn inline_from_raw_parts(buf: [MaybeUninit<u8>; N], len: u8) -> Self {
|
||||
// SAFETY:
|
||||
// The caller is responsible for ensuring that `len` is less than or equal to
|
||||
// `Self::MAX_LEN`, which is no greater than `u8::MAX - 2`. If this contract is upheld,
|
||||
// `len + 1` can never overflow, so `len + 1` can never be zero.
|
||||
let len = NonZeroU8::new_unchecked(len + 1);
|
||||
|
||||
Self {
|
||||
repr: Repr { inline: buf },
|
||||
len,
|
||||
_align: [],
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn new_boxed<S>(s: S) -> Self
|
||||
where
|
||||
Box<str>: From<S>,
|
||||
{
|
||||
const U8_NONZERO_MAX: NonZeroU8 = unsafe { NonZeroU8::new_unchecked(u8::MAX) };
|
||||
|
||||
Self {
|
||||
repr: Repr {
|
||||
boxed: ManuallyDrop::new(MaybeUninit::new(Box::from(s))),
|
||||
},
|
||||
len: U8_NONZERO_MAX,
|
||||
_align: [],
|
||||
}
|
||||
}
|
||||
|
||||
/// If the `inline` field is active, returns the length of the inline string data. If the
|
||||
/// `boxed` field is active, returns `None`.
|
||||
#[inline(always)]
|
||||
fn inline_string_len(&self) -> Option<u8> {
|
||||
let len = self.len.get() - 1;
|
||||
if len <= Self::MAX_LEN {
|
||||
Some(len)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn as_str(&self) -> &str {
|
||||
match self.inline_string_len() {
|
||||
Some(len) => {
|
||||
// Get a pointer to the `inline` field of the union.
|
||||
// SAFETY:
|
||||
// Since `inline_string_len` returned `Some`, the `inline` field must be active.
|
||||
let ptr = unsafe { addr_of!(self.repr.inline) }
|
||||
as *const MaybeUninit<u8>
|
||||
as *const u8;
|
||||
|
||||
// Construct a byte slice from the pointer to the string data and the length.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` are always initialised, as this is an
|
||||
// invariant of `InliningString`.
|
||||
let bytes = unsafe { slice::from_raw_parts(ptr, usize::from(len)) };
|
||||
|
||||
// Perform an unchecked conversion from the byte slice to a string slice.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` is always valid UTF-8, as this is an invariant
|
||||
// of `InliningString`.
|
||||
unsafe { str::from_utf8_unchecked(bytes) }
|
||||
},
|
||||
|
||||
None => {
|
||||
// SAFETY:
|
||||
// `inline_string_len` returned `None`, which means that the `boxed` field is
|
||||
// active. `boxed` is properly aligned because it is stored at offset 0 of
|
||||
// `InliningString` (since both `InliningString` and `Repr` use `repr(C)`), and the
|
||||
// alignment of `InliningString` is equal to the alignment of `Box<str>`.
|
||||
let box_str = unsafe { &*addr_of!(self.repr.boxed) };
|
||||
|
||||
// SAFETY:
|
||||
// `repr.boxed` is initialised, as the only time it's uninitialised is when it is
|
||||
// briefly replaced with a temporary value before the `InliningString` is dropped
|
||||
// in the `into_string` function.
|
||||
unsafe { box_str.assume_init_ref() }
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn as_str_mut(&mut self) -> &mut str {
|
||||
match self.inline_string_len() {
|
||||
Some(len) => {
|
||||
// Get a pointer to the `inline` field of the union.
|
||||
// SAFETY:
|
||||
// Since `inline_string_len` returned `Some`, the `inline` field must be active.
|
||||
let ptr = unsafe { addr_of_mut!(self.repr.inline) }
|
||||
as *mut MaybeUninit<u8>
|
||||
as *mut u8;
|
||||
|
||||
// Construct a byte slice from the pointer to the string data and the length.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` are always initialised, as this is an
|
||||
// invariant of `InliningString`.
|
||||
let bytes = unsafe { slice::from_raw_parts_mut(ptr, usize::from(len)) };
|
||||
|
||||
// Perform an unchecked conversion from the byte slice to a string slice.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` is always valid UTF-8, as this is an invariant
|
||||
// of `InliningString`.
|
||||
unsafe { str::from_utf8_unchecked_mut(bytes) }
|
||||
},
|
||||
|
||||
None => {
|
||||
// SAFETY:
|
||||
// `inline_string_len` returned `None`, which means that the `boxed` field is
|
||||
// active. `boxed` is properly aligned because it is stored at offset 0 of
|
||||
// `InliningString` (since both `InliningString` and `Repr` use `repr(C)`), and the
|
||||
// alignment of `InliningString` is equal to the alignment of `Box<str>`.
|
||||
let box_str = unsafe { &mut *addr_of_mut!(self.repr.boxed) };
|
||||
|
||||
// SAFETY:
|
||||
// `repr.boxed` is initialised, as the only time it's uninitialised is when it is
|
||||
// briefly replaced with a temporary value before the `InliningString` is dropped
|
||||
// in the `into_string` function.
|
||||
unsafe { box_str.assume_init_mut() }
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn into_boxed_str(self) -> Box<str> {
|
||||
match self.inline_string_len() {
|
||||
Some(len) => {
|
||||
// Get a pointer to the `inline` field of the union.
|
||||
// SAFETY:
|
||||
// Since `inline_string_len` returned `Some`, the `inline` field must be active.
|
||||
let ptr = unsafe { addr_of!(self.repr.inline) }
|
||||
as *const MaybeUninit<u8>
|
||||
as *const u8;
|
||||
|
||||
// Construct a byte slice from the pointer to the string data and the length.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` are always initialised, as this is an
|
||||
// invariant of `InliningString`.
|
||||
let bytes = unsafe { slice::from_raw_parts(ptr, usize::from(len)) };
|
||||
|
||||
// Perform an unchecked conversion from the byte slice to a string slice.
|
||||
// SAFETY:
|
||||
// The first `len` bytes of `inline` is always valid UTF-8, as this is an invariant
|
||||
// of `InliningString`.
|
||||
let str_slice = unsafe { str::from_utf8_unchecked(bytes) };
|
||||
|
||||
Box::from(str_slice)
|
||||
},
|
||||
|
||||
None => {
|
||||
let manual_box_str = {
|
||||
// Disable the destructor for `self`; we are transferring ownership of the
|
||||
// allocated memory to the caller, so we don't want to run the destructor which
|
||||
// would free the memory.
|
||||
let mut this = ManuallyDrop::new(self);
|
||||
|
||||
// SAFETY:
|
||||
// `inline_string_len` returned `None`, which means that the `boxed` field is
|
||||
// active. `boxed` is properly aligned because it is stored at offset 0 of
|
||||
// `InliningString` (since both `InliningString` and `Repr` use `repr(C)`), and
|
||||
// the alignment of `InliningString` is equal to the alignment of `Box<str>`.
|
||||
let field_ref = unsafe { &mut *addr_of_mut!(this.repr.boxed) };
|
||||
|
||||
// Move `repr.boxed` out of the `InliningString`, replacing it with
|
||||
// uninitialised memory. This is sound because we have ownership of the
|
||||
// `InliningString` and we will not be doing anything else with it after this
|
||||
// which calls `assume_init` on `repr.boxed`; at the end of this block, the
|
||||
// `InliningString` is dropped without calling its destructor.
|
||||
mem::replace(field_ref, ManuallyDrop::new(MaybeUninit::uninit()))
|
||||
};
|
||||
|
||||
// Re-enable the destructor for the boxed string.
|
||||
let maybe_box_str = ManuallyDrop::into_inner(manual_box_str);
|
||||
|
||||
// SAFETY:
|
||||
// The boxed string is initialised, as we obtained it by moving `repr.boxed`, and
|
||||
// the only time `repr.boxed` is uninitialised is when it is briefly replaced with
|
||||
// a temporary value in the block above.
|
||||
unsafe { maybe_box_str.assume_init() }
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn into_string(self) -> String {
|
||||
self.into_boxed_str()
|
||||
.into_string()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn heap_allocated(&self) -> bool {
|
||||
self.inline_string_len().is_none()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn len(&self) -> usize {
|
||||
self.as_str().len()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.as_str().is_empty()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> Drop for InliningString<N> {
|
||||
fn drop(&mut self) {
|
||||
if self.heap_allocated() {
|
||||
let boxed = unsafe { &mut *addr_of_mut!(self.repr.boxed) };
|
||||
|
||||
// SAFETY:
|
||||
// Since this is a drop implementation, `boxed` will not be used again after this.
|
||||
let _ = unsafe { ManuallyDrop::take(boxed).assume_init() };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> Default for InliningString<N> {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
Self::empty()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> ops::Deref for InliningString<N> {
|
||||
type Target = str;
|
||||
|
||||
#[inline]
|
||||
fn deref(&self) -> &Self::Target {
|
||||
self.as_str()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> ops::DerefMut for InliningString<N> {
|
||||
#[inline]
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
self.as_str_mut()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> AsRef<str> for InliningString<N> {
|
||||
#[inline]
|
||||
fn as_ref(&self) -> &str {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> AsMut<str> for InliningString<N> {
|
||||
#[inline]
|
||||
fn as_mut(&mut self) -> &mut str {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> borrow::Borrow<str> for InliningString<N> {
|
||||
#[inline]
|
||||
fn borrow(&self) -> &str {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> borrow::BorrowMut<str> for InliningString<N> {
|
||||
#[inline]
|
||||
fn borrow_mut(&mut self) -> &mut str {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> str::FromStr for InliningString<N> {
|
||||
type Err = Infallible;
|
||||
|
||||
#[inline]
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
Ok(Self::new(s))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> From<&'a str> for InliningString<N> {
|
||||
#[inline]
|
||||
fn from(s: &'a str) -> Self {
|
||||
Self::new(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<String> for InliningString<N> {
|
||||
#[inline]
|
||||
fn from(s: String) -> Self {
|
||||
Self::new(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<Box<str>> for InliningString<N> {
|
||||
#[inline]
|
||||
fn from(s: Box<str>) -> Self {
|
||||
Self::new(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> From<Cow<'a, str>> for InliningString<N> {
|
||||
#[inline]
|
||||
fn from(s: Cow<'a, str>) -> Self {
|
||||
Self::new(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<InliningString<N>> for String {
|
||||
#[inline]
|
||||
fn from(s: InliningString<N>) -> Self {
|
||||
s.into_string()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<InliningString<N>> for Box<str> {
|
||||
#[inline]
|
||||
fn from(s: InliningString<N>) -> Self {
|
||||
s.into_boxed_str()
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<InliningString<N>> for Rc<str> {
|
||||
#[inline]
|
||||
fn from(s: InliningString<N>) -> Self {
|
||||
Rc::from(s.into_boxed_str())
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<InliningString<N>> for Arc<str> {
|
||||
#[inline]
|
||||
fn from(s: InliningString<N>) -> Self {
|
||||
Arc::from(s.into_boxed_str())
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize, const M: usize> PartialEq<InliningString<M>> for InliningString<N> {
|
||||
#[inline]
|
||||
fn eq(&self, other: &InliningString<M>) -> bool {
|
||||
**self == **other
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> Eq for InliningString<N> {}
|
||||
|
||||
impl<const N: usize, const M: usize> PartialOrd<InliningString<M>> for InliningString<N> {
|
||||
#[inline]
|
||||
fn partial_cmp(&self, other: &InliningString<M>) -> Option<Ordering> {
|
||||
(**self).partial_cmp(&**other)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> Ord for InliningString<N> {
|
||||
#[inline]
|
||||
fn cmp(&self, other: &Self) -> Ordering {
|
||||
(**self).cmp(&**other)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> Hash for InliningString<N> {
|
||||
#[inline]
|
||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||
(**self).hash(state);
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> fmt::Debug for InliningString<N> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt::Debug::fmt(&**self, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> fmt::Display for InliningString<N> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
fmt::Display::fmt(&**self, f)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
impl<const N: usize> serde::Serialize for InliningString<N> {
|
||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
S: serde::Serializer
|
||||
{
|
||||
serde::Serialize::serialize(&**self, serializer)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
impl<'de, const N: usize> serde::Deserialize<'de> for InliningString<N> {
|
||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||
where
|
||||
D: serde::Deserializer<'de>
|
||||
{
|
||||
#[cfg(not(feature = "std"))]
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use serde::de::{Error, Unexpected, Visitor};
|
||||
|
||||
struct InliningStringVisitor<const N: usize>;
|
||||
|
||||
impl<'de, const N: usize> Visitor<'de> for InliningStringVisitor<N> {
|
||||
type Value = InliningString<N>;
|
||||
|
||||
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
f.write_str("a string")
|
||||
}
|
||||
|
||||
fn visit_str<E: Error>(self, v: &str) -> Result<Self::Value, E> {
|
||||
Ok(Self::Value::new(v))
|
||||
}
|
||||
|
||||
fn visit_string<E: Error>(self, v: String) -> Result<Self::Value, E> {
|
||||
Ok(Self::Value::new(v))
|
||||
}
|
||||
|
||||
fn visit_bytes<E: Error>(self, v: &[u8]) -> Result<Self::Value, E> {
|
||||
str::from_utf8(v)
|
||||
.map(Self::Value::new)
|
||||
.map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
|
||||
}
|
||||
|
||||
fn visit_byte_buf<E: Error>(self, v: Vec<u8>) -> Result<Self::Value, E> {
|
||||
String::from_utf8(v)
|
||||
.map(Self::Value::new)
|
||||
.map_err(|err| {
|
||||
Error::invalid_value(Unexpected::Bytes(&err.into_bytes()), &self)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
deserializer.deserialize_string(InliningStringVisitor)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[cfg(not(feature = "std"))]
|
||||
use alloc::{
|
||||
borrow::{Cow, ToOwned},
|
||||
vec::Vec,
|
||||
};
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
use std::borrow::Cow;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_align() {
|
||||
use core::mem::align_of;
|
||||
assert_eq!(align_of::<InliningString23>(), align_of::<Box<str>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_niche() {
|
||||
use core::mem::size_of;
|
||||
assert_eq!(size_of::<InliningString23>(), size_of::<Option<InliningString23>>());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_empty() {
|
||||
assert_eq!(InliningString23::empty().as_str(), "");
|
||||
assert_eq!(InliningString23::empty().len(), 0);
|
||||
assert!(!InliningString23::empty().heap_allocated());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new() {
|
||||
let test_strings = [
|
||||
"",
|
||||
"Hello",
|
||||
"Somethingfortheweekend",
|
||||
"Dichlorodifluoromethane",
|
||||
"Electrocardiographically",
|
||||
"こんにちは",
|
||||
"❤️🧡💛💚💙💜",
|
||||
];
|
||||
|
||||
for s in test_strings {
|
||||
let buf = s.to_owned();
|
||||
let borrowed = Cow::Borrowed(s);
|
||||
let owned = Cow::<'static, str>::Owned(buf.clone());
|
||||
|
||||
assert_eq!(InliningString23::new(s).as_str(), s);
|
||||
assert_eq!(InliningString23::new(buf).as_str(), s);
|
||||
assert_eq!(InliningString23::new(borrowed).as_str(), s);
|
||||
assert_eq!(InliningString23::new(owned).as_str(), s);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_contiguous() {
|
||||
let test_strings = [
|
||||
"",
|
||||
"Hello",
|
||||
"Somethingfortheweekend",
|
||||
"Dichlorodifluoromethane",
|
||||
"Electrocardiographically",
|
||||
"こんにちは",
|
||||
"❤️🧡💛💚💙💜",
|
||||
];
|
||||
|
||||
#[allow(clippy::needless_collect)]
|
||||
let vec = test_strings
|
||||
.iter()
|
||||
.copied()
|
||||
.map(InliningString23::new)
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
for (i, s) in vec.into_iter().enumerate() {
|
||||
assert_eq!(s.as_str(), test_strings[i]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_as_str_mut() {
|
||||
let mut s1 = InliningString23::new("hello");
|
||||
s1.as_str_mut().make_ascii_uppercase();
|
||||
assert_eq!(s1.as_str(), "HELLO");
|
||||
|
||||
let mut s2 = InliningString23::new("the quick brown fox jumps over the lazy dog");
|
||||
s2.as_str_mut().make_ascii_uppercase();
|
||||
assert_eq!(s2.as_str(), "THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_into_string() {
|
||||
let test_strings = [
|
||||
"".to_owned(),
|
||||
"Hello".to_owned(),
|
||||
"Somethingfortheweekend".to_owned(),
|
||||
"Dichlorodifluoromethane".to_owned(),
|
||||
"Electrocardiographically".to_owned(),
|
||||
"こんにちは".to_owned(),
|
||||
"❤️🧡💛💚💙💜".to_owned(),
|
||||
];
|
||||
|
||||
for s in test_strings {
|
||||
assert_eq!(InliningString23::new(&*s).into_string(), s);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_len() {
|
||||
assert_eq!(InliningString23::new("").len(), 0);
|
||||
assert_eq!(InliningString23::new("Hello").len(), 5);
|
||||
assert_eq!(InliningString23::new("Somethingfortheweekend").len(), 22);
|
||||
assert_eq!(InliningString23::new("Dichlorodifluoromethane").len(), 23);
|
||||
assert_eq!(InliningString23::new("Electrocardiographically").len(), 24);
|
||||
assert_eq!(InliningString23::new("こんにちは").len(), 15);
|
||||
assert_eq!(InliningString23::new("❤️🧡💛💚💙💜").len(), 26);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_heap_allocated() {
|
||||
assert!(!InliningString23::new("").heap_allocated());
|
||||
assert!(!InliningString23::new("Hello").heap_allocated());
|
||||
assert!(!InliningString23::new("Somethingfortheweekend").heap_allocated());
|
||||
assert!(!InliningString23::new("Dichlorodifluoromethane").heap_allocated());
|
||||
assert!(!InliningString23::new("こんにちは").heap_allocated());
|
||||
|
||||
assert!(InliningString23::new("Electrocardiographically").heap_allocated());
|
||||
assert!(InliningString23::new("Squishedbuginsidethescreen").heap_allocated());
|
||||
assert!(InliningString23::new("❤️🧡💛💚💙💜").heap_allocated());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zero_capacity() {
|
||||
assert_eq!(InliningString::<0>::new("").as_str(), "");
|
||||
assert!(!InliningString::<0>::new("").heap_allocated());
|
||||
assert_eq!(InliningString::<0>::new("a").as_str(), "a");
|
||||
assert!(InliningString::<0>::new("a").heap_allocated());
|
||||
assert_eq!(InliningString::<0>::new("Hello").as_str(), "Hello");
|
||||
assert!(InliningString::<0>::new("Hello").heap_allocated());
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue