Implement try_from_bytes for Pattern (#5034)

Author: younies

utils/pattern/src/common.rs

@@ -75,13 +75,21 @@ pub trait PatternBackend: crate::private::Sealed + 'static {
     /// The type of error that the [`TryWriteable`] for this backend can return.
     type Error<'a>;
 
+    /// The type of error that the [`PatternBackend::try_store_from_bytes`] can return.
+    type StoreFromBytesError;
+
     /// The unsized type of the store required for this backend, usually `str` or `[u8]`.
     type Store: ?Sized;
 
     /// The iterator type returned by [`Self::try_from_items`].
     #[doc(hidden)] // TODO(#4467): Should be internal
     type Iter<'a>: Iterator<Item = PatternItem<'a, Self::PlaceholderKey<'a>>>;
 
+    /// Converts a byte slice store to this pattern backend's store.
+    /// Does not perform validation of the store.
+    #[doc(hidden)] // TODO(#4467): Should be internal
+    fn try_store_from_bytes(bytes: &[u8]) -> Result<&Self::Store, Self::StoreFromBytesError>;
+
     /// Checks a store for validity, returning an error if invalid.
     #[doc(hidden)] // TODO(#4467): Should be internal
     fn validate_store(store: &Self::Store) -> Result<(), Error>;

utils/pattern/src/double.rs

@@ -5,6 +5,7 @@
 //! Code for the [`DoublePlaceholder`] pattern backend.
 
 use core::convert::Infallible;
+use core::str::Utf8Error;
 use core::{cmp::Ordering, str::FromStr};
 use either::Either;
 use writeable::adapters::WriteableAsTryWriteableInfallible;
@@ -270,9 +271,15 @@ impl PatternBackend for DoublePlaceholder {
     #[cfg(feature = "alloc")]
     type PlaceholderKeyCow<'a> = DoublePlaceholderKey;
     type Error<'a> = Infallible;
+    type StoreFromBytesError = Utf8Error;
     type Store = str;
     type Iter<'a> = DoublePlaceholderPatternIterator<'a>;
 
+    #[inline]
+    fn try_store_from_bytes(bytes: &[u8]) -> Result<&Self::Store, Self::StoreFromBytesError> {
+        core::str::from_utf8(bytes)
+    }
+
     fn validate_store(store: &Self::Store) -> Result<(), Error> {
         let mut chars = store.chars();
         let ph_first_char = chars.next().ok_or(Error::InvalidPattern)?;

utils/pattern/src/error.rs

@@ -13,5 +13,13 @@ pub enum PatternError {
     InvalidPlaceholder,
 }
 
+/// Error type for [`crate::Pattern::try_from_bytes_store`].
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum PatternOrUtf8Error<E> {
+    Pattern(PatternError),
+    Utf8(E),
+}
+
 #[cfg(feature = "std")]
 impl std::error::Error for PatternError {}

utils/pattern/src/frontend/mod.rs

@@ -6,22 +6,19 @@
 mod databake;
 #[cfg(feature = "serde")]
 mod serde;
-
-use core::{
-    convert::Infallible,
-    fmt::{self, Write},
-    marker::PhantomData,
-};
-
-use writeable::{adapters::TryWriteableInfallibleAsWriteable, PartsWrite, TryWriteable, Writeable};
-
 use crate::common::*;
 use crate::Error;
-
+use crate::PatternOrUtf8Error;
 #[cfg(feature = "alloc")]
 use crate::{Parser, ParserOptions};
 #[cfg(feature = "alloc")]
 use alloc::{borrow::ToOwned, str::FromStr, string::String};
+use core::{
+    convert::Infallible,
+    fmt::{self, Write},
+    marker::PhantomData,
+};
+use writeable::{adapters::TryWriteableInfallibleAsWriteable, PartsWrite, TryWriteable, Writeable};
 
 /// A string pattern with placeholders.
 ///
@@ -167,6 +164,33 @@ where
     }
 }
 
+impl<'a, B> Pattern<B, &'a B::Store>
+where
+    B: PatternBackend,
+{
+    /// Creates a pattern from its store encoded as bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu_pattern::Pattern;
+    /// use icu_pattern::SinglePlaceholder;
+    ///
+    /// Pattern::<SinglePlaceholder, _>::try_from_bytes_store(b"\x01 days")
+    ///     .expect("single placeholder pattern");
+    /// ```
+    pub fn try_from_bytes_store(
+        bytes: &'a [u8],
+    ) -> Result<Self, PatternOrUtf8Error<B::StoreFromBytesError>> {
+        let store = B::try_store_from_bytes(bytes).map_err(PatternOrUtf8Error::Utf8)?;
+        B::validate_store(store).map_err(PatternOrUtf8Error::Pattern)?;
+        Ok(Self {
+            _backend: PhantomData,
+            store,
+        })
+    }
+}
+
 #[cfg(feature = "alloc")]
 impl<B> Pattern<B, <B::Store as ToOwned>::Owned>
 where

utils/pattern/src/frontend/serde.rs

@@ -12,10 +12,10 @@ use ::serde::{Deserialize, Deserializer, Serialize, Serializer};
 type HumanReadablePattern<'a, B> =
     Vec<PatternItemCow<'a, <B as PatternBackend>::PlaceholderKeyCow<'a>>>;
 
-impl<'de, 'data, B, Store> Deserialize<'de> for Pattern<B, Store>
+impl<'de, 'data, B, Store, E> Deserialize<'de> for Pattern<B, Store>
 where
     'de: 'data,
-    B: PatternBackend,
+    B: PatternBackend<StoreFromBytesError = E>,
     B::Store: ToOwned + 'de,
     &'de B::Store: Deserialize<'de>,
     B::PlaceholderKeyCow<'data>: Deserialize<'de>,

utils/pattern/src/lib.rs

@@ -70,6 +70,7 @@ pub use common::PATTERN_PLACEHOLDER_PART;
 pub use double::DoublePlaceholder;
 pub use double::DoublePlaceholderKey;
 pub use error::PatternError;
+pub use error::PatternOrUtf8Error;
 pub use frontend::Pattern;
 pub use multi_named::MissingNamedPlaceholderError;
 pub use multi_named::MultiNamedPlaceholder;

utils/pattern/src/multi_named.rs

@@ -7,6 +7,7 @@
 #[cfg(feature = "alloc")]
 use alloc::{borrow::Cow, collections::BTreeMap, str::FromStr, string::String};
 use core::fmt;
+use core::str::Utf8Error;
 #[cfg(feature = "litemap")]
 use litemap::LiteMap;
 use writeable::Writeable;
@@ -314,9 +315,15 @@ impl PatternBackend for MultiNamedPlaceholder {
     #[cfg(feature = "alloc")]
     type PlaceholderKeyCow<'a> = MultiNamedPlaceholderKeyCow<'a>;
     type Error<'a> = MissingNamedPlaceholderError<'a>;
+    type StoreFromBytesError = Utf8Error;
     type Store = str;
     type Iter<'a> = MultiNamedPlaceholderPatternIterator<'a>;
 
+    #[inline]
+    fn try_store_from_bytes(bytes: &[u8]) -> Result<&Self::Store, Self::StoreFromBytesError> {
+        core::str::from_utf8(bytes)
+    }
+
     fn validate_store(store: &Self::Store) -> Result<(), Error> {
         let mut iter = MultiNamedPlaceholderPatternIterator::new(store);
         while iter

utils/pattern/src/single.rs

@@ -5,6 +5,7 @@
 //! Code for the [`SinglePlaceholder`] pattern backend.
 
 use core::convert::Infallible;
+use core::str::Utf8Error;
 use core::{cmp::Ordering, str::FromStr};
 use writeable::adapters::WriteableAsTryWriteableInfallible;
 use writeable::Writeable;
@@ -171,9 +172,15 @@ impl PatternBackend for SinglePlaceholder {
     #[cfg(feature = "alloc")]
     type PlaceholderKeyCow<'a> = SinglePlaceholderKey;
     type Error<'a> = Infallible;
+    type StoreFromBytesError = Utf8Error;
     type Store = str;
     type Iter<'a> = SinglePlaceholderPatternIterator<'a>;
 
+    #[inline]
+    fn try_store_from_bytes(utf8: &[u8]) -> Result<&Self::Store, Self::StoreFromBytesError> {
+        core::str::from_utf8(utf8)
+    }
+
     fn validate_store(store: &Self::Store) -> Result<(), Error> {
         let placeholder_offset_char = store.chars().next().ok_or(Error::InvalidPattern)?;
         let initial_offset = placeholder_offset_char.len_utf8();