Struct Span

pub struct Span {
    pub start: usize,
    pub end: usize,
}

Points to a specific region of a source file by identifying the region’s start and end points.

Fields

start: usize

The byte index of the beginning of the span (inclusive).

end: usize

The byte index of the end of the span (exclusive).

Methods from Deref<Target = Range<usize>>

pub fn contains<U>(&self, item: &U) -> bool

where Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized,

Returns true if item is contained in the range.

Examples

assert!(!(3..5).contains(&2));
assert!( (3..5).contains(&3));
assert!( (3..5).contains(&4));
assert!(!(3..5).contains(&5));

assert!(!(3..3).contains(&3));
assert!(!(3..2).contains(&3));

assert!( (0.0..1.0).contains(&0.5));
assert!(!(0.0..1.0).contains(&f32::NAN));
assert!(!(0.0..f32::NAN).contains(&0.5));
assert!(!(f32::NAN..1.0).contains(&0.5));

pub fn is_empty(&self) -> bool

Returns true if the range contains no items.

Examples

assert!(!(3..5).is_empty());
assert!( (3..3).is_empty());
assert!( (3..2).is_empty());

The range is empty if either side is incomparable:

assert!(!(3.0..5.0).is_empty());
assert!( (3.0..f32::NAN).is_empty());
assert!( (f32::NAN..5.0).is_empty());

Trait Implementations

impl Clone for Span

fn clone(&self) -> Span

Returns a duplicate 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 DeepSizeOf for Span

fn deep_size_of_children(&self, _: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

fn deep_size_of_with(&self, context: &mut Context) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl DerefMut for Span

fn deref_mut(&mut self) -> &mut Range<usize>

Mutably dereferences the value.

impl<'a> From<&'a FileSpan> for Span

fn from(fsp: &'a FileSpan) -> Self

Converts to this type from the input type.

impl From<Range<usize>> for Span

fn from(r: Range<usize>) -> Self

Converts to this type from the input type.

impl From<RangeInclusive<usize>> for Span

fn from(r: RangeInclusive<usize>) -> Self

Converts to this type from the input type.

impl From<Span> for Range<usize>

fn from(s: Span) -> Self

Converts to this type from the input type.

impl From<usize> for Span

fn from(n: usize) -> Self

Converts to this type from the input type.

impl Hash for Span

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 Index<Span> for LinedString

Allows LinedString to be indexed with a Span, since Span is essentially a range.

type Output = [u8]

The returned type after indexing.

fn index(&self, s: Span) -> &[u8]

Performs the indexing (container[index]) operation.

impl IntoIterator for Span

type Item = usize

The type of the elements being iterated over.

type IntoIter = Range<usize>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Range<usize>

Creates an iterator from a value.

impl PartialEq for Span

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

type Target = Range<usize>

The resulting type after dereferencing.

fn deref(&self) -> &Range<usize>

Dereferences the value.

impl Copy for Span

impl Eq for Span

impl StructuralPartialEq for Span