Struct 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.

🚧 This code is considered unstable; it may change at any time, in breaking or non-breaking ways, including in SemVer minor releases. In particular, the `DataProvider` implementations are only guaranteed to match with this version's `*_unstable` providers. Use with caution.

Examples

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

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

let samples = Samples {
    integer: Some(SampleList {
        sample_ranges: vec![SampleRange {
            lower_val: DecimalValue("2".to_string()),
            upper_val: None,
        }],
        ellipsis: true,
    }),
    decimal: Some(SampleList {
        sample_ranges: vec![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

The set of conditions that each must be satisfied for the entire Rule to be satisfied

samples: Option<Samples>

The set of sample numerical values matching each plural category that has a rule, or None if not present.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

impl PartialEq for Rule

fn eq(&self, other: &Rule) -> 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 TryFrom<&Rule> for Rule<'_>

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from( input: &Rule, ) -> Result<Rule<'_>, <Rule<'_> as TryFrom<&Rule>>::Error>

Performs the conversion.

impl StructuralPartialEq for Rule