Struct icu::plurals::PluralOperands

pub struct PluralOperands { /* private fields */ }

A full plural operands representation of a number. See CLDR Plural Rules for complete operands description.

Plural operands in compliance with CLDR Plural Rules.

See full operands description.

Data Types

The following types can be converted to PluralOperands:

• Integers, signed and unsigned
• Strings representing an arbitrary-precision decimal
• SignedFixedDecimal

This crate does not support selection from a floating-point number, because floats are not capable of carrying trailing zeros, which are required for proper plural rule selection. For example, in English, “1 star” has a different plural form than “1.0 stars”, but this distinction cannot be represented using a float. Clients should use SignedFixedDecimal instead.

Examples

From int

use icu::plurals::rules::RawPluralOperands;
use icu::plurals::PluralOperands;

assert_eq!(
    PluralOperands::from(RawPluralOperands {
        i: 2,
        v: 0,
        w: 0,
        f: 0,
        t: 0,
        c: 0,
    }),
    PluralOperands::from(2_usize)
);

From &str

use icu::plurals::rules::RawPluralOperands;
use icu::plurals::PluralOperands;

assert_eq!(
    Ok(PluralOperands::from(RawPluralOperands {
        i: 123,
        v: 2,
        w: 2,
        f: 45,
        t: 45,
        c: 0,
    })),
    "123.45".parse()
);

From SignedFixedDecimal

use fixed_decimal::SignedFixedDecimal;
use icu::plurals::rules::RawPluralOperands;
use icu::plurals::PluralOperands;

assert_eq!(
    PluralOperands::from(RawPluralOperands {
        i: 123,
        v: 2,
        w: 2,
        f: 45,
        t: 45,
        c: 0,
    }),
    (&{
        let mut decimal = SignedFixedDecimal::from(12345);
        decimal.multiply_pow10(-2);
        decimal
    }).into()
);

Implementations

impl PluralOperands

pub fn is_exactly_zero(self) -> bool

Whether these PluralOperands are exactly the number 0, which might be a special case.

pub fn is_exactly_one(self) -> bool

Whether these PluralOperands are exactly the number 1, which might be a special case.

Trait Implementations

impl Clone for PluralOperands

fn clone(&self) -> PluralOperands

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PluralOperands

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

Formats the value using the given formatter.

impl Default for PluralOperands

fn default() -> PluralOperands

Returns the “default value” for a type.

impl From<&CompactDecimal> for PluralOperands

fn from(compact: &CompactDecimal) -> PluralOperands

Converts a fixed_decimal::CompactDecimal to PluralOperands. Retains at most 18 digits each from the integer and fraction parts.

Examples

use fixed_decimal::CompactDecimal;
use fixed_decimal::SignedFixedDecimal;
use icu::locale::locale;
use icu::plurals::rules::RawPluralOperands;
use icu::plurals::PluralCategory;
use icu::plurals::PluralOperands;
use icu::plurals::PluralRules;

let fixed_decimal = "1000000.20".parse::<SignedFixedDecimal>().unwrap();
let compact_decimal = "1.00000020c6".parse::<CompactDecimal>().unwrap();

assert_eq!(
    PluralOperands::from(RawPluralOperands {
        i: 1000000,
        v: 2,
        w: 1,
        f: 20,
        t: 2,
        c: 0,
    }),
    PluralOperands::from(&fixed_decimal)
);

assert_eq!(
    PluralOperands::from(RawPluralOperands {
        i: 1000000,
        v: 2,
        w: 1,
        f: 20,
        t: 2,
        c: 6,
    }),
    PluralOperands::from(&compact_decimal)
);

let rules = PluralRules::try_new_cardinal(locale!("fr").into()).unwrap();
assert_eq!(rules.category_for(&fixed_decimal), PluralCategory::Other);
assert_eq!(rules.category_for(&compact_decimal), PluralCategory::Many);

impl From<&Signed<UnsignedFixedDecimal>> for PluralOperands

fn from(dec: &Signed<UnsignedFixedDecimal>) -> PluralOperands

Converts a fixed_decimal::SignedFixedDecimal to PluralOperands. Retains at most 18 digits each from the integer and fraction parts.

impl From<PluralOperands> for RawPluralOperands

fn from(po: PluralOperands) -> RawPluralOperands

Converts to this type from the input type.

impl From<RawPluralOperands> for PluralOperands

fn from(rpo: RawPluralOperands) -> PluralOperands

Converts to this type from the input type.

impl From<i128> for PluralOperands

fn from(input: i128) -> PluralOperands

Converts to this type from the input type.

impl From<i16> for PluralOperands

fn from(input: i16) -> PluralOperands

Converts to this type from the input type.

impl From<i32> for PluralOperands

fn from(input: i32) -> PluralOperands

Converts to this type from the input type.

impl From<i64> for PluralOperands

fn from(input: i64) -> PluralOperands

Converts to this type from the input type.

impl From<i8> for PluralOperands

fn from(input: i8) -> PluralOperands

Converts to this type from the input type.

impl From<isize> for PluralOperands

fn from(input: isize) -> PluralOperands

Converts to this type from the input type.

impl From<u128> for PluralOperands

fn from(input: u128) -> PluralOperands

Converts to this type from the input type.

impl From<u16> for PluralOperands

fn from(input: u16) -> PluralOperands

Converts to this type from the input type.

impl From<u32> for PluralOperands

fn from(input: u32) -> PluralOperands

Converts to this type from the input type.

impl From<u64> for PluralOperands

fn from(input: u64) -> PluralOperands

Converts to this type from the input type.

impl From<u8> for PluralOperands

fn from(input: u8) -> PluralOperands

Converts to this type from the input type.

impl From<usize> for PluralOperands

fn from(input: usize) -> PluralOperands

Converts to this type from the input type.

impl FromStr for PluralOperands

type Err = OperandsError

The associated error which can be returned from parsing.

fn from_str( input: &str, ) -> Result<PluralOperands, <PluralOperands as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for PluralOperands

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

impl StructuralPartialEq for PluralOperands