Enum icu_pattern::PatternToken

pub enum PatternToken<'s, P> {
    Placeholder(P),
    Literal {
        content: Cow<'s, str>,
        quoted: bool,
    },
}

A token returned by the Parser.

Examples

use icu_pattern::{Parser, ParserOptions, PatternToken};

let input = "{0}, {1}";

let mut parser = Parser::new(
    input,
    ParserOptions {
        allow_raw_letters: false,
    },
);

let mut result = vec![];

while let Some(element) =
    parser.try_next().expect("Failed to advance iterator")
{
    result.push(element);
}

assert_eq!(
    result,
    &[
        PatternToken::Placeholder(0),
        PatternToken::Literal {
            content: ", ".into(),
            quoted: false
        },
        PatternToken::Placeholder(1),
    ]
);

Type parameters

• P: A placeholder type which implements FromStr.

Lifetimes

• s: The life time of an input string slice being parsed.

Variants

Placeholder(P)

Literal

Fields

content: Cow<'s, str>

quoted: bool

Trait Implementations

impl<'s, P: Clone> Clone for PatternToken<'s, P>

fn clone(&self) -> PatternToken<'s, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'s, P: Debug> Debug for PatternToken<'s, P>

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

Formats the value using the given formatter.

impl<'s, P> From<(&'s str, bool)> for PatternToken<'s, P>

fn from(input: (&'s str, bool)) -> Self

Converts to this type from the input type.

impl<'s, P: PartialEq> PartialEq<PatternToken<'s, P>> for PatternToken<'s, P>

fn eq(&self, other: &PatternToken<'s, P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'s, P> StructuralPartialEq for PatternToken<'s, P>