Struct BoardRange

pub struct BoardRange<T>(/* private fields */);

A range on a board.

This range consists of four pieces of information: the minimum and maximum x-coordinate values and the minimum and maximum y-coordinate values. The type parameter T is used as the type of the x- and y-coordinate values.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
let min_x = range.x().start();
let max_x = range.x().end();
let min_y = range.y().start();
let max_y = range.y().end();
assert_eq!(min_x, &0);
assert_eq!(max_x, &2);
assert_eq!(min_y, &0);
assert_eq!(max_y, &1);

Implementations

impl<T> BoardRange<T>

pub fn new() -> Self

where T: Zero + One,

Creates an empty range.

Examples

use life_backend::BoardRange;
let range = BoardRange::<i32>::new();
assert!(range.is_empty());

pub const fn x(&self) -> &RangeInclusive<T>

Returns the range on the x-coordinate.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
assert_eq!(range.x(), &(0..=2));

pub const fn y(&self) -> &RangeInclusive<T>

Returns the range on the y-coordinate.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
assert_eq!(range.y(), &(0..=1));

pub fn into_inner(self) -> (RangeInclusive<T>, RangeInclusive<T>)

Destructures BoardRange into (range-x, range-y).

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
let (range_x, range_y) = range.into_inner();
assert_eq!(range_x, 0..=2);
assert_eq!(range_y, 0..=1);

pub fn is_empty(&self) -> bool

where T: PartialOrd,

Returns true if the range contains no area.

If the range is empty, return values of methods are defined as the following:

• range.is_empty() is true
• range.x().is_empty() and range.y().is_empty() are true
• range.x().start(), range.x().end(), range.y().start() and range.y().end() are unspecified

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
assert!(!range.is_empty());

Trait Implementations

impl<T: Clone> Clone for BoardRange<T>

fn clone(&self) -> BoardRange<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BoardRange<T>

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

Formats the value using the given formatter.

impl<T> Default for BoardRange<T>

where T: Zero + One,

fn default() -> Self

Returns the default value of the type, same as the return value of new().

impl<T> Display for BoardRange<T>

where T: PartialOrd + Display,

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

Formats the value using the given formatter.

impl<'a, T> Extend<&'a Position<T>> for BoardRange<T>

where T: Copy + PartialOrd + Zero + One + 'a,

fn extend<U>(&mut self, iter: U)

where U: IntoIterator<Item = &'a Position<T>>,

Extends the range with the contents of the specified non-owning iterator over the series of &Position<T>. Each item in the series represents an immutable reference of a position.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let mut range = BoardRange::new();
range.extend(positions.iter());
assert!(!range.is_empty());
assert_eq!(range.x(), &(0..=2));
assert_eq!(range.y(), &(0..=1));

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> Extend<Position<T>> for BoardRange<T>

where T: Copy + PartialOrd + Zero + One,

fn extend<U>(&mut self, iter: U)

where U: IntoIterator<Item = Position<T>>,

Extends the range with the contents of the specified owning iterator over the series of Position<T>. Each item in the series represents a moved position.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let mut range = BoardRange::new();
range.extend(positions.into_iter());
assert!(!range.is_empty());
assert_eq!(range.x(), &(0..=2));
assert_eq!(range.y(), &(0..=1));

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, T> FromIterator<&'a Position<T>> for BoardRange<T>

where T: Copy + PartialOrd + Zero + One + 'a,

fn from_iter<U>(iter: U) -> Self

where U: IntoIterator<Item = &'a Position<T>>,

Creates a value from a non-owning iterator over a series of &Position<T>. Each item in the series represents an immutable reference of a position to be contained to the range.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.iter().collect();
assert!(!range.is_empty());
assert_eq!(range.x(), &(0..=2));
assert_eq!(range.y(), &(0..=1));

impl<T> FromIterator<Position<T>> for BoardRange<T>

where T: Copy + PartialOrd + Zero + One,

fn from_iter<U>(iter: U) -> Self

where U: IntoIterator<Item = Position<T>>,

Creates a value from an owning iterator over a series of Position<T>. Each item in the series represents a moved position to be contained to the range.

Examples

use life_backend::{BoardRange, Position};
let positions = [Position(0, 0), Position(1, 0), Position(2, 0), Position(1, 1)];
let range: BoardRange<_> = positions.into_iter().collect();
assert!(!range.is_empty());
assert_eq!(range.x(), &(0..=2));
assert_eq!(range.y(), &(0..=1));

impl<T: PartialEq> PartialEq for BoardRange<T>

fn eq(&self, other: &BoardRange<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<T: Eq> Eq for BoardRange<T>

impl<T> StructuralPartialEq for BoardRange<T>