Struct icu_plurals::rules::ast::Rule

pub struct Rule {
    pub condition: Condition,
    pub samples: Option<Samples>,
}

A complete AST representation of a plural rule. Comprises a vector of AndConditions and optionally a set of Samples.

Examples

use icu::plurals::rules::ast::*;
use icu::plurals::rules::{parse, parse_condition};

let condition = parse_condition(b"i = 5 or v = 2")
    .expect("Parsing failed.");

let samples = Samples {
    integer: Some(SampleList {
        sample_ranges: Box::new([SampleRange {
            lower_val: DecimalValue("2".to_string()),
            upper_val: None,
        }]),
        ellipsis: true
    }),
    decimal: Some(SampleList {
        sample_ranges: Box::new([SampleRange {
            lower_val: DecimalValue("2.5".to_string()),
            upper_val: None,
        }]),
        ellipsis: false
    }),
};

let rule = Rule {
    condition,
    samples: Some(samples),
};

assert_eq!(
    rule,
    parse("i = 5 or v = 2 @integer 2, … @decimal 2.5".as_bytes())
         .expect("Parsing failed")
)

Fields

condition: Condition

samples: Option<Samples>

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl PartialEq<Rule> for Rule

fn eq(&self, other: &Rule) -> bool

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

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

This method tests for !=.

impl StructuralPartialEq for Rule