Struct yaml_peg::Node

pub struct Node {
    pub pos: u64,
    pub ty: String,
    pub anchor: String,
    pub yaml: Yaml,
}

Parser node, includes line number, column number, type assertion and anchor.

This type will ignore additional members when comparison and hashing.

use std::collections::HashSet;
use yaml_peg::Node;
let mut s = HashSet::new();
s.insert(Node::new("a".into()).pos(0));
s.insert(Node::new("a".into()).pos(1));
s.insert(Node::new("a".into()).pos(2));
assert_eq!(s.len(), 1);

There is a convenient macro node! to create nodes literally.

Nodes can be indexing by usize or &str, but it will always return self if the index is not contained.

use yaml_peg::node;
let n = node!(null);
assert_eq!(n["a"][0]["bc"], n);

There are as_* methods provide Result<T, u64> returns with node position, default options can be created by Result::unwrap_or, additional error message can be attach by Result::map_err, and the optional Option can be return by Result::ok, which shown as following example:

use yaml_peg::node;

fn main() -> Result<(), (&'static str, u64)> {
    let n = node!({
        node!("title") => node!(12.)
    });
    let n = n.get(&["title"]).map_err(|p| ("missing \"title\"", p))?;
    assert_eq!(
        Err(("title", 0)),
        n.as_str().map_err(|p| ("title", p))
    );
    assert_eq!(
        Option::<&str>::None,
        n.as_str().ok()
    );
    Ok(())
}

Fields

pos: u64

Document position

ty: String

Type assertion

anchor: String

Anchor reference

yaml: Yaml

YAML data

Implementations

impl Node

pub fn new(yaml: Yaml) -> Self

Create node from YAML data.

pub fn pos(self, pos: u64) -> Self

Builder function for position.

pub fn ty(self, ty: String) -> Self

Builder function for type assertion.

pub fn anchor(self, anchor: String) -> Self

Builder function for anchor annotation.

pub fn is_null(&self) -> bool

Check the value is null.

pub fn as_bool(&self) -> Result<bool, u64>

Convert to boolean.

use yaml_peg::{node};
assert!(node!(true).as_bool().unwrap());

pub fn as_int<N>(&self) -> Result<N, u64> where
    N: FromStr, 

Convert to integer.

use yaml_peg::node;
assert_eq!(60, node!(60).as_int().unwrap());

pub fn as_float<N>(&self) -> Result<N, u64> where
    N: FromStr, 

Convert to float.

use yaml_peg::node;
assert_eq!(20.06, node!(20.06).as_float().unwrap());

pub fn as_number<N>(&self) -> Result<N, u64> where
    N: FromStr, 

Convert to number.

use yaml_peg::node;
assert_eq!(60, node!(60).as_number().unwrap());
assert_eq!(20.06, node!(20.06).as_number().unwrap());

pub fn as_str(&self) -> Result<&str, u64>

Convert to string pointer.

This method allows null, it represented as empty string. You can check them by str::is_empty.

use yaml_peg::node;
assert_eq!("abc", node!("abc").as_str().unwrap());
assert!(node!(null).as_str().unwrap().is_empty());

pub fn as_value(&self) -> Result<&str, u64>

Convert to string pointer for string, null, int, and float type.

This method is useful when the option mixed with digit values.

use yaml_peg::node;
assert_eq!("abc", node!("abc").as_value().unwrap());
assert_eq!("123", node!(123).as_value().unwrap());
assert!(node!(null).as_value().unwrap().is_empty());

pub fn as_anchor(&self) -> Result<&str, u64>

Convert to the string pointer of an anchor.

use yaml_peg::node;
assert_eq!("abc", node!(*("abc")).as_anchor().unwrap());

pub fn as_array(&self) -> Result<&Array, u64>

Convert to array.

WARNING: The object ownership will be took.

use yaml_peg::node;
assert_eq!(
    &vec![node!(1), node!(2)],
    node!([node!(1), node!(2)]).as_array().unwrap()
);

pub fn as_map(&self) -> Result<&Map, u64>

Convert to map.

WARNING: The object ownership will be took.

use yaml_peg::node;
assert_eq!(
    &node!(2),
    node!({node!(1) => node!(2)}).as_map().unwrap().get(&node!(1)).unwrap()
);

pub fn get<Y>(&self, keys: &[Y]) -> Result<&Self, u64> where
    Y: Into<Yaml> + Copy, 

Convert to map and try to get the value by keys recursivly.

If get failed, returns Option::None.

use yaml_peg::node;
assert_eq!(
    &node!(30.),
    node!({node!("a") => node!({node!("b") => node!(30.)})}).get(&["a", "b"]).unwrap()
);

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Dumper for Node

fn dump(&self, level: usize, wrap: bool) -> String

Recursive dump function.

fn ind(level: usize) -> String

Generate indentation.

impl FromIterator<Node> for Yaml

fn from_iter<T>(iter: T) -> Self where
    T: IntoIterator<Item = Node>, 

Creates a value from an iterator.

impl Hash for Node

fn hash<H: Hasher>(&self, state: &mut H)

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 Index<&'_ str> for Node

type Output = Self

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for Node

type Output = Self

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl PartialEq<Node> for Node

fn eq(&self, rhs: &Self) -> bool

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

#[must_use]

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

This method tests for !=.

impl Eq for Node

impl StructuralEq for Node