Struct sgf_parser::GameTree

pub struct GameTree {
    pub nodes: Vec<GameNode>,
    pub variations: Vec<GameTree>,
}

A game tree, containing it's nodes and possible variations following the last node

Fields

nodes: Vec<GameNode>

variations: Vec<GameTree>

Methods

impl GameTree

pub fn count_max_nodes(&self) -> usize

Counts number of nodes in the longest variation

pub fn get_unknown_nodes(&self) -> Vec<&GameNode>

Gets a vector of all nodes that contain a SgfToken::Unknown token

use sgf_parser::*;

let tree: GameTree = parse("(;B[dc];W[ef]TMP[foobar](;B[aa])(;B[cc];W[ee]))").unwrap();

let unknown_nodes = tree.get_unknown_nodes();
unknown_nodes.iter().for_each(|node| {
    let unknown_tokens = node.get_unknown_tokens();
    assert_eq!(unknown_tokens.len(), 1);
    if let SgfToken::Unknown((identifier, value)) = unknown_tokens[0] {
        assert_eq!(identifier, "TMP");
        assert_eq!(value, "foobar");
    }
});

pub fn get_invalid_nodes(&self) -> Vec<&GameNode>

Gets a vector of all nodes that contain a SgfToken::Invalid token

use sgf_parser::*;

let tree: GameTree = parse("(;B[dc];W[foobar];B[aa])(;B[cc];W[ee]))").unwrap();

let invalid_nodes = tree.get_invalid_nodes();
invalid_nodes.iter().for_each(|node| {
    let invalid_tokens = node.get_invalid_tokens();
    if let SgfToken::Invalid((identifier, value)) = invalid_tokens[0] {
        assert_eq!(identifier, "W");
        assert_eq!(value, "foobar");
    }
});

pub fn has_variations(&self) -> bool

Checks if this GameTree has any variations

pub fn count_variations(&self) -> usize

Counts number of variations in the GameTree

pub fn get_varation_length(&self, variation: usize) -> Result<usize, SgfError>

Get max length of a variation

use sgf_parser::*;

let tree: GameTree = parse("(;B[dc];W[ef](;B[aa])(;B[cc];W[ee]))").unwrap();

assert_eq!(tree.get_varation_length(0).unwrap(), 1);
assert_eq!(tree.get_varation_length(1).unwrap(), 2);

pub fn iter(&self) -> GameTreeIterator

Gets an iterator for the GameTree

use sgf_parser::*;

let tree: GameTree = parse("(;B[dc];W[ef](;B[aa])(;B[cc];W[ee]))").unwrap();

let mut iter = tree.iter();

assert_eq!(iter.count_variations(), 2);
assert!(iter.pick_variation(1).is_ok());

let mut count = 0;
iter.for_each(|node| {
    assert!(!node.tokens.is_empty());
    count += 1;
});

assert_eq!(count, tree.count_max_nodes());

Trait Implementations

impl PartialEq<GameTree> for GameTree

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

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

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

This method tests for !=.

impl Default for GameTree

fn default() -> Self

Creates an empty GameTree

impl Debug for GameTree

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

Formats the value using the given formatter.