Enum sgf_parser::SgfToken

pub enum SgfToken {
    Add {
        color: Color,
        coordinate: (u8, u8),
    },
    Move {
        color: Color,
        action: Action,
    },
    Time {
        color: Color,
        time: u32,
    },
    PlayerName {
        color: Color,
        name: String,
    },
    PlayerRank {
        color: Color,
        rank: String,
    },
    Result(Outcome),
    Komi(f32),
    Event(String),
    Copyright(String),
    GameName(String),
    Place(String),
    Date(String),
    Size(u32, u32),
    TimeLimit(u32),
    Handicap(u32),
    Comment(String),
    Unknown((String, String)),
    Invalid((String, String)),
    Square {
        coordinate: (u8, u8),
    },
    Triangle {
        coordinate: (u8, u8),
    },
    Label {
        label: String,
        coordinate: (u8, u8),
    },
}

Enum describing all possible SGF Properties

Variants

Add

Fields of Add

color: Colorcoordinate: (u8, u8)

Move

Fields of Move

color: Coloraction: Action

Time

Fields of Time

color: Colortime: u32

PlayerName

Fields of PlayerName

color: Colorname: String

PlayerRank

Fields of PlayerRank

color: Colorrank: String

Result(Outcome)

Komi(f32)

Event(String)

Copyright(String)

GameName(String)

Place(String)

Date(String)

Size(u32, u32)

TimeLimit(u32)

Handicap(u32)

Comment(String)

Unknown((String, String))

Invalid((String, String))

Square

Fields of Square

coordinate: (u8, u8)

Triangle

Fields of Triangle

coordinate: (u8, u8)

Label

Fields of Label

label: Stringcoordinate: (u8, u8)

Methods

impl SgfToken

pub fn from_pair(base_ident: &str, value: &str) -> SgfToken

Converts a identifier and value pair to a SGF token

Returns SgfToken::Unknown((identifier, value)) for tokens without a matching identifier

Returns SgfToken::Invalid((identifier, value)) for tokens with a matching identifier, but invalid value

use sgf_parser::*;

let token = SgfToken::from_pair("B", "aa");
assert_eq!(token, SgfToken::Move { color: Color::Black, action: Action::Move(1, 1) });

let token = SgfToken::from_pair("B", "");
assert_eq!(token, SgfToken::Move { color: Color::Black, action: Action::Pass });

let token = SgfToken::from_pair("B", "not_coord");
assert_eq!(token, SgfToken::Invalid(("B".to_string(), "not_coord".to_string())));

let token = SgfToken::from_pair("FOO", "aa");
assert_eq!(token, SgfToken::Unknown(("FOO".to_string(), "aa".to_string())));

pub fn is_root_token(&self) -> bool

Checks if the token is a root token as defined by the SGF spec.

Root tokens can only occur in the root of a gametree collection, and they are invalid anywhere else

use sgf_parser::*;

let token = SgfToken::from_pair("B", "aa");
assert!(!token.is_root_token());

let token = SgfToken::from_pair("SZ", "19");
assert!(token.is_root_token());

Trait Implementations

impl<'_> Into<String> for &'_ SgfToken

fn into(self) -> String

Performs the conversion.

impl Into<String> for SgfToken

fn into(self) -> String

Performs the conversion.

impl Clone for SgfToken

fn clone(&self) -> SgfToken

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq<SgfToken> for SgfToken

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

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

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

This method tests for !=.

impl Debug for SgfToken

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

Formats the value using the given formatter.