Expand description
Readonly node, including line number, column number, type assertion and anchor.
You can access Yaml
type through Node::yaml
method.
This type will ignore additional information when comparison and hashing.
use std::collections::HashSet;
use yaml_peg::{NodeRc, Yaml};
let mut s = HashSet::new();
s.insert(NodeRc::new(Yaml::from("a"), 0, "", ""));
s.insert(NodeRc::new("a", 1, "my-tag", ""));
s.insert(NodeRc::new("a", 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 sequence indicator Ind
,
but it will be panic if the index is not contained.
use yaml_peg::{node, Ind};
let n = node!(["a", "b", "c"]);
assert_eq!(node!("b"), n[Ind(1)]);
use yaml_peg::{node, Ind};
let n = node!(());
let n = &n["a"][Ind(0)]["b"];
Same as containers, to prevent panic, the Node::get
method is the best choice.
The Node::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!({
"title" => 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 Anchor
, and attach with Node::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));
}
assert_eq!(1, Rc::strong_count(&a));
If you want to copy data, please get the data first.
Implementations
sourceimpl<R: Repr> Node<R>
impl<R: Repr> Node<R>
sourcepub fn new<Y>(yaml: Y, pos: u64, tag: &str, anchor: &str) -> Self where
Y: Into<Yaml<R>>,
pub fn new<Y>(yaml: Y, pos: u64, tag: &str, anchor: &str) -> Self where
Y: Into<Yaml<R>>,
Create node from YAML data.
sourcepub fn tag(&self) -> &str
pub fn tag(&self) -> &str
Tag. If the tag is not specified, returns a default tag from core schema.
Anchor has no tag.
sourcepub fn as_bool(&self) -> Result<bool, u64>
pub fn as_bool(&self) -> Result<bool, u64>
Convert to boolean.
use yaml_peg::node;
assert!(node!(true).as_bool().unwrap());
sourcepub fn as_int<N: FromStr>(&self) -> Result<N, u64>
pub fn as_int<N: FromStr>(&self) -> Result<N, u64>
Convert to integer.
use yaml_peg::node;
assert_eq!(60, node!(60).as_int().unwrap());
sourcepub fn as_float<N: FromStr>(&self) -> Result<N, u64>
pub fn as_float<N: FromStr>(&self) -> Result<N, u64>
Convert to float.
use yaml_peg::node;
assert_eq!(20.06, node!(20.06).as_float().unwrap());
sourcepub fn as_number<N: FromStr>(&self) -> Result<N, u64>
pub fn as_number<N: FromStr>(&self) -> Result<N, u64>
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());
sourcepub fn as_str(&self) -> Result<&str, u64>
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!(()).as_str().unwrap().is_empty());
sourcepub fn as_value(&self) -> Result<&str, u64>
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!(()).as_value().unwrap().is_empty());
sourcepub fn as_anchor<'a, 'b: 'a>(&'a self, v: &'b Anchor<R>) -> &'a Self
pub fn as_anchor<'a, 'b: 'a>(&'a self, v: &'b Anchor<R>) -> &'a 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" => 20.];
assert_eq!(20., node_a.as_anchor(&v).as_float().unwrap());
sourcepub fn as_seq(&self) -> Result<Seq<R>, u64>
pub fn as_seq(&self) -> Result<Seq<R>, u64>
Convert to sequence.
use yaml_peg::node;
let n = node!(["55"]);
assert_eq!(node!("55"), n.as_seq().unwrap()[0]);
for n in n.as_seq().unwrap() {
assert_eq!(node!("55"), n);
}
sourcepub fn as_map(&self) -> Result<Map<R>, u64>
pub fn as_map(&self) -> Result<Map<R>, u64>
Convert to map.
use yaml_peg::node;
let n = node!({1 => 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);
}
sourcepub fn get<Y: Into<Self>>(&self, key: Y) -> Result<&Self, u64>
pub fn get<Y: Into<Self>>(&self, key: Y) -> Result<&Self, u64>
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")?);
sourcepub fn get_default<'a, Y, Ret, F>(
&'a self,
key: Y,
default: Ret,
factory: F
) -> Result<Ret, u64> where
Y: Into<Self>,
F: Fn(&'a Self) -> Result<Ret, u64>,
pub fn get_default<'a, Y, Ret, F>(
&'a self,
key: Y,
default: Ret,
factory: F
) -> Result<Ret, u64> where
Y: Into<Self>,
F: Fn(&'a Self) -> Result<Ret, u64>,
Same as Node::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, Node};
let a = node!({node!("a") => node!({node!("b") => node!("c")})});
assert_eq!(
"c",
a.get("a")?.get_default("b", "d", Node::as_str)?
);
let b = node!({node!("a") => node!({})});
assert_eq!(
"d",
b.get("a")?.get_default("b", "d", Node::as_str)?
);
let c = node!({node!("a") => node!({node!("b") => node!(20.)})});
assert_eq!(
Err(0),
c.get("a")?.get_default("b", "d", Node::as_str)
);
use yaml_peg::{node, Node};
let n = node!({node!("a") => node!([node!(1), node!(2), node!(3)])});
let a = n.get_default("c", vec![], Node::as_seq)?;
assert_eq!(a, vec![]);
sourcepub fn get_ind(&self, ind: Ind) -> Result<&Self, u64>
pub fn get_ind(&self, ind: Ind) -> Result<&Self, u64>
Get node through index indicator. Only suitable for sequence.
use yaml_peg::{node, Ind};
let n = node!([node!("a"), node!("b"), node!("c")]);
assert_eq!(&node!("b"), n.get_ind(Ind(1))?);
sourcepub fn replace_anchor(&self, visitor: &Anchor<R>) -> Result<Self, InvalidAnchor>
pub fn replace_anchor(&self, visitor: &Anchor<R>) -> Result<Self, InvalidAnchor>
Replace the anchor insertion recursively.
Return None
if the anchor is not found.
If the anchor contains a self-loop, Yaml::Anchor
will be left.
See also Anchor::resolve
.
sourcepub fn new_with_yaml(&self, yaml: Yaml<R>) -> Self
pub fn new_with_yaml(&self, yaml: Yaml<R>) -> Self
Create a node with original information.
Trait Implementations
sourceimpl<'a, R: Repr> Deserialize<'a> for Node<R>
This is supported on crate feature serde
only.
impl<'a, R: Repr> Deserialize<'a> for Node<R>
serde
only.sourcefn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'a>,
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
D: Deserializer<'a>,
Deserialize this value from the given Serde deserializer. Read more
sourceimpl<'a, R: Repr> Deserializer<'a> for Node<R>
This is supported on crate feature serde
only.
impl<'a, R: Repr> Deserializer<'a> for Node<R>
serde
only.type Error = SerdeError
type Error = SerdeError
The error type that can be returned if some error occurs during deserialization. Read more
sourcefn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Require the Deserializer
to figure out how to drive the visitor based
on what data type is in the input. Read more
sourcefn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a bool
value.
sourcefn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an i8
value.
sourcefn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an i16
value.
sourcefn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an i32
value.
sourcefn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an i64
value.
sourcefn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a u8
value.
sourcefn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a u16
value.
sourcefn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a u32
value.
sourcefn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a u64
value.
sourcefn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a f32
value.
sourcefn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a f64
value.
sourcefn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer
. Read more
sourcefn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer
. Read more
sourcefn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a char
value.
sourcefn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a sequence of values.
sourcefn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a map of key-value pairs.
sourcefn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting the name of a struct
field or the discriminant of an enum variant. Read more
sourcefn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an i128
value. Read more
sourcefn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an u128
value. Read more
sourcefn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer
. Read more
sourcefn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer
. Read more
sourcefn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an optional value. Read more
sourcefn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a unit value.
sourcefn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_unit_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a unit struct with a
particular name. Read more
sourcefn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a newtype struct with a
particular name. Read more
sourcefn deserialize_tuple<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_tuple<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a sequence of values and
knows how many values there are without looking at the serialized data. Read more
sourcefn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_tuple_struct<V>(
self,
_name: &'static str,
_len: usize,
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a tuple struct with a
particular name and number of fields. Read more
sourcefn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_struct<V>(
self,
_name: &'static str,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting a struct with a particular
name and fields. Read more
sourcefn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_enum<V>(
self,
_name: &'static str,
_variants: &'static [&'static str],
visitor: V
) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type is expecting an enum value with a
particular name and possible variants. Read more
sourcefn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error> where
V: Visitor<'a>,
Hint that the Deserialize
type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read more
sourcefn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Determine whether Deserialize
implementations should expect to
deserialize their human-readable form. Read more
sourceimpl<R: Repr> FromIterator<Node<R>> for Node<R>
impl<R: Repr> FromIterator<Node<R>> for Node<R>
sourcefn from_iter<T: IntoIterator<Item = Self>>(iter: T) -> Self
fn from_iter<T: IntoIterator<Item = Self>>(iter: T) -> Self
Creates a value from an iterator. Read more
sourceimpl<R: Repr> FromIterator<Node<R>> for Yaml<R>
impl<R: Repr> FromIterator<Node<R>> for Yaml<R>
sourcefn from_iter<T: IntoIterator<Item = Node<R>>>(iter: T) -> Self
fn from_iter<T: IntoIterator<Item = Node<R>>>(iter: T) -> Self
Creates a value from an iterator. Read more
impl<R: Eq + Repr> Eq for Node<R>
impl<R: Repr> StructuralEq for Node<R>
impl<R: Repr> StructuralPartialEq for Node<R>
Auto Trait Implementations
impl<R> RefUnwindSafe for Node<R> where
R: RefUnwindSafe,
impl<R> Send for Node<R> where
R: Send,
impl<R> Sync for Node<R> where
R: Sync,
impl<R> Unpin for Node<R> where
R: Unpin,
impl<R> UnwindSafe for Node<R> where
R: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcepub fn to_owned(&self) -> T
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
sourcepub fn clone_into(&self, target: &mut T)
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more