Struct bellframe::Bell

#[repr(transparent)]
pub struct Bell { /* private fields */ }

A type-safe representation of a ‘bell’, which adds things like conversions to and from commonly-used bell names. Each Bell takes a single byte in memory.

Implementations

impl Bell

pub fn from_name(c: char) -> Option<Bell>

Creates a Bell from a char containing a bell name (e.g. '4' or 'T'). If the name is not valid, then this fails and returns None. Note that lower case chars are not considered valid bell names.

Example

use bellframe::Bell;

// Converting a valid name to a `Bell` and back should be the identity function
assert_eq!(Bell::from_name('1')?.name(), "1");
assert_eq!(Bell::from_name('5')?.name(), "5");
assert_eq!(Bell::from_name('0')?.name(), "0");
assert_eq!(Bell::from_name('T')?.name(), "T");
// Converting a lower-case letter should return `None`, even if the upper case
// version is valid
assert_eq!(Bell::from_name('e'), None);
assert_eq!(Bell::from_name('t'), None);
// Converting any old rubbish will return `None` (no shade on Ferris)
assert_eq!(Bell::from_name('\r'), None);
assert_eq!(Bell::from_name('🦀'), None);

pub fn from_index(index: u8) -> Bell

Creates a Bell from a 0-indexed integer.

Panics

Panics if 255 is passed (a Bell with index 255 would imply a Stage of 256, which cannot be created).

Example

use bellframe::Bell;

// A 'Bell' with index 0 is the treble
assert_eq!(Bell::from_index(0).name(), "1");
// A 'Bell' with index 11 is the '12' or 'T'
assert_eq!(Bell::from_index(11).name(), "T");

pub fn from_number(number: u8) -> Option<Bell>

Creates a Bell from a 1-indexed integer. This could fail if number is 0, so in that case None is returned.

Example

use bellframe::Bell;

// The `Bell` with number '12' is the 12th and should be displayed as 'T'
assert_eq!(Bell::from_number(12)?.name(), "T");
// Trying to create a Bell with number `0` fails:
assert_eq!(Bell::from_number(0), None);

pub fn tenor(stage: Stage) -> Bell

Creates the Bell representing the tenor or heaviest bell on a given Stage. This could fail if the Stage has no Bells, so in that case None is returned.

Example

use bellframe::{Bell, Stage};

// The **5** is the 'tenor' when ringing Doubles
assert_eq!(Bell::tenor(Stage::DOUBLES), Bell::from_number(5)?);
// The 12 is the tenor on maximus
assert_eq!(Bell::tenor(Stage::MAXIMUS), Bell::from_number(12)?);

pub const TREBLE: Bell = _

A Bell representing the ‘treble’ on any stage. Equivalent to Bell::from_name('1').unwrap().

Example

use bellframe::Bell;

// `TREBLE` should be the bell with name '1'
assert_eq!(Bell::from_name('1'), Some(Bell::TREBLE));
// The `TREBLE` has index 0, and its number is 1
assert_eq!(Bell::TREBLE.index(), 0);
assert_eq!(Bell::TREBLE.number(), 1);
// The treble should display as `"1"`
assert_eq!(Bell::TREBLE.name(), "1");

pub fn to_char(self) -> Option<char>

Converts this Bell into the char that it should be displayed as. If the Bell is too big to have a corresponding name, then None is returned.

Example

use bellframe::Bell;

// A 'Bell' with index 0 is the treble, and therefore displays as `1`
assert_eq!(Bell::from_index(0).to_char(), Some('1'));
// The 11th should display as 'E'
assert_eq!(Bell::from_number(11)?.to_char(), Some('E'));

// Trying to display the 100th Bell fails:
assert_eq!(Bell::from_number(100)?.to_char(), None);

pub fn index(self) -> usize

Returns the 0-indexed representation of this Bell.

Example

use bellframe::Bell;

// Creating a `Bell` with `from_index` should return the same index passed to it
assert_eq!(Bell::from_index(0).index(), 0);
assert_eq!(Bell::from_index(12).index(), 12);

assert_eq!(Bell::from_name('8')?.index(), 7);
assert_eq!(Bell::from_name('0')?.index(), 9);
assert_eq!(Bell::from_name('T')?.index(), 11);

pub fn index_u8(self) -> u8

Returns the 0-indexed representation of this Bell, as a u8.

Example

use bellframe::Bell;

// Creating a `Bell` with `from_index` should return the same index passed to it
assert_eq!(Bell::from_index(0).index_u8(), 0);
assert_eq!(Bell::from_index(12).index_u8(), 12);

assert_eq!(Bell::from_name('8')?.index_u8(), 7);
assert_eq!(Bell::from_name('0')?.index_u8(), 9);
assert_eq!(Bell::from_name('T')?.index_u8(), 11);

pub fn number(self) -> u8

Returns the 1-indexed representation of this Bell.

Example

use bellframe::Bell;

assert_eq!(Bell::from_index(0).number(), 1);
assert_eq!(Bell::from_name('0')?.number(), 10);
// Using `from_number` should return the same number that was passed to it
assert_eq!(Bell::from_number(4)?.number(), 4);
assert_eq!(Bell::from_number(10)?.number(), 10);

pub fn name(self) -> String

Converts this Bell into a String that it should be displayed as. Unlike to_char, this does not fail if the Bell is to big to have a name. Instead, it returns the 1-indexed ‘number’ of the Bell in angle brackets.

Example

use bellframe::Bell;

// Bells which are <= 9th should return their number as a `String`
assert_eq!(Bell::from_number(1)?.name(), "1");
assert_eq!(Bell::from_number(5)?.name(), "5");
assert_eq!(Bell::from_number(9)?.name(), "9");
// The 10th display as "0"
assert_eq!(Bell::from_number(10)?.name(), "0");
// Other bells display as their single-character names
assert_eq!(Bell::from_number(12)?.name(), "T");
assert_eq!(Bell::from_number(16)?.name(), "D");
// Anything too big simply displays as '<{bell.number()}>'
assert_eq!(Bell::from_number(100)?.name(), "<100>");

Trait Implementations

impl Add<u8> for Bell

type Output = Bell

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<u8> for Bell

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl Clone for Bell

fn clone(&self) -> Bell

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Bell

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

Formats the value using the given formatter.

impl Display for Bell

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

Formats the value using the given formatter.

impl Hash for Bell

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 Bell

fn cmp(&self, other: &Bell) -> 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 where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl PartialEq<Bell> for Bell

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

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

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

This method tests for !=.

impl PartialOrd<Bell> for Bell

fn partial_cmp(&self, other: &Bell) -> 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 Sub<u8> for Bell

type Output = Bell

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<u8> for Bell

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl Copy for Bell

impl Eq for Bell

impl StructuralEq for Bell

impl StructuralPartialEq for Bell