Struct marked_yaml::Marker

pub struct Marker { /* private fields */ }

A marker for a YAML node

This indicates where a node started or ended.

use marked_yaml::{parse_yaml, Marker};
let node = parse_yaml(100, "{foo: bar}").unwrap();
let map = node.as_mapping().unwrap();
let bar = map.get("foo").unwrap();
// the "bar" string started on line 1, column 7 of source ID 100.
assert_eq!(bar.span().start(), Some(&Marker::new(100, 1, 7)));

Implementations

impl Marker

pub fn new(source: usize, line: usize, column: usize) -> Self

Create a new Marker

This will typically not be used because markers will come from parsing YAML, however it is provided for completeness and in case you need it for your own tests.

let marker = Marker::new(0, 1, 2);

pub fn source(&self) -> usize

The source index given for this marker.

When parsing YAML, we record where nodes start (and often finish). This is the source index provided when parsing the YAML. Likely this refers to a vector of PathBuf recording where input came from, but that is entirely up to the user of this library crate.

This is likely most useful to computers, not humans.

assert_eq!(marker.source(), 0);

pub fn line(&self) -> usize

The line number on which this marker resides, 1-indexed

When parsing YAML, we record where nodes start (and often finish). This is the line number of where this marker resides. Line numbers start with 1 to make them more useful to humans.

assert_eq!(marker.line(), 1);

pub fn column(&self) -> usize

The column number at which this marker resides, 1-indexed

When parsing YAML, we record where nodes start (and often finish). This is the column number of where this marker resides. Column numbers start with 1 to make them more useful to humans.

assert_eq!(marker.column(), 2);

pub fn render<D, F>(self, renderfn: F) -> RenderedMarker<D>

where D: Display, F: FnOnce(usize) -> D,

Render this marker

Markers have a source identifier, typically as passed to parse_yaml() but have no way in and of themselves to turn that into a useful name. This function allows you to create a rendered marker which knows how to show the source name.

let rendered = marker.render(|_| "name");
assert_eq!(format!("{}", rendered), "name:1:2")

pub fn set_source(&mut self, source: usize)

Set the source index for this marker

assert_ne!(marker.source(), 1);
marker.set_source(1);
assert_eq!(marker.source(), 1);

pub fn set_line(&mut self, line: usize)

Set the line number for this marker

assert_ne!(marker.line(), 1);
marker.set_line(1);
assert_eq!(marker.line(), 1);

pub fn set_column(&mut self, column: usize)

Set the column number for this marker

assert_ne!(marker.column(), 1);
marker.set_column(1);
assert_eq!(marker.column(), 1);

Trait Implementations

impl Clone for Marker

fn clone(&self) -> Marker

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Marker

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

Formats the value using the given formatter.

impl Display for Marker

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

Formats the value using the given formatter.

impl PartialEq for Marker

fn eq(&self, other: &Marker) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Marker

impl Eq for Marker

impl StructuralPartialEq for Marker