Enum icu::pattern::SinglePlaceholder

pub enum SinglePlaceholder {}

Backend for patterns containing zero or one placeholder.

This empty type is not constructible.

Placeholder Keys

The placeholder is always SinglePlaceholderKey::Singleton.

In Pattern::interpolate(), pass a single-element array or tuple.

Encoding Details

The first code point of the string is 1 plus the byte offset of the placeholder counting from after that initial code point. If zero, there is no placeholder.

Examples

Parsing a pattern into the encoding:

use core::str::FromStr;
use icu_pattern::Pattern;
use icu_pattern::SinglePlaceholder;

// Parse the string syntax and check the resulting data store:
let pattern = Pattern::<SinglePlaceholder>::try_from_str(
    "Hello, {0}!",
    Default::default(),
)
.unwrap();

assert_eq!("\u{8}Hello, !", &pattern.store);

Example patterns supported by this backend:

use core::str::FromStr;
use icu_pattern::Pattern;
use icu_pattern::QuoteMode;
use icu_pattern::SinglePlaceholder;

// Single numeric placeholder:
assert_eq!(
    Pattern::<SinglePlaceholder>::try_from_str(
        "{0} days ago",
        Default::default()
    )
    .unwrap()
    .interpolate_to_string([5]),
    "5 days ago",
);

// Single named placeholder:
assert_eq!(
    Pattern::<SinglePlaceholder>::try_from_str(
        "{name}",
        Default::default()
    )
    .unwrap()
    .interpolate_to_string(["Alice"]),
    "Alice",
);

// No placeholder (note, the placeholder value is never accessed):
assert_eq!(
    Pattern::<SinglePlaceholder>::try_from_str(
        "yesterday",
        Default::default()
    )
    .unwrap()
    .interpolate_to_string(["hi"]),
    "yesterday",
);

// Escaped placeholder and a real placeholder:
assert_eq!(
    Pattern::<SinglePlaceholder>::try_from_str(
        "'{0}' {1}",
        QuoteMode::QuotingSupported.into()
    )
    .unwrap()
    .interpolate_to_string(("hi",)),
    "{0} hi",
);

Trait Implementations

impl Clone for SinglePlaceholder

fn clone(&self) -> SinglePlaceholder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SinglePlaceholder

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

Formats the value using the given formatter.

impl PartialEq for SinglePlaceholder

fn eq(&self, other: &SinglePlaceholder) -> 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 PatternBackend for SinglePlaceholder

type PlaceholderKey<'a> = SinglePlaceholderKey

The type to be used as the placeholder key in code.

type PlaceholderKeyCow<'a> = SinglePlaceholderKey

Cowable version of the type to be used as the placeholder key in code.

type Error<'a> = Infallible

The type of error that the TryWriteable for this backend can return.

impl Copy for SinglePlaceholder

impl Eq for SinglePlaceholder

impl StructuralPartialEq for SinglePlaceholder