Struct GenericPattern

pub struct GenericPattern<'data> {
    pub items: ZeroVec<'data, GenericPatternItem>,
}

A raw, low-level pattern with literals and placeholders.

This is a datetime-specific type designed to be binary-compatible with Pattern. ICU4X developers looking for this sort of type should use the icu_pattern crate instead.

🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways, including in SemVer minor releases. While the serde representation of data structs is guaranteed to be stable, their Rust representation might not be. Use with caution.

Fields

items: ZeroVec<'data, GenericPatternItem>

The list of GenericPatternItems.

Implementations

impl GenericPattern<'_>

pub fn to_string(&self) -> String

Converts the given value to a String.

Under the hood, this uses an efficient Writeable implementation. However, in order to avoid allocating a string, it is more efficient to use Writeable directly.

impl<'data> GenericPattern<'data>

pub fn combined( self, date: Pattern<'data>, time: Pattern<'data>, ) -> Result<Pattern<'static>, PatternError>

The function allows for creation of new DTF pattern from a generic pattern and replacement patterns.

Examples

use icu::datetime::provider::pattern::runtime::{GenericPattern, Pattern};

let date: Pattern = "y-M-d".parse().expect("Failed to parse pattern");
let time: Pattern = "HH:mm".parse().expect("Failed to parse pattern");

let glue: GenericPattern = "{1} 'at' {0}"
    .parse()
    .expect("Failed to parse generic pattern");
assert_eq!(
    glue.combined(date, time)
        .expect("Failed to combine patterns")
        .to_string(),
    "y-M-d 'at' HH:mm"
);

Trait Implementations

impl<'data> Clone for GenericPattern<'data>

fn clone(&self) -> GenericPattern<'data>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'data> Debug for GenericPattern<'data>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for GenericPattern<'_>

fn default() -> GenericPattern<'_>

Returns the “default value” for a type.

impl<'de, 'data> Deserialize<'de> for GenericPattern<'data>

where 'de: 'data,

fn deserialize<D>( deserializer: D, ) -> Result<GenericPattern<'data>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GenericPattern<'_>

This trait is implemented for compatibility with fmt!. To create a string, Writeable::write_to_string is usually more efficient.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<&GenericPattern<'_>> for GenericPattern

fn from(input: &GenericPattern<'_>) -> GenericPattern

Converts to this type from the input type.

impl From<&GenericPattern> for GenericPattern<'_>

fn from(input: &GenericPattern) -> GenericPattern<'_>

Converts to this type from the input type.

impl FromStr for GenericPattern<'_>

type Err = PatternError

The associated error which can be returned from parsing.

fn from_str( s: &str, ) -> Result<GenericPattern<'_>, <GenericPattern<'_> as FromStr>::Err>

Parses a string s to return a value of this type.

impl<'data> PartialEq for GenericPattern<'data>

fn eq(&self, other: &GenericPattern<'data>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Writeable for GenericPattern<'_>

fn write_to<W>(&self, formatter: &mut W) -> Result<(), Error>

where W: Write + ?Sized,

Writes a string to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to_parts, and discards any Part annotations.

fn write_to_parts<S>(&self, sink: &mut S) -> Result<(), Error>

where S: PartsWrite + ?Sized,

Write bytes and Part annotations to the given sink. Errors from the sink are bubbled up. The default implementation delegates to write_to, and doesn’t produce any Part annotations.

fn writeable_length_hint(&self) -> LengthHint

Returns a hint for the number of UTF-8 bytes that will be written to the sink.

fn write_to_string(&self) -> Cow<'_, str>

Creates a new String with the data from this Writeable. Like ToString, but smaller and faster.

impl<'a> Yokeable<'a> for GenericPattern<'static>

type Output = GenericPattern<'a>

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>

fn transform(&'a self) -> &'a <GenericPattern<'static> as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>.

fn transform_owned(self) -> <GenericPattern<'static> as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>.

unsafe fn make( this: <GenericPattern<'static> as Yokeable<'a>>::Output, ) -> GenericPattern<'static>

This method can be used to cast away Self<'a>’s lifetime.

fn transform_mut<F>(&'a mut self, f: F)

where F: 'static + for<'b> FnOnce(&'b mut <GenericPattern<'static> as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>, and pass it to f.

impl<'zf, 'zf_inner> ZeroFrom<'zf, GenericPattern<'zf_inner>> for GenericPattern<'zf>

fn zero_from(this: &'zf GenericPattern<'zf_inner>) -> GenericPattern<'zf>

Clone the other C into a struct that may retain references into C.

impl<'data> Eq for GenericPattern<'data>

impl<'data> StructuralPartialEq for GenericPattern<'data>