Struct MarkedYaml 

pub struct MarkedYaml<'input> {
    pub span: Span,
    pub data: YamlData<'input, MarkedYaml<'input>>,
}

A YAML node with Spans pointing to the start of the node.

This structure does not implement functions to operate on the YAML object. To access those, refer to the Self::data field.

Warning

In order to allow indexing by content in mappings, equality comparisons for this structure ignore the Span.

Fields

span: Span

The span indicating where in the input stream the object is.

The markers are relative to the start of the input stream that was given to the parser, not to the start of the document within the input stream.

data: YamlData<'input, MarkedYaml<'input>>

The YAML contents of the node.

Implementations

impl<'input> MarkedYaml<'input>

pub fn value_from_str(v: &'input str) -> Self

Convert a string to a scalar node.

See YamlData::value_from_str for more details.

The returned node is created with a default Span.

pub fn scalar_from_string(v: String) -> Self

Same as Self::value_from_str but uses a String instead.

See YamlData::value_from_str for more details.

The returned node is created with a default Span.

pub fn value_from_cow(v: Cow<'input, str>) -> Self

Same as Self::value_from_str but uses a Cow instead.

See YamlData::value_from_str for more details.

The returned node is created with a default Span.

pub fn value_from_cow_and_metadata( v: Cow<'input, str>, style: ScalarStyle, tag: Option<&Cow<'input, Tag>>, ) -> Self

Convert a string to a scalar node, abiding by the given metadata.

The variant returned by this function will always be a YamlData::Value, unless the tag forces a particular type and the representation cannot be parsed as this type, in which case it returns a YamlData::BadValue.

The returned node is created with a default Span.

Trait Implementations

impl AnnotatedNode for MarkedYaml<'_>

type HashKey<'a> = MarkedYaml<'a>

The type used as the key in the YamlData::Mapping variant.

fn parse_representation_recursive(&mut self) -> bool

See YamlData::parse_representation_recursive.

impl<'input> Clone for MarkedYaml<'input>

fn clone(&self) -> MarkedYaml<'input>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'input> Debug for MarkedYaml<'input>

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

Formats the value using the given formatter.

impl<'a> From<YamlData<'a, MarkedYaml<'a>>> for MarkedYaml<'a>

fn from(value: YamlData<'a, MarkedYaml<'a>>) -> Self

Converts to this type from the input type.

impl Hash for MarkedYaml<'_>

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<'input> LoadableYamlNode<'input> for MarkedYaml<'input>

type HashKey = MarkedYaml<'input>

The type of the key for the hash variant of the YAML node.

fn from_bare_yaml(yaml: Yaml<'input>) -> Self

Create an instance of Self from a Yaml.

fn is_sequence(&self) -> bool

Return whether the YAML node is an array.

fn is_mapping(&self) -> bool

Return whether the YAML node is a hash.

fn is_badvalue(&self) -> bool

Return whether the YAML node is BadValue.

fn into_tagged(self, tag: Cow<'input, Tag>) -> Self

Turn self into a Tagged node, using the given tag.

fn sequence_mut(&mut self) -> &mut Vec<Self>

Retrieve the sequence variant of the YAML node.

fn mapping_mut(&mut self) -> &mut LinkedHashMap<Self::HashKey, Self>

Retrieve the mapping variant of the YAML node.

fn take(&mut self) -> Self

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

fn with_span(self, span: Span) -> Self

Provide the span for the node (builder-style).

fn with_start_marker(self, mark: Marker) -> Self

Provide the start-marker for the node (builder-style).

fn with_end_marker(self, mark: Marker) -> Self

Provide the end-marker for the node (builder-style).

fn load_from_str(source: &str) -> Result<Vec<Self>, ScanError>

Load the given string as an array of YAML documents.

fn load_from_iter<I: Iterator<Item = char>>( source: I, ) -> Result<Vec<Self>, ScanError>

Load the contents of the given iterator as an array of YAML documents.

fn load_from_parser<I: Input>( parser: &mut Parser<'input, I>, ) -> Result<Vec<Self>, ScanError>

Load the contents from the specified Parser as an array of YAML documents.

impl<'b> PartialEq<MarkedYaml<'b>> for MarkedYaml<'_>

fn eq(&self, other: &MarkedYaml<'b>) -> 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 Eq for MarkedYaml<'_>