Struct gluon_base::pos::Span

pub struct Span<I> { /* private fields */ }

A region of code in a source file

Implementations

impl<I: Ord> Span<I>

pub fn new(start: I, end: I) -> Span<I>

Create a new span

use gluon_base::pos::{ByteIndex, Span};

let span = Span::new(ByteIndex(3), ByteIndex(6));
assert_eq!(span.start(), ByteIndex(3));
assert_eq!(span.end(), ByteIndex(6));

start and end are reordered to maintain the invariant that start <= end

use gluon_base::pos::{ByteIndex, Span};

let span = Span::new(ByteIndex(6), ByteIndex(3));
assert_eq!(span.start(), ByteIndex(3));
assert_eq!(span.end(), ByteIndex(6));

pub fn map<F, J>(self, f: F) -> Span<J>

where F: FnMut(I) -> J, J: Ord,

impl<I> Span<I>

pub const fn new_unchecked(start: I, end: I) -> Span<I>

Create a span like new but does not check that start <= end

impl<I> Span<I>

pub fn start(self) -> I

Get the start index

pub fn end(self) -> I

Get the end index

impl<I: Index> Span<I>

pub fn subspan(&self, begin: I::Offset, end: I::Offset) -> Span<I>

Makes a span from offsets relative to the start of this span.

pub fn from_offset(start: I, off: I::Offset) -> Span<I>

Create a new span from a byte start and an offset

pub fn with_start(self, start: I) -> Span<I>

Return a new span with the low byte position replaced with the supplied byte position

use gluon_base::pos::{ByteIndex, Span};

let span = Span::new(ByteIndex(3), ByteIndex(6));
assert_eq!(span.with_start(ByteIndex(2)), Span::new(ByteIndex(2), ByteIndex(6)));
assert_eq!(span.with_start(ByteIndex(5)), Span::new(ByteIndex(5), ByteIndex(6)));
assert_eq!(span.with_start(ByteIndex(7)), Span::new(ByteIndex(6), ByteIndex(7)));

pub fn with_end(self, end: I) -> Span<I>

Return a new span with the high byte position replaced with the supplied byte position

use gluon_base::pos::{ByteIndex, Span};

let span = Span::new(ByteIndex(3), ByteIndex(6));
assert_eq!(span.with_end(ByteIndex(7)), Span::new(ByteIndex(3), ByteIndex(7)));
assert_eq!(span.with_end(ByteIndex(5)), Span::new(ByteIndex(3), ByteIndex(5)));
assert_eq!(span.with_end(ByteIndex(2)), Span::new(ByteIndex(2), ByteIndex(3)));

pub fn contains(self, other: Span<I>) -> bool

Return true if self fully encloses other.

use gluon_base::pos::{ByteIndex, Span};

let a = Span::new(ByteIndex(5), ByteIndex(8));

assert_eq!(a.contains(a), true);
assert_eq!(a.contains(Span::new(ByteIndex(6), ByteIndex(7))), true);
assert_eq!(a.contains(Span::new(ByteIndex(6), ByteIndex(10))), false);
assert_eq!(a.contains(Span::new(ByteIndex(3), ByteIndex(6))), false);

pub fn contains_pos(self, other: I) -> bool

pub fn containment(self, pos: I) -> Ordering

Return Equal if self contains pos, otherwise it returns Less if pos is before start or Greater if pos is after or at end.

use gluon_base::pos::{ByteIndex, Span};
use std::cmp::Ordering::*;

let a = Span::new(ByteIndex(5), ByteIndex(8));

assert_eq!(a.containment(ByteIndex(4)), Less);
assert_eq!(a.containment(ByteIndex(5)), Equal);
assert_eq!(a.containment(ByteIndex(6)), Equal);
assert_eq!(a.containment(ByteIndex(8)), Equal);
assert_eq!(a.containment(ByteIndex(9)), Greater);

pub fn containment_exclusive(self, pos: I) -> Ordering

Return Equal if self contains pos, otherwise it returns Less if pos is before start or Greater if pos is strictly after end.

use gluon_base::pos::{ByteIndex, Span};
use std::cmp::Ordering::*;

let a = Span::new(ByteIndex(5), ByteIndex(8));

assert_eq!(a.containment_exclusive(ByteIndex(4)), Less);
assert_eq!(a.containment_exclusive(ByteIndex(5)), Equal);
assert_eq!(a.containment_exclusive(ByteIndex(6)), Equal);
assert_eq!(a.containment_exclusive(ByteIndex(8)), Greater);
assert_eq!(a.containment_exclusive(ByteIndex(9)), Greater);

pub fn to(self, end: Span<I>) -> Span<I>

Return a Span that would enclose both self and end.

self     ~~~~~~~
end                     ~~~~~~~~
returns  ~~~~~~~~~~~~~~~~~~~~~~~

use gluon_base::pos::{ByteIndex, Span};

let a = Span::new(ByteIndex(2), ByteIndex(5));
let b = Span::new(ByteIndex(10), ByteIndex(14));

assert_eq!(a.to(b), Span::new(ByteIndex(2), ByteIndex(14)));

pub fn between(self, end: Span<I>) -> Span<I>

Return a Span between the end of self to the beginning of end.

self     ~~~~~~~
end                     ~~~~~~~~
returns         ~~~~~~~~~

use gluon_base::pos::{ByteIndex, Span};

let a = Span::new(ByteIndex(2), ByteIndex(5));
let b = Span::new(ByteIndex(10), ByteIndex(14));

assert_eq!(a.between(b), Span::new(ByteIndex(5), ByteIndex(10)));

pub fn until(self, end: Span<I>) -> Span<I>

Return a Span between the beginning of self to the beginning of end.

self     ~~~~~~~
end                     ~~~~~~~~
returns  ~~~~~~~~~~~~~~~~

use gluon_base::pos::{ByteIndex, Span};

let a = Span::new(ByteIndex(2), ByteIndex(5));
let b = Span::new(ByteIndex(10), ByteIndex(14));

assert_eq!(a.until(b), Span::new(ByteIndex(2), ByteIndex(10)));

impl Span<BytePos>

pub fn to_range(self, source: &CodeMap) -> Option<Range<usize>>

Trait Implementations

impl<I: Clone> Clone for Span<I>

fn clone(&self) -> Span<I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Span<I>

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

Formats the value using the given formatter.

impl<I: Default> Default for Span<I>

fn default() -> Span<I>

Returns the “default value” for a type.

impl<'de, I> Deserialize<'de> for Span<I>

where I: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: Display> Display for Span<I>

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

Formats the value using the given formatter.

impl<I: Ord> Ord for Span<I>

fn cmp(&self, other: &Span<I>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<I: PartialEq> PartialEq for Span<I>

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

fn partial_cmp(&self, other: &Span<I>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<I> Serialize for Span<I>

where I: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Copy> Copy for Span<I>

impl<I: Eq> Eq for Span<I>

impl<I> StructuralEq for Span<I>

impl<I> StructuralPartialEq for Span<I>