Enum pgn_reader::San

pub enum San {
    Normal {
        role: Role,
        file: Option<File>,
        rank: Option<Rank>,
        capture: bool,
        to: Square,
        promotion: Option<Role>,
    },
    Castle(CastlingSide),
    Put {
        role: Role,
        to: Square,
    },
    Null,
}

A move in Standard Algebraic Notation.

Variants

Normal

Fields of Normal

role: Rolefile: Option<File>rank: Option<Rank>capture: boolto: Squarepromotion: Option<Role>

Castle(CastlingSide)

Tuple Fields of Castle

0: CastlingSide

Put

Fields of Put

role: Roleto: Square

Null

Implementations

impl San

pub fn from_ascii(san: &[u8]) -> Result<San, ParseSanError>

Parses a SAN. Ignores a possible check or checkmate suffix.

Errors

Returns ParseSanError if san is not syntactically valid.

pub fn from_move<P>(pos: &P, m: &Move) -> San where
    P: Position, 

Converts a move to Standard Algebraic Notation.

pub fn to_move<P>(&self, pos: &P) -> Result<Move, SanError> where
    P: Position, 

Tries to convert the San to a legal move in the context of a position.

Errors

Returns SanError if there is no unique matching legal move.

pub fn disambiguate(m: &Move, moves: &ArrayVec<Move, {_: usize}>) -> San

pub fn find_move(
    &self,
    moves: &'a ArrayVec<Move, {_: usize}>
) -> Result<&'a Move, SanError>

Searches a MoveList for a unique matching move.

Errors

Returns SanError if there is no unique matching legal move.

pub fn matches(&self, m: &Move) -> bool

Test if the San can match the Move (in any position).

Examples

use shakmaty::{Square, Role, Move};
use shakmaty::san::San;

let m = Move::Normal {
    role: Role::Knight,
    from: Square::G1,
    to: Square::F3,
    capture: None,
    promotion: None,
};

let nf3 = San::from_ascii(b"Nf3")?;
assert!(nf3.matches(&m));

let ng1f3 = San::from_ascii(b"Ng1f3")?;
assert!(ng1f3.matches(&m));

// capture does not match
let nxf3 = San::from_ascii(b"Nxf3")?;
assert!(!nxf3.matches(&m));

// other file does not match
let nef3 = San::from_ascii(b"Nef3")?;
assert!(!nef3.matches(&m));

Trait Implementations

impl Clone for San

pub fn clone(&self) -> San

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for San

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

Formats the value using the given formatter.

impl Display for San

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

Formats the value using the given formatter.

impl FromStr for San

type Err = ParseSanError

The associated error which can be returned from parsing.

pub fn from_str(san: &str) -> Result<San, ParseSanError>

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

impl Hash for San

pub 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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<San> for San

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

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

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

This method tests for !=.

impl Eq for San

impl StructuralEq for San

impl StructuralPartialEq for San