Enum icu::pattern::DoublePlaceholder

pub enum DoublePlaceholder {}

Backend for patterns containing zero, one, or two placeholders.

This empty type is not constructible.

Placeholder Keys

The placeholder is either DoublePlaceholderKey::Place0 or DoublePlaceholderKey::Place1.

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

Encoding Details

The first two code points contain the indices of the first and second placeholders with the following encoding:

1. First bit: 0 for DoublePlaceholderKey::Place0, 1 for DoublePlaceholderKey::Place1.
2. Second and higher bits: 1 plus the byte offset of the placeholder counting from after the placeholder index code points. If zero, skip this placeholder.

Examples

Parsing a pattern into the encoding:

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

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

assert_eq!("\x10\x1BHello,  and !", &pattern.store);

Explanation of the lead code points:

1. \x10 is placeholder 0 at index 7: ((7 + 1) << 1) | 0
2. \x1B is placeholder 1 at index 12: ((12 + 1) << 1) | 1

Example patterns supported by this backend:

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

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

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

// Escaped placeholder and a placeholder value 1 (note, "bar" is used):
assert_eq!(
    Pattern::<DoublePlaceholder>::try_from_str(
        "'{0}' {1}",
        QuoteMode::QuotingSupported.into()
    )
    .unwrap()
    .interpolate_to_string(("foo", "bar")),
    "{0} bar",
);

// Pattern with the placeholders in the opposite order:
assert_eq!(
    Pattern::<DoublePlaceholder>::try_from_str(
        "A {1} B {0} C",
        Default::default()
    )
    .unwrap()
    .interpolate_to_string(("D", "E")),
    "A E B D C",
);

// No literals, only placeholders:
assert_eq!(
    Pattern::<DoublePlaceholder>::try_from_str(
        "{1}{0}",
        Default::default()
    )
    .unwrap()
    .interpolate_to_string((1, "A")),
    "A1",
);

Trait Implementations

impl Clone for DoublePlaceholder

fn clone(&self) -> DoublePlaceholder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DoublePlaceholder

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

Formats the value using the given formatter.

impl PartialEq for DoublePlaceholder

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

type PlaceholderKey<'a> = DoublePlaceholderKey

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

type PlaceholderKeyCow<'a> = DoublePlaceholderKey

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 DoublePlaceholder

impl Eq for DoublePlaceholder

impl StructuralPartialEq for DoublePlaceholder