icu_decimal 2.3.0

API for formatting basic decimal numbers in a locale-sensitive way
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use fixed_decimal::UnsignedDecimal;
use icu_plurals::PluralOperands;
use writeable::Writeable;

use crate::{
    CompactDecimalFormatter, DecimalFormatter, FormattedSign, FormattedUnsignedCompactDecimal,
    FormattedUnsignedDecimal,
};

pub trait Sealed {}

/// A trait representing an abstract number formatter.
///
/// This is a building block for more complicated formatters, like currency or units.
///
/// <div class="stab unstable">
/// 🚫 This trait is sealed; it cannot be implemented by user code. If an API requests an item that implements this
/// trait, please consider using a type from the implementors listed below.
/// </div>
pub trait AbstractFormatter: core::fmt::Debug + Sealed {
    #[doc(hidden)]
    type FormattedUnsigned<'a>: Writeable
    where
        Self: 'a;

    #[doc(hidden)]
    fn format_unsigned<'a>(&'a self, value: UnsignedDecimal) -> Self::FormattedUnsigned<'a>;

    #[doc(hidden)]
    fn format_sign<'a, W: Writeable>(
        &'a self,
        value: W,
        sign: fixed_decimal::Sign,
    ) -> FormattedSign<'a, W>;

    #[doc(hidden)]
    fn plural_operands(value: &Self::FormattedUnsigned<'_>) -> PluralOperands;
}

impl Sealed for DecimalFormatter {}
impl AbstractFormatter for DecimalFormatter {
    type FormattedUnsigned<'a> = FormattedUnsignedDecimal<'a>;

    fn format_unsigned<'a>(&'a self, value: UnsignedDecimal) -> Self::FormattedUnsigned<'a> {
        self.format_unsigned(crate::Cow::Owned(value))
    }

    fn format_sign<'a, W: Writeable>(
        &'a self,
        value: W,
        sign: fixed_decimal::Sign,
    ) -> FormattedSign<'a, W> {
        self.format_sign(sign, value)
    }

    fn plural_operands(value: &Self::FormattedUnsigned<'_>) -> PluralOperands {
        value.plural_operands()
    }
}

impl Sealed for CompactDecimalFormatter {}
impl AbstractFormatter for CompactDecimalFormatter {
    type FormattedUnsigned<'a> = FormattedUnsignedCompactDecimal<'a>;

    fn format_unsigned<'a>(&'a self, value: UnsignedDecimal) -> Self::FormattedUnsigned<'a> {
        self.format_unsigned(&value)
    }

    fn format_sign<'a, W: Writeable>(
        &'a self,
        value: W,
        sign: fixed_decimal::Sign,
    ) -> FormattedSign<'a, W> {
        self.decimal_formatter.format_sign(sign, value)
    }

    fn plural_operands(value: &Self::FormattedUnsigned<'_>) -> PluralOperands {
        value.plural_operands()
    }
}