Struct yaml_peg::NodeBase [−][src]
pub struct NodeBase<R: Repr>(_);
Expand description
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
Create node from YAML data.
Convert to boolean.
use yaml_peg::node; assert!(node!(true).as_bool().unwrap());
Convert to integer.
use yaml_peg::node; assert_eq!(60, node!(60).as_int().unwrap());
Convert to float.
use yaml_peg::node; assert_eq!(20.06, node!(20.06).as_float().unwrap());
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());
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());
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());
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());
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); }
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); }
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")?);
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![]);
Trait Implementations
Auto Trait Implementations
Blanket Implementations
Mutably borrows from an owned value. Read more
pub default fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64 where
H: Hash + ?Sized,
B: BuildHasher,