Struct icu_plurals::operands::PluralOperands

pub struct PluralOperands {
    pub(crate) i: u64,
    pub(crate) v: usize,
    pub(crate) w: usize,
    pub(crate) f: u64,
    pub(crate) t: u64,
    pub(crate) c: usize,
}

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
• FixedDecimal

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 FixedDecimal 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 FixedDecimal

use fixed_decimal::FixedDecimal;
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,
    }),
    (&FixedDecimal::from(12345).multiplied_pow10(-2)).into()
);

Fields

i: u64

Integer value of input

v: usize

Number of visible fraction digits with trailing zeros

w: usize

Number of visible fraction digits without trailing zeros

f: u64

Visible fraction digits with trailing zeros

t: u64

Visible fraction digits without trailing zeros

c: usize

Exponent of the power of 10 used in compact decimal formatting

Implementations

impl PluralOperands

fn from_significand_and_exponent(dec: &FixedDecimal, exp: u8) -> PluralOperands

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

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) -> Self

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::FixedDecimal;
use icu::locid::locale;
use icu::plurals::rules::RawPluralOperands;
use icu::plurals::PluralCategory;
use icu::plurals::PluralOperands;
use icu::plurals::PluralRules;

let fixed_decimal = "1000000.20".parse::<FixedDecimal>().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<&FixedDecimal> for PluralOperands

fn from(dec: &FixedDecimal) -> Self

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

impl From<i128> for PluralOperands

fn from(input: i128) -> Self

Converts to this type from the input type.

impl From<i16> for PluralOperands

fn from(input: i16) -> Self

Converts to this type from the input type.

impl From<i32> for PluralOperands

fn from(input: i32) -> Self

Converts to this type from the input type.

impl From<i64> for PluralOperands

fn from(input: i64) -> Self

Converts to this type from the input type.

impl From<i8> for PluralOperands

fn from(input: i8) -> Self

Converts to this type from the input type.

impl From<isize> for PluralOperands

fn from(input: isize) -> Self

Converts to this type from the input type.

impl From<u128> for PluralOperands

fn from(input: u128) -> Self

Converts to this type from the input type.

impl From<u16> for PluralOperands

fn from(input: u16) -> Self

Converts to this type from the input type.

impl From<u32> for PluralOperands

fn from(input: u32) -> Self

Converts to this type from the input type.

impl From<u64> for PluralOperands

fn from(input: u64) -> Self

Converts to this type from the input type.

impl From<u8> for PluralOperands

fn from(input: u8) -> Self

Converts to this type from the input type.

impl From<usize> for PluralOperands

fn from(input: usize) -> Self

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<Self, Self::Err>

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

impl PartialEq for PluralOperands

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

impl StructuralPartialEq for PluralOperands