Struct bellframe::place_not::PlaceNot

pub struct PlaceNot { /* fields omitted */ }

A single piece of place notation on any Stage.

Implementations

impl PlaceNot

pub fn parse(s: &str, stage: Stage) -> Result<Self, ParseError>

Parse a string, interpreting it as a single PlaceNot of a given Stage. Like Row::parse_with_stage, this ignores chars that don’t correspond to valid Bell names, including &, ., , and + which have reserved meanings in blocks of place notation. This will expand implicit places (even between two written places) but will fail if there is any kind of ambiguity, returning a ParseError describing the problem. This also runs in O(n) time except for sorting the places which takes O(n log n) time.

Example

use proj_core::{Stage, PlaceNot, place_not::ParseError};

// Parsing a valid place notation is OK
assert_eq!(PlaceNot::parse("14", Stage::MAJOR)?.to_string(), "14");
// Ordering and rogue chars don't matter
assert_eq!(PlaceNot::parse("  4|7~18", Stage::ROYAL)?.to_string(), "1478");
// Implicit places will be expanded
assert_eq!(PlaceNot::parse("467", Stage::MAXIMUS)?.to_string(), "14567T");

// Parsing invalid or ambiguous PN is not OK, and warns you of the problem
assert_eq!(
    PlaceNot::parse("14T", Stage::MAJOR).unwrap_err().to_string(),
    "Place 'T' is out stage Major"
);
assert_eq!(
    PlaceNot::parse("15", Stage::MAJOR).unwrap_err().to_string(),
    "Ambiguous gap of 3 bells between places '1' and '5'."
);

pub unsafe fn from_sorted_slice(
    parsed_places: &[usize],
    stage: Stage
) -> Result<Self, ParseError>

Creates a new PlaceNot from a sorted slice of places, performing bounds checks and returning errors if necessary.

Safety

This function is safe if parsed_places is sorted into increasing order

pub fn cross(stage: Stage) -> Option<Self>

Returns a new PlaceNot representing the ‘cross’ notation on a given stage. This will fail if stage doesn’t have an even number of bells.

Example

use proj_core::{PlaceNot, Stage};

// These are crosses
assert_eq!(
    PlaceNot::cross(Stage::MAJOR).unwrap(),
    PlaceNot::parse("x", Stage::MAJOR)?
);

pub fn is_cross(&self) -> bool

Checks if this PlaceNot corresponds to the ‘cross’ notation.

Example

use proj_core::{PlaceNot, Stage};

// These are crosses
assert!(PlaceNot::cross(Stage::MAJOR).unwrap().is_cross());
assert!(PlaceNot::parse("x", Stage::MAJOR)?.is_cross());
// These are not
assert!(!PlaceNot::parse("14", Stage::MAJOR)?.is_cross());
assert!(!PlaceNot::parse("3", Stage::TRIPLES)?.is_cross());

pub fn contains(&self, place: usize) -> bool

Checks whether a given place is made in this PlaceNot.

pub fn stage(&self) -> Stage

Returns the Stage of this PlaceNot

pub fn permute(&self, row: &mut Row) -> Result<(), IncompatibleStages>

Uses this PlaceNot to perform an in-place permutation of a given Row. If you want to to preserve the old Row, then use permute_new.

pub unsafe fn permute_unchecked(&self, row: &mut Row)

Uses this PlaceNot to perform an in-place permutation of a given Row, without checking that the Stages match. If you want to to preserve the old Row, then use permute_new_unchecked.

Safety

This function is safe to use only when self.stage() == row.stage().

pub fn permute_new(&self, row: &Row) -> Result<Row, IncompatibleStages>

Uses this PlaceNot to permute a given Row, preserving the old copy and returning a new Row. This checks that the Stages are equal, and is therefore safe.

pub unsafe fn permute_new_unchecked(&self, row: &Row) -> Row

Uses this PlaceNot to permute a given Row, preserving the old copy and returning a new Row.

Safety

This function is safe to use only when self.stage() == row.stage().

Trait Implementations

impl Clone for PlaceNot

fn clone(&self) -> PlaceNot

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PlaceNot

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

Formats the value using the given formatter.

impl Display for PlaceNot

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

Formats the value using the given formatter.

impl Hash for PlaceNot

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 PartialEq<PlaceNot> for PlaceNot

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

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

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

This method tests for !=.

impl Eq for PlaceNot

impl StructuralEq for PlaceNot

impl StructuralPartialEq for PlaceNot