Struct bellframe::Stage

#[repr(transparent)]
pub struct Stage(_);

A newtype over usize that represents a stage.

To create a new Stage, you can either create it directly by using Stage::from(usize) or use a constant for the human name for each Stage:

use bellframe::Stage;

// Converting from numbers is the same as using the constants
assert_eq!(Stage::SINGLES, Stage::from(3));
assert_eq!(Stage::MAJOR, Stage::from(8));
assert_eq!(Stage::CINQUES, Stage::from(11));
assert_eq!(Stage::SIXTEEN, Stage::from(16));
// We can use `Stage::from` to generate `Stage`s that don't have names
assert_eq!(Stage::from(2).as_usize(), 2);
assert_eq!(Stage::from(100).as_usize(), 100);

Stages with names will also be Displayed as their names:

assert_eq!(&format!("{}", Stage::MAXIMUS), "Maximus");
assert_eq!(&format!("{}", Stage::from(9)), "Caters");

Implementations

impl Stage

pub fn as_usize(self) -> usize

Returns this Stage as a usize.

Example

use bellframe::Stage;

assert_eq!(Stage::DOUBLES.as_usize(), 5);
assert_eq!(Stage::MAXIMUS.as_usize(), 12);

pub fn is_even(self) -> bool

Returns true if this Stage has an even number of bells

pub fn from_lower_case_name(name: &str) -> Option<Stage>

Creates a Stage from the lower case version of the human-friendly name (e.g. "royal", "triples" or "twenty-two").

pub fn name(self) -> Option<&'static str>

Gets the human-friendly name of this Stage, as would be used in [Method] names (or None if self is too big to have a name).

impl Stage

User-friendly constants for commonly used Stages.

Example

use bellframe::Stage;

assert_eq!(Stage::MINIMUS, Stage::from(4));
assert_eq!(Stage::MINOR, Stage::from(6));
assert_eq!(Stage::TRIPLES, Stage::from(7));
assert_eq!(Stage::FOURTEEN, Stage::from(14));
assert_eq!(Stage::SEPTUPLES, Stage::from(15));

pub const ZERO: Stage

A Stage with no bells

pub const ONE: Stage

A Stage with 1 ‘working’ bell

pub const TWO: Stage

A Stage with 2 working bells

pub const SINGLES: Stage

A Stage with 3 working bells

pub const MINIMUS: Stage

A Stage with 4 working bells

pub const DOUBLES: Stage

A Stage with 5 working bells

pub const MINOR: Stage

A Stage with 6 working bells

pub const TRIPLES: Stage

A Stage with 7 working bells

pub const MAJOR: Stage

A Stage with 8 working bells

pub const CATERS: Stage

A Stage with 9 working bells

pub const ROYAL: Stage

A Stage with 10 working bells

pub const CINQUES: Stage

A Stage with 11 working bells

pub const MAXIMUS: Stage

A Stage with 12 working bells

pub const SEXTUPLES: Stage

A Stage with 13 working bells

pub const FOURTEEN: Stage

A Stage with 14 working bells

pub const SEPTUPLES: Stage

A Stage with 15 working bells

pub const SIXTEEN: Stage

A Stage with 16 working bells

Trait Implementations

impl Clone for Stage

fn clone(&self) -> Stage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Stage

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

Formats the value using the given formatter.

impl Display for Stage

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

Formats the value using the given formatter.

impl From<usize> for Stage

fn from(n: usize) -> Self

Performs the conversion.

impl Hash for Stage

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, 

Feeds a slice of this type into the given Hasher.

impl Ord for Stage

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<Stage> for Stage

fn eq(&self, other: &Stage) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Stage) -> bool

This method tests for !=.

impl PartialOrd<Stage> for Stage

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Stage

impl Eq for Stage

impl StructuralEq for Stage

impl StructuralPartialEq for Stage