Struct sgf_parse::SgfNode

pub struct SgfNode { /* fields omitted */ }

A node in an SGF Game Tree.

Implementations

impl SgfNode

pub fn new(
    props: Vec<SgfProp>,
    children: Vec<SgfNode>,
    is_root: bool
) -> Result<SgfNode, SgfParseError>

pub fn get_property(&self, identifier: &str) -> Option<&SgfProp>

Returns the property with the provided identifier for the node (if present).

Examples

use sgf_parse::{parse, SgfProp};

let node = parse("(;SZ[13:13];B[de])").unwrap().into_iter().next().unwrap();
let board_size = match node.get_property("SZ") {
    Some(SgfProp::SZ(size)) => size.clone(),
    None => (19, 19),
    _ => unreachable!(),
};

pub fn children<'a>(&'a self) -> impl Iterator<Item = &SgfNode> + 'a

Returns an iterator over the children of this node.

Examples

use sgf_parse::parse;

let node = parse("(;SZ[19](;B[de])(;B[dd]HO[2]))").unwrap().into_iter().next().unwrap();
for child in node.children() {
    if let Some(prop) = child.get_property("HO") {
       println!("Found a hotspot!")
    }
}

pub fn properties<'a>(&'a self) -> impl Iterator<Item = &SgfProp> + 'a

Returns an iterator over the properties of this node.

Examples

use sgf_parse::{parse, SgfProp, Move};

let node = parse("(;B[de]C[A comment])").unwrap().into_iter().next().unwrap();
for prop in node.properties() {
    match prop {
        SgfProp::B(mv) => match mv {
            Move::Move(p) => println!("B Move at {}, {}", p.x, p.y),
            Move::Pass => println!("B Pass"),
        }
        SgfProp::W(mv) => match mv {
            Move::Move(p) => println!("W Move at {}, {}", p.x, p.y),
            Move::Pass => println!("W Pass"),
        }
        _ => {},
    }
}

Trait Implementations

impl Clone for SgfNode

fn clone(&self) -> SgfNode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SgfNode

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

Formats the value using the given formatter.

impl IntoIterator for SgfNode

type Item = SgfNode

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.