Struct marked_yaml::types::Span

pub struct Span { /* private fields */ }

The span for a YAML marked node

use marked_yaml::{parse_yaml, Marker, Span};
let node = parse_yaml(100, "{foo: bar}").unwrap();
let map = node.as_mapping().unwrap();
assert_eq!(map.span(), &Span::new_with_marks(Marker::new(100, 1, 1), Marker::new(100, 1, 10)));

Implementations

impl Span

pub fn new_blank() -> Self

Create a span with no marker information

Sometimes we simply do not know where information came from (for example if it was created by software) and in that case we can create a blank span.

let blank = Span::new_blank();

pub fn new_start(start: Marker) -> Self

Create a span with only start information

Sometimes when creating a span we know where it started but not where it ends. This might be during parsing, or for some other reason.

let span = Span::new_start(Marker::new(0, 1, 2));

pub fn new_with_marks(start: Marker, end: Marker) -> Self

Create a span with both start and end markers

When we know both the start and end of a node, we can create a span which has all that knowledge.

let span = Span::new_with_marks(Marker::new(0, 1, 1), Marker::new(10, 2, 1));

pub fn start(&self) -> Option<&Marker>

The start of the span

assert_eq!(span.start(), Some(&Marker::new(0, 1, 1)));

pub fn end(&self) -> Option<&Marker>

The end of the span

assert_eq!(span.end(), Some(&Marker::new(10, 2, 1)));

pub fn start_mut(&mut self) -> Option<&mut Marker>

The start of the span, mutably

span.start_mut().unwrap().set_line(5);
assert_eq!(span.start(), Some(&Marker::new(0, 5, 1)));

pub fn end_mut(&mut self) -> Option<&mut Marker>

The end of the span, mutably

span.end_mut().unwrap().set_line(5);
assert_eq!(span.end(), Some(&Marker::new(10, 5, 1)));

pub fn set_start(&mut self, start: Option<Marker>)

Replace the start of the span

assert_eq!(span.start(), None);
span.set_start(Some(Marker::new(0, 1, 2)));
assert_eq!(span.start(), Some(&Marker::new(0, 1, 2)));

pub fn set_end(&mut self, end: Option<Marker>)

Replace the end of the span

assert_eq!(span.end(), None);
span.set_end(Some(Marker::new(0, 1, 2)));
assert_eq!(span.end(), Some(&Marker::new(0, 1, 2)));

Trait Implementations

impl Clone for Span

fn clone(&self) -> Span

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Span

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

Formats the value using the given formatter.

impl PartialEq for Span

fn eq(&self, other: &Span) -> 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 Span

impl Eq for Span

impl StructuralPartialEq for Span