Enum Token

pub enum Token<'a> {
    Unknown(&'a str),
    Application(&'a str),
    Comment(&'a str),
    Copyright(&'a str),
    BlackName(&'a str),
    WhiteName(&'a str),
    BlackTeam(&'a str),
    WhiteTeam(&'a str),
    BoardSize(usize, usize),
    Variation(Base<'a>),
    FileFormat(usize),
    GameType(usize),
    Charset(&'a str),
    VariationShown(usize),
    WhoseTurn(Player),
    BlackStones(Vec<Point<'a>>),
    WhiteStones(Vec<Point<'a>>),
    BlackMove(Move<'a>),
    WhiteMove(Move<'a>),
    BlackPlayerRank(&'a str),
    WhitePlayerRank(&'a str),
    Source(&'a str),
    GameName(&'a str),
    NodeName(&'a str),
    Rule(&'a str),
    Komi(f32),
    PersonWhoProvidesAnnotations(&'a str),
    DrawArrow(PointRange<'a>),
    DrawCircle(Vec<Point<'a>>),
    DrawSquare(Vec<Point<'a>>),
    DrawTriangle(Vec<Point<'a>>),
    GreyOut(Vec<Point<'a>>),
    MarkX(Vec<Point<'a>>),
    Handicap(usize),
    Result(&'a str),
    Figure(Option<Figure<'a>>),
    Printing(usize),
    TimeLimit(usize),
    Date(&'a str),
    Event(&'a str),
    PointText(Vec<PointText<'a>>),
    Round(&'a str),
    SGFCreator(&'a str),
    ViewOnly(Vec<PointRange<'a>>),
    MoveNumber(usize),
}

Variants

Unknown(&'a str)

Application(&'a str)

Property: AP

Comment(&'a str)

Property: C

Copyright(&'a str)

Property: CP

BlackName(&'a str)

Property: PB

WhiteName(&'a str)

Property: PW

BlackTeam(&'a str)

Property: BT

WhiteTeam(&'a str)

Property: WT

BoardSize(usize, usize)

Property: SZ

Variation(Base<'a>)

Variation

FileFormat(usize)

Property: FF

GameType(usize)

Property: GM

Charset(&'a str)

Property: CA

VariationShown(usize)

Property: ST

WhoseTurn(Player)

Property: PL

BlackStones(Vec<Point<'a>>)

Property: AB

WhiteStones(Vec<Point<'a>>)

Property: AW

BlackMove(Move<'a>)

Property: B

WhiteMove(Move<'a>)

Property: W

BlackPlayerRank(&'a str)

Property: BR

WhitePlayerRank(&'a str)

Property: WR

Source(&'a str)

Property: SO

GameName(&'a str)

Property: GN

NodeName(&'a str)

Property: N

Rule(&'a str)

Property: RU

Komi(f32)

Property: KM

PersonWhoProvidesAnnotations(&'a str)

Property: AN

DrawArrow(PointRange<'a>)

Property: AR

DrawCircle(Vec<Point<'a>>)

Property: CR

DrawSquare(Vec<Point<'a>>)

Property: SQ

DrawTriangle(Vec<Point<'a>>)

Property: TR

GreyOut(Vec<Point<'a>>)

Property: DD

MarkX(Vec<Point<'a>>)

Property: MA

Handicap(usize)

Property: HA

Result(&'a str)

Property: RE

Figure(Option<Figure<'a>>)

Property: FG

Printing(usize)

Property: PM

TimeLimit(usize)

Property: TM

Date(&'a str)

Property: DT

Event(&'a str)

Property: AV

PointText(Vec<PointText<'a>>)

Property: LB

Round(&'a str)

Property: RO

SGFCreator(&'a str)

Property: US

ViewOnly(Vec<PointRange<'a>>)

Property: VW

MoveNumber(usize)

Property: MN

Trait Implementations

impl Builder for Token<'_>

fn build(&self, buffer: &mut String) -> Result<(), SgfToolError>

impl<'a> Clone for Token<'a>

fn clone(&self) -> Token<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Token<'a>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a> Deserialize<'de> for Token<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> EnumMessage for Token<'a>

fn get_message(&self) -> Option<&'static str>

fn get_detailed_message(&self) -> Option<&'static str>

fn get_documentation(&self) -> Option<&'static str>

Get the doc comment associated with a variant if it exists.

fn get_serializations(&self) -> &'static [&'static str]

impl<'a, '_enum> From<&'_enum Token<'a>> for TokenType

fn from(val: &'_enum Token<'a>) -> TokenType

Converts to this type from the input type.

impl<'a> From<Token<'a>> for TokenType

fn from(val: Token<'a>) -> TokenType

Converts to this type from the input type.

impl<'a> PartialEq for Token<'a>

fn eq(&self, other: &Token<'a>) -> bool

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

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<'a> Serialize for Token<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for Token<'a>