Enum YamlDataOwned 

pub enum YamlDataOwned<Node>
where
    Node: Hash + Eq + From<Self> + AnnotatedNodeOwned,
{
    Representation(String, ScalarStyle, Option<Tag>),
    Value(ScalarOwned),
    Sequence(Vec<Node>),
    Mapping(LinkedHashMap<Node, Node>),
    Tagged(Tag, Box<Node>),
    Alias(usize),
    BadValue,
}

YAML data for nodes that will contain annotations.

Owned version of YamlData.

Variants

Representation(String, ScalarStyle, Option<Tag>)

The raw string from the input.

See YamlData::Representation.

Value(ScalarOwned)

The resolved value from the representation.

See YamlData::Value.

Sequence(Vec<Node>)

YAML sequence, can be accessed as a Vec.

See YamlData::Sequence.

Mapping(LinkedHashMap<Node, Node>)

YAML mapping, can be accessed as a LinkedHashMap.

See YamlData::Mapping.

Tagged(Tag, Box<Node>)

A tagged node.

See YamlData::Tagged.

Alias(usize)

Alias, not fully supported yet.

See YamlData::Alias.

BadValue

A variant used when parsing the representation of a scalar node fails.

See YamlData::BadValue.

Implementations

impl<Node> YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

pub fn as_bool(&self) -> Option<bool>

Get a copy of the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with a copy of the $t contained. Otherwise, return None.

pub fn as_integer(&self) -> Option<i64>

Get a copy of the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with a copy of the $t contained. Otherwise, return None.

pub fn as_floating_point(&self) -> Option<f64>

Get a copy of the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with a copy of the $t contained. Otherwise, return None.

pub fn as_str(&self) -> Option<&str>

Get a reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&$t) with the $t contained. Otherwise, return None.

pub fn as_bool_mut(&mut self) -> Option<&mut bool>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn as_integer_mut(&mut self) -> Option<&mut i64>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn as_floating_point_mut(&mut self) -> Option<&mut f64>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn into_bool(self) -> Option<bool>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn into_integer(self) -> Option<i64>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn into_floating_point(self) -> Option<f64>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn into_string(self) -> Option<String>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn as_mapping(&self) -> Option<&LinkedHashMap<Node, Node>>

Get a reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&$t) with the $t contained. Otherwise, return None.

pub fn as_sequence(&self) -> Option<&Vec<Node>>

Get a reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&$t) with the $t contained. Otherwise, return None.

pub fn as_vec(&self) -> Option<&Vec<Node>>

Get a reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&$t) with the $t contained. Otherwise, return None.

pub fn as_mapping_mut(&mut self) -> Option<&mut LinkedHashMap<Node, Node>>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn as_sequence_mut(&mut self) -> Option<&mut Vec<Node>>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn as_vec_mut(&mut self) -> Option<&mut Vec<Node>>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn into_mapping(self) -> Option<LinkedHashMap<Node, Node>>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn into_vec(self) -> Option<Vec<Node>>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn into_sequence(self) -> Option<Vec<Node>>

Get the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some($t) with the $t contained. Otherwise, return None.

pub fn is_boolean(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_integer(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_null(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_floating_point(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_string(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_sequence(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_badvalue(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_mapping(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_alias(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_representation(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_value(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn is_tag_node(&self) -> bool

Check whether the YAML enum contains the given variant.

Return

If the variant of self is Self::$variant, return true. Otherwise, return false.

pub fn get_tagged_node(&self) -> Option<&Node>

Retrieve the tagged node if self is of the Tagged variant.

Return

The underlying node (without the tag) if self is a Tagged variant, None otherwise.

pub fn get_tagged_node_mut(&mut self) -> Option<&mut Node>

Retrieve the tagged node if self is of the Tagged variant.

Return

The underlying node (without the tag) if self is a Tagged variant, None otherwise.

pub fn is_empty_collection(&self) -> bool

Check whether the YAML enum is an empty sequence ([]) or empty mapping ({}).

Return

If the variant of self is Self::Sequence(x) with x.is_empty() or Self::Mapping(x) with y.is_empty(), return true. If self is a non-empty sequence, a non-empty mapping, or not a collection, return false.

pub fn is_non_empty_collection(&self) -> bool

Check whether the YAML enum is a non-empty sequence or a non-empty mapping.

Return

If the variant of self is Self::Sequence(x) with !x.is_empty() or Self::Mapping(x) with !y.is_empty(), return true. If self is an empty sequence, an empty mapping, or not a collection, return false.

pub fn parse_representation_recursive(&mut self) -> bool

Call Self::parse_representation on self and children nodes.

If self was Self::Value or Self::Alias upon calling, this function does nothing and returns true.

If Self::parse_representation fails on a descendent node, this function will not short circuit but still attempt to call Self::parse_representation on further nodes. Even if all further nodes succeed, this function will still return false.

Return

Returns true if all self and its children are successfully parsed, false otherwise.

pub fn or(self, other: Self) -> Self

If a value is null or otherwise bad (see variants), consume it and replace it with a given value other. Otherwise, return self unchanged.

assert_eq!(
    Yaml::Value(Scalar::Null).or(Yaml::Value(Scalar::Integer(3))),
    Yaml::Value(Scalar::Integer(3))
);
assert_eq!(
    Yaml::Value(Scalar::Integer(3)).or(Yaml::Value(Scalar::Integer(7))),
    Yaml::Value(Scalar::Integer(3))
);

pub fn borrowed_or<'a>(&'a self, other: &'a Self) -> &'a Self

See Self::or for behavior.

This performs the same operations, but with borrowed values for less linear pipelines.

pub fn contains_mapping_key(&self, key: &str) -> bool

Check whether self is a Self::Mapping and that it contains the given key.

This is equivalent to:

matches!(self, Self::Mapping(ref x) if x.contains_key(&Yaml::<'_>::String(key.into())))

Return

If the variant of self is Self::Mapping and the mapping contains the key, returns true. Otherwise, returns false.

pub fn as_mapping_get(&self, key: &str) -> Option<&Node>

Return the value associated to the given key if self is a Self::Mapping.

This is equivalent to:

self.as_mapping().and_then(|mapping| mapping.get(key))

Return

If the variant of self is Self::Mapping and the mapping contains the key, returns the value associated with it. Otherwise, returns None.

pub fn as_mapping_get_mut(&mut self, key: &str) -> Option<&mut Node>

Return the value associated to the given key if self is a Self::Mapping.

This is equivalent to:

self.as_mapping_mut().and_then(|mapping| mapping.get_mut(key))

Return

If the variant of self is Self::Mapping and the mapping contains the key, returns the value associated with it. Otherwise, returns None.

pub fn as_sequence_get(&self, idx: usize) -> Option<&Node>

Return the value at the given index if self is a Self::Sequence.

This is equivalent to:

self.as_sequence().and_then(|seq| seq.get(idx))

Return

If the variant of self is Self::Sequence and the index is not out of bounds, returns the value at the given index. Otherwise, returns None.

pub fn as_sequence_get_mut(&mut self, idx: usize) -> Option<&mut Node>

Return the value at the given index if self is a Self::Sequence.

This is equivalent to:

self.as_sequence_mut().and_then(|seq| seq.get_mut(idx))

Return

If the variant of self is Self::Sequence and the index is not out of bounds, returns the value at the given index. Otherwise, returns None.

impl<Node> YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

pub fn as_str_mut(&mut self) -> Option<&mut str>

Get a mutable reference to the inner object in the YAML enum if it is a $t.

Return

If the variant of self is Self::$variant, return Some(&mut $t) with the $t contained. Otherwise, return None.

pub fn parse_representation(&mut self) -> bool

If self is of the Self::Representation variant, parse it to the value.

If self was Self::Value, Self::Sequence, Self::Mapping or Self::Alias upon calling, this function does nothing and returns true.

If parsing fails, *self is assigned Self::BadValue.

Return

Returns true if self is successfully parsed, false otherwise.

pub fn get_tag(&self) -> Option<&Tag>

Retrieve the tag, if any.

This may return Some only on Tagged variants and sometimes on Representation variants (depending on the Noneness of the tag).

Return

Returns a tag if the node has one, None otherwise.

impl<Node> YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

pub fn take(&mut self) -> Self

Take the contained node out of Self, leaving a BadValue in its place.

Trait Implementations

impl<Node> Clone for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + Clone,

fn clone(&self) -> YamlDataOwned<Node>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Node> Debug for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + Debug,

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

Formats the value using the given formatter.

impl From<YamlDataOwned<MarkedYamlOwned>> for MarkedYamlOwned

fn from(value: YamlDataOwned<MarkedYamlOwned>) -> Self

Converts to this type from the input type.

impl<Node> Hash for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + Hash,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'key, Node> Index<&'key str> for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

fn index(&self, idx: &'key str) -> &Node

Perform indexing if self is a mapping.

Panics

This function panics if the key given does not exist within self (as per Index).

This function also panics if self is not a [$t::Mapping].

type Output = Node

The returned type after indexing.

impl<Node> Index<usize> for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

fn index(&self, idx: usize) -> &Node

Perform indexing if self is a sequence or a mapping.

Panics

This function panics if the index given is out of range (as per Index). If self is a [$t::Sequence], this is when the index is bigger or equal to the length of the underlying Vec. If self is a [$t::Mapping], this is when the mapping sequence does not contain Scalar::Integer(idx) as a key.

This function also panics if self is not a [$t::Sequence] nor a [$t::Mapping].

type Output = Node

The returned type after indexing.

impl<'key, Node> IndexMut<&'key str> for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

fn index_mut(&mut self, idx: &'key str) -> &mut Node

Perform indexing if self is a mapping.

Panics

This function panics if the key given does not exist within self (as per Index).

This function also panics if self is not a [$t::Mapping].

impl<Node> IndexMut<usize> for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

fn index_mut(&mut self, idx: usize) -> &mut Node

Perform indexing if self is a sequence or a mapping.

Panics

This function panics if the index given is out of range (as per IndexMut). If self is a [$t::Sequence], this is when the index is bigger or equal to the length of the underlying Vec. If self is a [$t::Mapping], this is when the mapping sequence does not contain Scalar::Integer(idx) as a key.

This function also panics if self is not a [$t::Sequence] nor a [$t::Mapping].

impl<Node> IntoIterator for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq<Node::HashKey>,

type Item = Node

The type of the elements being iterated over.

type IntoIter = AnnotatedYamlOwnedIter<Node>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Node> Ord for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + Ord,

fn cmp(&self, other: &YamlDataOwned<Node>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Node> PartialEq for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialEq,

fn eq(&self, other: &YamlDataOwned<Node>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Node> PartialOrd for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + PartialOrd,

fn partial_cmp(&self, other: &YamlDataOwned<Node>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Node> Eq for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned + Eq,

impl<Node> StructuralPartialEq for YamlDataOwned<Node>

where Node: Hash + Eq + From<Self> + AnnotatedNodeOwned,