Struct Letter 

pub struct Letter(/* private fields */);

The single-letter abbreviation of a player style.

A Letter is the identity part of a SIN token, independent of side. Per the specification the abbreviation is case-insensitive (C and c denote the same style), so a Letter is always stored uppercase; the case of the original token is carried separately by Side.

Invariant

The wrapped byte is always an uppercase ASCII letter (b'A'..=b'Z'). Every constructor enforces this, so the invariant cannot be violated from outside the crate.

Ordering is alphabetical (A < B < … < Z).

Implementations

impl Letter

pub const ALL: [Self; 26]

Every abbreviation, in alphabetical order (A through Z).

pub const fn from_ascii(byte: u8) -> Option<(Self, Side)>

Decodes a raw ASCII byte into a Letter and the Side its case implies.

Returns None for any byte that is not an ASCII letter. This is the lossless decoder used by the token parser.

Examples

use sashite_sin::{Letter, Side};

let (letter, side) = Letter::from_ascii(b'c').unwrap();
assert_eq!(letter.as_char(), 'C');
assert_eq!(side, Side::Second);

assert!(Letter::from_ascii(b'1').is_none());

pub const fn try_from_char(c: char) -> Result<Self, ParseError>

Builds a Letter from a char, folding case.

Both 'C' and 'c' yield the same Letter; the case (which encodes side) is not retained.

Errors

Returns ParseError::InvalidLetter if c is not an ASCII letter.

Examples

use sashite_sin::Letter;

assert_eq!(Letter::try_from_char('j').unwrap().as_char(), 'J');
assert!(Letter::try_from_char('+').is_err());

pub const fn as_char(self) -> char

Returns the abbreviation as an uppercase char.

pub const fn as_ascii(self) -> u8

Returns the abbreviation as its raw uppercase ASCII byte.

Trait Implementations

impl Clone for Letter

fn clone(&self) -> Letter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Letter

impl Debug for Letter

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

Formats the value using the given formatter.

impl Eq for Letter

impl Hash for Letter

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 Letter

fn cmp(&self, other: &Letter) -> 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 Letter

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

fn partial_cmp(&self, other: &Letter) -> 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 StructuralPartialEq for Letter

impl TryFrom<char> for Letter

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(c: char) -> Result<Self, Self::Error>

Performs the conversion.