Struct Sign

pub struct Sign(pub i128);

Sign of a number.

Tuple Fields

0: i128

Trait Implementations

impl ChineseFormat for Sign

When converted to Chinese, a sign renders as follows:

• for positive numbers and zero: an empty string (thus omissible, too).

• for negative numbers:

  • 负 in Variant::Simplified script.

  • 負 in Variant::Traditional script.

use chinese_format::*;

//Positive numbers
assert_eq!(Sign(90).to_chinese(Variant::Simplified), Chinese {
    logograms: "".to_string(),
    omissible: true
});
assert_eq!(Sign(90).to_chinese(Variant::Traditional), "");

//Zero
assert_eq!(Sign(0).to_chinese(Variant::Simplified), Chinese {
    logograms: "".to_string(),
    omissible: true
});
assert_eq!(Sign(0).to_chinese(Variant::Traditional), "");

//Negative numbers
assert_eq!(Sign(-7).to_chinese(Variant::Simplified), Chinese {
    logograms: "负".to_string(),
    omissible: false
});
assert_eq!(Sign(-7).to_chinese(Variant::Traditional), "負");

fn to_chinese(&self, variant: Variant) -> Chinese

impl Clone for Sign

fn clone(&self) -> Sign

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Sign

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

Formats the value using the given formatter.

impl Hash for Sign

The hash depends uniquely on the sign of the underlying integer value.

use chinese_format::*;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

fn get_hash<T: Hash>(source: &T) -> u64 {
    let mut hasher = DefaultHasher::new();
    source.hash(&mut hasher);
    hasher.finish()
}

fn main() {
    assert_eq!(get_hash(&Sign(-54)), get_hash(&Sign(-7)));
    assert_eq!(get_hash(&Sign(0)), get_hash(&Sign(0)));
    assert_eq!(get_hash(&Sign(3)), get_hash(&Sign(90)));

    assert_ne!(get_hash(&Sign(-54)), get_hash(&Sign(0)));
    assert_ne!(get_hash(&Sign(0)), get_hash(&Sign(90)));
}

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Sign

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Sign

Sign instances are equal if the sign (+, - or 0) of their underlying numeric values are equal:

use chinese_format::*;

assert_eq!(Sign(-9), Sign(-3));
assert_eq!(Sign(0), Sign(0));
assert_eq!(Sign(13), Sign(90));

assert_ne!(Sign(-9), Sign(0));
assert_ne!(Sign(-9), Sign(7));
assert_ne!(Sign(0), Sign(-9));
assert_ne!(Sign(0), Sign(13));
assert_ne!(Sign(13), Sign(-9));
assert_ne!(Sign(13), Sign(0));

fn eq(&self, other: &Self) -> 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 PartialOrd for Sign

Sign instances are sorted in this order:

1. negative
2. zero
3. positive

The magnitude of the underlying integer values does not affect the comparison:

use chinese_format::*;

assert!(Sign(-90) == Sign(-4));
assert!(Sign(0) > Sign(-4));
assert!(Sign(0) < Sign(17));
assert!(Sign(17) == Sign(92));

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Sign

impl Eq for Sign