Enum pgn_reader::Square

pub enum Square {
    A1,
    B1,
    C1,
    D1,
    E1,
    F1,
    G1,
    H1,
    A2,
    B2,
    C2,
    D2,
    E2,
    F2,
    G2,
    H2,
    A3,
    B3,
    C3,
    D3,
    E3,
    F3,
    G3,
    H3,
    A4,
    B4,
    C4,
    D4,
    E4,
    F4,
    G4,
    H4,
    A5,
    B5,
    C5,
    D5,
    E5,
    F5,
    G5,
    H5,
    A6,
    B6,
    C6,
    D6,
    E6,
    F6,
    G6,
    H6,
    A7,
    B7,
    C7,
    D7,
    E7,
    F7,
    G7,
    H7,
    A8,
    B8,
    C8,
    D8,
    E8,
    F8,
    G8,
    H8,
}

A square index.

Variants

A1

B1

C1

D1

E1

F1

G1

H1

A2

B2

C2

D2

E2

F2

G2

H2

A3

B3

C3

D3

E3

F3

G3

H3

A4

B4

C4

D4

E4

F4

G4

H4

A5

B5

C5

D5

E5

F5

G5

H5

A6

B6

C6

D6

E6

F6

G6

H6

A7

B7

C7

D7

E7

F7

G7

H7

A8

B8

C8

D8

E8

F8

G8

H8

Implementations

impl Square

pub fn new(index: i8) -> Square

Gets a Square from an integer index.

Panics

Panics if the index is not in the range 0..=63.

Examples

use shakmaty::Square;

assert_eq!(Square::new(0), Square::A1);
assert_eq!(Square::new(63), Square::H8);

pub fn from_index(index: i8) -> Option<Square>

Tries to get a Square from an integer index in the range 0..=63.

Examples

use shakmaty::Square;

assert_eq!(Square::from_index(0), Some(Square::A1));
assert_eq!(Square::from_index(63), Some(Square::H8));

assert_eq!(Square::from_index(64), None);

pub unsafe fn from_index_unchecked(index: i8) -> Square

Gets a Square from an integer index.

Unsafety

It is the callers responsibility to ensure it is in the range 0..=63.

pub fn from_coords(file: File, rank: Rank) -> Square

Tries to get a square from file and rank.

Examples

use shakmaty::{Square, File, Rank};

assert_eq!(Square::from_coords(File::A, Rank::First), Square::A1);

pub fn from_ascii(s: &[u8]) -> Result<Square, ParseSquareError>

Parses a square name.

Errors

Returns ParseSquareError if the input is not a valid square name in lowercase ASCII characters.

Example

use shakmaty::Square;

let sq = Square::from_ascii(b"a5")?;
assert_eq!(sq, Square::A5);

pub fn file(self) -> File

Gets the file.

Examples

use shakmaty::{Square, File};

assert_eq!(Square::A1.file(), File::A);
assert_eq!(Square::B2.file(), File::B);

pub fn rank(self) -> Rank

Gets the rank.

Examples

use shakmaty::{Square, Rank};

assert_eq!(Square::A1.rank(), Rank::First);
assert_eq!(Square::B2.rank(), Rank::Second);

pub fn offset(self, delta: i8) -> Option<Square>

Calculates the offset from a square index.

Examples

use shakmaty::Square;

assert_eq!(Square::F3.offset(8), Some(Square::F4));
assert_eq!(Square::F3.offset(-1), Some(Square::E3));

assert_eq!(Square::F3.offset(48), None);

pub fn flip_horizontal(self) -> Square

Flip the square horizontally.

use shakmaty::Square;

assert_eq!(Square::H1.flip_horizontal(), Square::A1);
assert_eq!(Square::D3.flip_horizontal(), Square::E3);

pub fn flip_vertical(self) -> Square

Flip the square vertically.

use shakmaty::Square;

assert_eq!(Square::A8.flip_vertical(), Square::A1);
assert_eq!(Square::D3.flip_vertical(), Square::D6);

pub fn flip_diagonal(self) -> Square

Flip at the a1-h8 diagonal by swapping file and rank.

use shakmaty::Square;

assert_eq!(Square::A1.flip_diagonal(), Square::A1);
assert_eq!(Square::A3.flip_diagonal(), Square::C1);

pub fn is_light(self) -> bool

Tests is the square is a light square.

use shakmaty::Square;

assert!(Square::D1.is_light());
assert!(!Square::D8.is_light());

pub fn is_dark(self) -> bool

Tests is the square is a dark square.

use shakmaty::Square;

assert!(Square::E1.is_dark());
assert!(!Square::E8.is_dark());

pub fn distance(self, other: Square) -> i8

The distance between the two squares, i.e. the number of king steps to get from one square to the other.

use shakmaty::Square;

assert_eq!(Square::A2.distance(Square::B5), 3);

pub fn combine(self, rank: Square) -> Square

Combines two squares, taking the file from the first and the rank from the second.

use shakmaty::Square;

assert_eq!(Square::D3.combine(Square::F5), Square::D5);

Trait Implementations

impl Clone for Square

fn clone(&self) -> Square

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Square

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

Formats the value using the given formatter.

impl Display for Square

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

Formats the value using the given formatter.

impl From<(File, Rank)> for Square

fn from(_: (File, Rank)) -> Square

Converts to this type from the input type.

impl FromStr for Square

type Err = ParseSquareError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Square, ParseSquareError>

Parses a string s to return a value of this type.

impl Hash for Square

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

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 Square

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Square> for Square

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Square> for Square

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

type Output = i8

The resulting type after applying the - operator.

fn sub(self, other: Square) -> i8

Performs the - operation.

impl Copy for Square

impl Eq for Square

impl StructuralEq for Square

impl StructuralPartialEq for Square