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 also a convenient macro node! to create nodes literally. Please see the macro description for more information.

Nodes can be indexing by convertable values, or array indicator Ind, but it will be panic if the index is not contained.

use yaml_peg::{node, Ind};

let n = node!([node!("a"), node!("b"), node!("c")]);
assert_eq!(node!("b"), n[Ind(1)]);

use yaml_peg::{node, Ind};

let n = node!(null);
let n = &n["a"][Ind(0)]["b"];

Same as containers, to prevent panic, the NodeBase::get method is the best choice. The NodeBase::get_default can provide missing key value when indexing.

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(())
}

Anchor

The anchors can be infer from AnchorBase, and attach with NodeBase::as_anchor method.

Clone

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

use std::rc::Rc;
use yaml_peg::node;

let a = node!("a");
{
    let b = a.clone();
    assert_eq!(2, Rc::strong_count(b.as_ref()));
}
assert_eq!(1, Rc::strong_count(a.as_ref()));

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

Implementations

impl<R: Repr> NodeBase<R>

pub fn new(yaml: YamlBase<R>, 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<R>

YAML data.

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

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, anchors: &AnchorBase<R>) -> Self

Infer an anchor with anchor visitor.

If the node is not a anchor, or the anchor does not exist, the original node is returned. Since the anchor type is invalid except for this method, missing anchor will still return an error.

use yaml_peg::{node, anchors};

let node_a = node!(*"a");
let v = anchors!["a" => node!(20.)];
assert_eq!(20., node_a.as_anchor(&v).as_float().unwrap());

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

Convert to array.

use yaml_peg::node;

let n = node!([node!("55")]);
assert_eq!(node!("55"), n.as_array().unwrap()[0]);
for n in n.as_array().unwrap() {
    assert_eq!(node!("55"), n);
}

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

Convert to map.

use yaml_peg::node;

let n = node!({node!(1) => node!(2)});
assert_eq!(node!(2), n.as_map().unwrap()[&node!(1)]);
for (k, v) in n.as_map().unwrap() {
    assert_eq!(node!(1), k);
    assert_eq!(node!(2), v);
}

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

Convert to map and try to get the value by key.

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

use yaml_peg::node;

let n = node!({node!("a") => node!({node!("b") => node!(30.)})});
assert_eq!(node!(30.), n.get("a")?.get("b")?);

pub fn get_default<'a, Y, Ret, F>(
    &'a self,
    keys: Y,
    default: Ret,
    factory: F
) -> Result<Ret, u64> where
    Y: Into<Self> + Copy,
    F: Fn(&'a Self) -> Result<Ret, 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("a")?.get_default("b", "d", NodeBase::as_str)?
);
let b = node!({node!("a") => node!({})});
assert_eq!(
    "d",
    b.get("a")?.get_default("b", "d", NodeBase::as_str)?
);
let c = node!({node!("a") => node!({node!("b") => node!(20.)})});
assert_eq!(
    Err(0),
    c.get("a")?.get_default("b", "d", NodeBase::as_str)
);

use yaml_peg::{node, NodeBase};

let n = node!({node!("a") => node!([node!(1), node!(2), node!(3)])});
let a = n.get_default("c", vec![], NodeBase::as_array)?;
assert_eq!(a, vec![]);

pub fn get_ind(&self, ind: Ind) -> Result<Self, u64>

Get node through index indicator. Only suitable for array.

use yaml_peg::{node, Ind};

let n = node!([node!("a"), node!("b"), node!("c")]);
assert_eq!(node!("b"), n.get_ind(Ind(1))?);

Trait Implementations

impl AsRef<Arc<Inner<ArcRepr>>> for NodeBase<ArcRepr>

fn as_ref(&self) -> &Arc<Inner<ArcRepr>>

Performs the conversion.

impl AsRef<Rc<Inner<RcRepr>>> for NodeBase<RcRepr>

fn as_ref(&self) -> &Rc<Inner<RcRepr>>

Performs the conversion.

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, Y> From<Y> for NodeBase<R> where
    R: Repr,
    Y: Into<YamlBase<R>>, 

fn from(yaml: Y) -> 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, I> Index<I> for NodeBase<R> where
    R: Repr,
    I: Into<Self>, 

type Output = Self

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

type Output = Self

The returned type after indexing.

fn index(&self, index: Ind) -> &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>