[−][src]Struct codespan::Span
A region of code in a source file
Methods
impl<I: Ord> Span<I>
[src]
pub fn new(start: I, end: I) -> Span<I>
[src]
Create a new span
use codespan::{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 codespan::{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,
[src]
F: FnMut(I) -> J,
J: Ord,
impl<I> Span<I>
[src]
impl<I: Index> Span<I>
[src]
pub fn subspan(&self, begin: I::Offset, end: I::Offset) -> Span<I>
[src]
Makes a span from offsets relative to the start of this span.
pub fn from_offset(start: I, off: I::Offset) -> Span<I>
[src]
Create a new span from a byte start and an offset
pub fn with_start(self, start: I) -> Span<I>
[src]
Return a new span with the low byte position replaced with the supplied byte position
use codespan::{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>
[src]
Return a new span with the high byte position replaced with the supplied byte position
use codespan::{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
[src]
Return true if self
fully encloses other
.
use codespan::{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 containment(self, pos: I) -> Ordering
[src]
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 codespan::{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
[src]
Return Equal
if self
contains pos
, otherwise it returns Less
if pos
is before
start
or Greater
if pos
is strictly after end
.
use codespan::{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>
[src]
Return a Span
that would enclose both self
and end
.
self ~~~~~~~
end ~~~~~~~~
returns ~~~~~~~~~~~~~~~~~~~~~~~
use codespan::{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>
[src]
Return a Span
between the end of self
to the beginning of end
.
self ~~~~~~~
end ~~~~~~~~
returns ~~~~~~~~~
use codespan::{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>
[src]
Return a Span
between the beginning of self
to the beginning of end
.
self ~~~~~~~
end ~~~~~~~~
returns ~~~~~~~~~~~~~~~~
use codespan::{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)));
Trait Implementations
impl<I: PartialEq> PartialEq<Span<I>> for Span<I>
[src]
impl<I: Default> Default for Span<I>
[src]
impl<I: Ord> Ord for Span<I>
[src]
fn cmp(&self, other: &Span<I>) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
impl<I: Clone> Clone for Span<I>
[src]
fn clone(&self) -> Span<I>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<I: Eq> Eq for Span<I>
[src]
impl<I: Copy> Copy for Span<I>
[src]
impl<I: PartialOrd> PartialOrd<Span<I>> for Span<I>
[src]
fn partial_cmp(&self, other: &Span<I>) -> Option<Ordering>
[src]
fn lt(&self, other: &Span<I>) -> bool
[src]
fn le(&self, other: &Span<I>) -> bool
[src]
fn gt(&self, other: &Span<I>) -> bool
[src]
fn ge(&self, other: &Span<I>) -> bool
[src]
impl<I: Display> Display for Span<I>
[src]
impl<I: Debug> Debug for Span<I>
[src]
Auto Trait Implementations
Blanket Implementations
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> From for T
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,