pub struct Node<R: Repr> { /* private fields */ }
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, ""));
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(())
}
§Clone
Since the YAML data is wrapped by reference counter
alloc::rc::Rc
/alloc::sync::Arc
, cloned nodes are still shared
together, just like Python or JavaScript. Please see the
Node::rc_ref
/Node::yaml
/Node::clone_yaml
methods for details.
If you still want to copy data, use From
/Into
or serialize them to
your custom type.
Implementations§
source§impl<R: Repr> Node<R>
impl<R: Repr> Node<R>
sourcepub fn new(yaml: impl Into<Yaml<R>>, pos: u64, tag: impl ToString) -> Self
pub fn new(yaml: impl Into<Yaml<R>>, pos: u64, tag: impl ToString) -> Self
Create node from YAML data.
sourcepub fn new_repr(yaml: R::Rc, pos: u64, tag: impl ToString) -> Self
pub fn new_repr(yaml: R::Rc, pos: u64, tag: impl ToString) -> Self
Create from a representation.
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 clone_yaml(&self) -> R::Rc
pub fn clone_yaml(&self) -> R::Rc
Clone YAML repr.
sourcepub fn rc_ref(&self) -> &R::Rc
pub fn rc_ref(&self) -> &R::Rc
As reference for the underlying reference counter.
use std::{rc::Rc, sync::Arc};
use yaml_peg::node;
let a_rc = node!("a");
let a_arc = node!(arc "a");
{
let b_rc = a_rc.clone();
let b_arc = a_arc.clone();
assert_eq!(2, Rc::strong_count(b_rc.rc_ref()));
assert_eq!(2, Arc::strong_count(b_arc.rc_ref()));
}
assert_eq!(1, Rc::strong_count(a_rc.rc_ref()));
assert_eq!(1, Arc::strong_count(a_arc.rc_ref()));
sourcepub fn as_int(&self) -> Result<i64, u64>
pub fn as_int(&self) -> Result<i64, u64>
Convert to integer.
use yaml_peg::node;
assert_eq!(60, node!(60).as_int().unwrap());
sourcepub fn as_float(&self) -> Result<f64, u64>
pub fn as_float(&self) -> Result<f64, u64>
Convert to float.
use yaml_peg::node;
assert_eq!(20.06, node!(20.06).as_float().unwrap());
sourcepub fn as_number(&self) -> Result<f64, u64>
pub fn as_number(&self) -> Result<f64, u64>
Convert to float for any 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_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_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_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 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>(&'a self, anchors: &'a Anchors<R>) -> Result<&'a Self, u64>
pub fn as_anchor<'a>(&'a self, anchors: &'a Anchors<R>) -> Result<&'a Self, u64>
Return the reference from anchors
or self.
use yaml_peg::{node, parser::Anchors};
let mut anchors = Anchors::new();
anchors.insert("a".to_string(), node!(20));
assert_eq!(
20,
node!(*"a").as_anchor(&anchors).unwrap().as_int().unwrap()
);
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>
pub fn get_default<'a, Y, Ret, F>( &'a self, key: Y, default: Ret, factory: F ) -> 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![]);
Trait Implementations§
source§impl<'a, R: Repr> Deserialize<'a> for Node<R>
Available on crate feature serde
only.
impl<'a, R: Repr> Deserialize<'a> for Node<R>
serde
only.source§fn 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>,
source§impl<'a, R: Repr> Deserializer<'a> for Node<R>
Available on crate feature serde
only.
impl<'a, R: Repr> Deserializer<'a> for Node<R>
serde
only.§type Error = SerdeError
type Error = SerdeError
source§fn 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>,
Deserializer
to figure out how to drive the visitor based
on what data type is in the input. Read moresource§fn 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>,
Deserialize
type is expecting a bool
value.source§fn 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>,
Deserialize
type is expecting an i8
value.source§fn 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>,
Deserialize
type is expecting an i16
value.source§fn 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>,
Deserialize
type is expecting an i32
value.source§fn 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>,
Deserialize
type is expecting an i64
value.source§fn 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>,
Deserialize
type is expecting a u8
value.source§fn 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>,
Deserialize
type is expecting a u16
value.source§fn 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>,
Deserialize
type is expecting a u32
value.source§fn 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>,
Deserialize
type is expecting a u64
value.source§fn 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>,
Deserialize
type is expecting a f32
value.source§fn 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>,
Deserialize
type is expecting a f64
value.source§fn 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>,
Deserialize
type is expecting a string value and does
not benefit from taking ownership of buffered data owned by the
Deserializer
. Read moresource§fn 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>,
Deserialize
type is expecting a string value and would
benefit from taking ownership of buffered data owned by the
Deserializer
. Read moresource§fn 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>,
Deserialize
type is expecting a char
value.source§fn 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>,
Deserialize
type is expecting a sequence of values.source§fn 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>,
Deserialize
type is expecting a map of key-value pairs.source§fn 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>,
Deserialize
type is expecting the name of a struct
field or the discriminant of an enum variant.source§fn 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>,
source§fn 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>,
source§fn 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>,
Deserialize
type is expecting a byte array and does not
benefit from taking ownership of buffered data owned by the
Deserializer
. Read moresource§fn 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>,
Deserialize
type is expecting a byte array and would
benefit from taking ownership of buffered data owned by the
Deserializer
. Read moresource§fn 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>,
Deserialize
type is expecting an optional value. Read moresource§fn 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>,
Deserialize
type is expecting a unit value.source§fn 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>,
Deserialize
type is expecting a unit struct with a
particular name.source§fn 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>,
Deserialize
type is expecting a newtype struct with a
particular name.source§fn 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>,
Deserialize
type is expecting a sequence of values and
knows how many values there are without looking at the serialized data.source§fn 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>,
Deserialize
type is expecting a tuple struct with a
particular name and number of fields.source§fn 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>,
Deserialize
type is expecting a struct with a particular
name and fields.source§fn 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>,
Deserialize
type is expecting an enum value with a
particular name and possible variants.source§fn 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>,
Deserialize
type needs to deserialize a value whose type
doesn’t matter because it is ignored. Read moresource§fn is_human_readable(&self) -> bool
fn is_human_readable(&self) -> bool
Deserialize
implementations should expect to
deserialize their human-readable form. Read more