Struct yaml_peg::NodeBase

pub struct NodeBase<R: Repr>(_);

Readonly node, including line number, column number, type assertion and anchor. You can access YamlBase type through NodeBase::yaml method.

This type will ignore additional information when comparison and hashing.

use std::collections::HashSet;
use yaml_peg::Node;
let mut s = HashSet::new();
s.insert(Node::new("a".into(), 0, "", ""));
s.insert(Node::new("a".into(), 1, "my-type", ""));
s.insert(Node::new("a".into(), 2, "", "my-anchor"));
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(())
}

For default value on map type, NodeBase::get method has a shorten method NodeBase::get_default to combining transform function and default function as well.

Clone

Since the YAML data is wrapped by reference counter std::rc::Rc and std::sync::Arc, cloning node just increase the reference counter, the entire data structure are still shared together.

If you want to copy data, please get the data first.

Implementations

impl<Repr: Repr> NodeBase<Repr>

pub fn new(yaml: YamlBase<Repr>, pos: u64, ty: &str, anchor: &str) -> Self

Create node from YAML data.

pub fn pos(&self) -> u64

Document position.

pub fn ty(&self) -> &str

Type assertion.

pub fn anchor(&self) -> &str

Anchor reference.

pub fn yaml(&self) -> &YamlBase<Repr>

YAML data.

pub fn into_yaml(self) -> YamlBase<Repr>

Drop the node and get the YAML data.

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, bool, 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_eq!("12.04", node!(12.04).as_value().unwrap());
assert_eq!("true", node!(true).as_value().unwrap());
assert_eq!("false", node!(false).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<Repr>, 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<Repr>, 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<YamlBase<Repr>> + Copy, 

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

If any key is missing, return Err with node position.

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

pub fn get_default<'a, Y, R, F>(
    &'a self,
    keys: &[Y],
    default: R,
    factory: F
) -> Result<R, u64> where
    Y: Into<YamlBase<Repr>> + Copy,
    F: Fn(&'a Self) -> Result<R, u64>, 

Same as NodeBase::get but provide default value if the key is missing. For this method, a transform method as_* is required.

• If the value exist, return the value.
• If value is a wrong type, return Err with node position.
• If the value is not exist, return the default value.

use yaml_peg::{node, NodeBase};
let a = node!({node!("a") => node!({node!("b") => node!("c")})});
assert_eq!(
    "c",
    a.get_default(&["a", "b"], "d", NodeBase::as_str).unwrap()
);
let b = node!({node!("a") => node!({})});
assert_eq!(
    "d",
    b.get_default(&["a", "b"], "d", NodeBase::as_str).unwrap()
);
let c = node!({node!("a") => node!({node!("b") => node!(20.)})});
assert_eq!(
    Err(0),
    c.get_default(&["a", "b"], "d", NodeBase::as_str)
);

Trait Implementations

impl<R: Clone + Repr> Clone for NodeBase<R>

fn clone(&self) -> NodeBase<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Repr> Debug for NodeBase<R>

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

Formats the value using the given formatter.

impl<R: Repr> Dumper for NodeBase<R>

fn dump(&self, level: usize, root: Root) -> String

Recursive dump function.

fn ind(level: usize) -> String

Generate indentation.

impl<R: Repr> From<YamlBase<R>> for NodeBase<R>

fn from(yaml: YamlBase<R>) -> Self

Performs the conversion.

impl<R: Repr> FromIterator<NodeBase<R>> for YamlBase<R>

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

Creates a value from an iterator.

impl<R: Hash + Repr> Hash for NodeBase<R>

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<R: Repr> Index<&'_ str> for NodeBase<R>

type Output = Self

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<R: Repr> Index<usize> for NodeBase<R>

type Output = Self

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<R: PartialEq + Repr> PartialEq<NodeBase<R>> for NodeBase<R>

fn eq(&self, other: &NodeBase<R>) -> bool

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

fn ne(&self, other: &NodeBase<R>) -> bool

This method tests for !=.

impl<R: Eq + Repr> Eq for NodeBase<R>

impl<R: Repr> StructuralEq for NodeBase<R>

impl<R: Repr> StructuralPartialEq for NodeBase<R>