Struct Stage 

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

A newtype over u8 that represents a stage. All Stages must contain at least one Bell; zero-bell Stages cannot be created without using incorrect unsafe code.

To create a new Stage, you can either create it directly with Stage::try_from (which returns a Result) or with Stage::new (which panics if passed 0).

If you want a specific small Stage, then you can use the constants 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::new(3));
assert_eq!(Stage::MAJOR, Stage::new(8));
assert_eq!(Stage::CINQUES, Stage::new(11));
assert_eq!(Stage::SIXTEEN, Stage::new(16));
// We can use `Stage::from` to generate `Stage`s that don't have names
assert_eq!(Stage::new(100).num_bells(), 100);
assert_eq!(Stage::new(254).num_bells(), 254);

Stages with human-friendly names are Displayed as their names:

assert_eq!(Stage::MAXIMUS.to_string(), "Maximus");
assert_eq!(Stage::new(9).to_string(), "Caters");
assert_eq!(Stage::new(50).to_string(), "50 bells");

Implementations

impl Stage

pub fn new(num_bells: u8) -> Stage

Creates a new Stage representing a given number of Bells.

Panics

Panics if num_bells is zero.

pub fn num_bells(self) -> usize

The number of Bells in this Stage. This is guaranteed to be non-zero.

Example

use bellframe::Stage;

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

pub fn num_bells_u8(self) -> u8

The number of Bells in this Stage as a u8. This is guaranteed to be non-zero.

Example

use bellframe::Stage;

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

pub fn tenor(self) -> Bell

Returns the highest numbered Bell in this Stage

pub fn bells(self) -> impl DoubleEndedIterator<Item = Bell>

Gets an Iterator over the Bells contained within this Stage, in increasing order.

pub fn contains(self, bell: Bell) -> bool

Returns true if a given Bell is contained in this Stage.

pub fn is_even(self) -> bool

Returns true if this Stage denotes 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).

pub fn checked_add(self, rhs: u8) -> Option<Self>

pub fn checked_sub(self, rhs: u8) -> Option<Self>

pub fn extent(self) -> SameStageVec

Returns a SameStageVec containing one copy of every Row possible in this Stage in some arbitrary order.

impl Stage

User-friendly constants for commonly used Stages.

Example

use bellframe::Stage;

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

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 Add<u8> for Stage

type Output = Stage

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl Clone for Stage

fn clone(&self) -> Stage

Returns a duplicate 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 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, Self: Sized,

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

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 Stage

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

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 Sub<u8> for Stage

type Output = Stage

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl TryFrom<u8> for Stage

type Error = ZeroStageError

The type returned in the event of a conversion error.

fn try_from(num_bells: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for Stage

impl Eq for Stage

impl StructuralPartialEq for Stage