/rust/registry/src/index.crates.io-1949cf8c6b5b557f/tinystr-0.7.6/src/unvalidated.rs

Source
// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use crate::TinyAsciiStr;
use crate::TinyStrError;
use core::fmt;

/// A fixed-length bytes array that is expected to be an ASCII string but does not enforce that invariant.
///
/// Use this type instead of `TinyAsciiStr` if you don't need to enforce ASCII during deserialization. For
/// example, strings that are keys of a map don't need to ever be reified as `TinyAsciiStr`s.
///
/// The main advantage of this type over `[u8; N]` is that it serializes as a string in
/// human-readable formats like JSON.
#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy)]
pub struct UnvalidatedTinyAsciiStr<const N: usize>(pub(crate) [u8; N]);

impl<const N: usize> fmt::Debug for UnvalidatedTinyAsciiStr<N> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // Debug as a string if possible
        match self.try_into_tinystr() {
            Ok(s) => fmt::Debug::fmt(&s, f),
            Err(_) => fmt::Debug::fmt(&self.0, f),
        }
    }
}

impl<const N: usize> UnvalidatedTinyAsciiStr<N> {
    #[inline]
    // Converts into a [`TinyAsciiStr`]. Fails if the bytes are not valid ASCII.
    pub fn try_into_tinystr(&self) -> Result<TinyAsciiStr<N>, TinyStrError> {
        TinyAsciiStr::try_from_raw(self.0)
    }

    #[doc(hidden)]
    pub const fn from_bytes_unchecked(bytes: [u8; N]) -> Self {
        Self(bytes)
    }
}

impl<const N: usize> TinyAsciiStr<N> {
    #[inline]
    // Converts into a [`UnvalidatedTinyAsciiStr`]
    pub const fn to_unvalidated(self) -> UnvalidatedTinyAsciiStr<N> {
        UnvalidatedTinyAsciiStr(*self.all_bytes())
    }
}

impl<const N: usize> From<TinyAsciiStr<N>> for UnvalidatedTinyAsciiStr<N> {
    fn from(other: TinyAsciiStr<N>) -> Self {
        other.to_unvalidated()
    }
}

#[cfg(feature = "serde")]
impl<const N: usize> serde::Serialize for UnvalidatedTinyAsciiStr<N> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::Error;
        self.try_into_tinystr()
            .map_err(|_| S::Error::custom("invalid ascii in UnvalidatedTinyAsciiStr"))?
            .serialize(serializer)
    }
}

macro_rules! deserialize {
    ($size:literal) => {
        #[cfg(feature = "serde")]
        impl<'de, 'a> serde::Deserialize<'de> for UnvalidatedTinyAsciiStr<$size>
        where
            'de: 'a,
        {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                if deserializer.is_human_readable() {
                    Ok(TinyAsciiStr::deserialize(deserializer)?.to_unvalidated())
                } else {
                    Ok(Self(<[u8; $size]>::deserialize(deserializer)?))
                }
            }
        }
    };
}

deserialize!(1);
deserialize!(2);
deserialize!(3);
deserialize!(4);
deserialize!(5);
deserialize!(6);
deserialize!(7);
deserialize!(8);
deserialize!(9);
deserialize!(10);
deserialize!(11);
deserialize!(12);
deserialize!(13);
deserialize!(14);
deserialize!(15);
deserialize!(16);
deserialize!(17);
deserialize!(18);
deserialize!(19);
deserialize!(20);
deserialize!(21);
deserialize!(22);
deserialize!(23);
deserialize!(24);
deserialize!(25);
deserialize!(26);
deserialize!(27);
deserialize!(28);
deserialize!(29);
deserialize!(30);
deserialize!(31);
deserialize!(32);

Coverage Report

Created: 2025-11-16 07:04

Line	Count	Source
1		// This file is part of ICU4X. For terms of use, please see the file
2		// called LICENSE at the top level of the ICU4X source tree
3		// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
4
5		use crate::TinyAsciiStr;
6		use crate::TinyStrError;
7		use core::fmt;
8
9		/// A fixed-length bytes array that is expected to be an ASCII string but does not enforce that invariant.
10		///
11		/// Use this type instead of `TinyAsciiStr` if you don't need to enforce ASCII during deserialization. For
12		/// example, strings that are keys of a map don't need to ever be reified as `TinyAsciiStr`s.
13		///
14		/// The main advantage of this type over `[u8; N]` is that it serializes as a string in
15		/// human-readable formats like JSON.
16		#[derive(PartialEq, PartialOrd, Eq, Ord, Clone, Copy)]
17		pub struct UnvalidatedTinyAsciiStr<const N: usize>(pub(crate) [u8; N]);
18
19		impl<const N: usize> fmt::Debug for UnvalidatedTinyAsciiStr<N> {
20	0	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
21		// Debug as a string if possible
22	0	match self.try_into_tinystr() {
23	0	Ok(s) => fmt::Debug::fmt(&s, f),
24	0	Err(_) => fmt::Debug::fmt(&self.0, f),
25		}
26	0	}
27		}
28
29		impl<const N: usize> UnvalidatedTinyAsciiStr<N> {
30		#[inline]
31		// Converts into a [`TinyAsciiStr`]. Fails if the bytes are not valid ASCII.
32	0	pub fn try_into_tinystr(&self) -> Result<TinyAsciiStr<N>, TinyStrError> {
33	0	TinyAsciiStr::try_from_raw(self.0)
34	0	}
35
36		#[doc(hidden)]
37	0	pub const fn from_bytes_unchecked(bytes: [u8; N]) -> Self {
38	0	Self(bytes)
39	0	}
40		}
41
42		impl<const N: usize> TinyAsciiStr<N> {
43		#[inline]
44		// Converts into a [`UnvalidatedTinyAsciiStr`]
45	0	pub const fn to_unvalidated(self) -> UnvalidatedTinyAsciiStr<N> {
46	0	UnvalidatedTinyAsciiStr(*self.all_bytes())
47	0	} Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<2>>::to_unvalidated Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<3>>::to_unvalidated Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<4>>::to_unvalidated Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<7>>::to_unvalidated Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<8>>::to_unvalidated Unexecuted instantiation: <tinystr::ascii::TinyAsciiStr<_>>::to_unvalidated
48		}
49
50		impl<const N: usize> From<TinyAsciiStr<N>> for UnvalidatedTinyAsciiStr<N> {
51	0	fn from(other: TinyAsciiStr<N>) -> Self {
52	0	other.to_unvalidated()
53	0	}
54		}
55
56		#[cfg(feature = "serde")]
57		impl<const N: usize> serde::Serialize for UnvalidatedTinyAsciiStr<N> {
58		fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
59		where
60		S: serde::Serializer,
61		{
62		use serde::ser::Error;
63		self.try_into_tinystr()
64		.map_err(\|_\| S::Error::custom("invalid ascii in UnvalidatedTinyAsciiStr"))?
65		.serialize(serializer)
66		}
67		}
68
69		macro_rules! deserialize {
70		($size:literal) => {
71		#[cfg(feature = "serde")]
72		impl<'de, 'a> serde::Deserialize<'de> for UnvalidatedTinyAsciiStr<$size>
73		where
74		'de: 'a,
75		{
76		fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
77		where
78		D: serde::Deserializer<'de>,
79		{
80		if deserializer.is_human_readable() {
81		Ok(TinyAsciiStr::deserialize(deserializer)?.to_unvalidated())
82		} else {
83		Ok(Self(<[u8; $size]>::deserialize(deserializer)?))
84		}
85		}
86		}
87		};
88		}
89
90		deserialize!(1);
91		deserialize!(2);
92		deserialize!(3);
93		deserialize!(4);
94		deserialize!(5);
95		deserialize!(6);
96		deserialize!(7);
97		deserialize!(8);
98		deserialize!(9);
99		deserialize!(10);
100		deserialize!(11);
101		deserialize!(12);
102		deserialize!(13);
103		deserialize!(14);
104		deserialize!(15);
105		deserialize!(16);
106		deserialize!(17);
107		deserialize!(18);
108		deserialize!(19);
109		deserialize!(20);
110		deserialize!(21);
111		deserialize!(22);
112		deserialize!(23);
113		deserialize!(24);
114		deserialize!(25);
115		deserialize!(26);
116		deserialize!(27);
117		deserialize!(28);
118		deserialize!(29);
119		deserialize!(30);
120		deserialize!(31);
121		deserialize!(32);