Struct str_index::StrRange

pub struct StrRange { /* fields omitted */ }

A range of a string, represented as a half-open range of StrIndex.

Construct a StrRange by using from conversion from std::ops::Range/RangeTo. The range is always guaranteed increasing; conversion panics if end < start.

Examples

let zero = StrIndex::from(0);
let start = StrIndex::from(10);
let end = StrIndex::from(20);
assert_eq!(
    format!("{:?}", StrRange::from(start..end)),
    format!("{:?}", start..end),
);
assert_eq!(
    format!("{:?}", StrRange::from(..end)),
    format!("{:?}", zero..end),
);

let this_panics = StrRange::from(end..start);

Methods

impl StrRange

pub fn start(self) -> StrIndex

The (inclusive) start index of this range.

pub fn end(self) -> StrIndex

The (exclusive) end index of this range.

pub fn len(self) -> StrIndex

The length of this range.

pub fn is_empty(self) -> bool

Is this range a unit range? That is, does this range have equivalent start and end points?

pub fn with_start(self, start: StrIndex) -> StrRange

A range with an adjusted end.

Panics

Panics if self.end() < start.

Example

let range = StrRange::from(5.into()..10.into());
let point = StrIndex::from(0);
assert_eq!(
    range.with_start(point),
    point.range_to(range.end()),
);

pub fn with_end(self, end: StrIndex) -> StrRange

A range with an adjusted end.

Panics

Panics if end < self.start().

Example

let range = StrRange::from(0.into()..5.into());
let point = StrIndex::from(10);
assert_eq!(
    range.with_end(point),
    range.start().range_to(point),
);

pub fn is_disjoint(self, other: StrRange) -> bool

Are these ranges disjoint?

Ranges that touch end to start are disjoint, as no byte is in both ranges.

Examples

let left = StrRange::from(0.into()..20.into());
let right = StrRange::from(10.into()..30.into());
assert!(!left.is_disjoint(right));
assert!(!right.is_disjoint(left));

let left = StrRange::from(0.into()..10.into());
let right = StrRange::from(10.into()..20.into());
assert!(left.is_disjoint(right));
assert!(right.is_disjoint(left));

let empty = StrRange::from(10.into()..10.into());
assert!(empty.is_disjoint(empty));

pub fn intersection(self, other: Self) -> Option<Self>

The range that is both in self and other.

Note that ranges that touch but do not overlap return Some(empty range) and ranges that do not touch and do not overlap return None.

Examples

let left = StrRange::from(0.into()..20.into());
let right = StrRange::from(10.into()..30.into());
assert_eq!(
    left.intersection(right),
    Some(StrRange::from(10.into()..20.into())),
);

let left = StrRange::from(0.into()..10.into());
let right = StrRange::from(10.into()..20.into());
assert_eq!(
    left.intersection(right),
    Some(StrRange::from(10.into()..10.into())),
);

pub fn nonempty_intersection(self, other: Self) -> Option<Self>

Like [intersection], but disjoint ranges always return None.

Examples

let left = StrRange::from(0.into()..20.into());
let right = StrRange::from(10.into()..30.into());
assert_eq!(
    left.nonempty_intersection(right),
    left.intersection(right),
);

let left = StrRange::from(0.into()..10.into());
let right = StrRange::from(10.into()..20.into());
assert_eq!(
    left.nonempty_intersection(right),
    None,
);

pub fn merge(self, other: Self) -> Self

The range that covers both self and other.

Note that it will also cover any space between self and other.

Example

let left = StrRange::from(0.into()..10.into());
let right = StrRange::from(20.into()..30.into());
assert_eq!(
    left.merge(right),
    StrRange::from(0.into()..30.into()),
);

pub fn contains(self, other: StrRange) -> bool

Does this range contain other?

other must be completely within self, but may share endpoints.

Examples

let range = StrRange::from(0.into()..20.into());
assert!(range.contains(StrRange::from(5.into()..15.into())));
assert!(range.contains(range));

pub fn contains_exclusive(self, index: StrIndex) -> bool

Does this range contain this index?

This is an exclusive test; use StrIndex::as_unit_range for an inclusive test.

Examples

let range = StrRange::from(10.into()..20.into());
assert!(range.contains_exclusive(range.start()));
assert!(!range.contains_exclusive(range.end()));
assert!(range.contains(range.end().as_unit_range()));

Trait Implementations

impl From<Range<StrIndex>> for StrRange

fn from(range: Range<StrIndex>) -> Self

Performs the conversion.

impl From<RangeTo<StrIndex>> for StrRange

fn from(range: RangeTo<StrIndex>) -> Self

Performs the conversion.

impl Debug for StrRange

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

Formats the value using the given formatter.

impl Display for StrRange

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

Formats the value using the given formatter.

impl PartialEq<StrRange> for StrRange

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

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

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

This method tests for !=.

impl Eq for StrRange

impl Ord for StrRange

fn cmp(&self, other: &StrRange) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialOrd<StrRange> for StrRange

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

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

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

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

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

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

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

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

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

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

impl Index<StrRange> for str

type Output = str

The returned type after indexing.

fn index(&self, index: StrRange) -> &str

Performs the indexing (container[index]) operation.

impl Index<StrRange> for String

type Output = str

The returned type after indexing.

fn index(&self, index: StrRange) -> &str

Performs the indexing (container[index]) operation.

impl IndexMut<StrRange> for str

fn index_mut(&mut self, index: StrRange) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<StrRange> for String

fn index_mut(&mut self, index: StrRange) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl RangeBounds<StrIndex> for StrRange

fn start_bound(&self) -> Bound<&StrIndex>

Start index bound.

fn end_bound(&self) -> Bound<&StrIndex>

End index bound.

fn contains<U>(&self, item: &U) -> bool where
    T: PartialOrd<U>,
    U: PartialOrd<T> + ?Sized, 

Returns true if item is contained in the range.

impl Hash for StrRange

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, 

Feeds a slice of this type into the given [Hasher].

impl Copy for StrRange

impl StructuralPartialEq for StrRange

impl StructuralEq for StrRange

impl Clone for StrRange

fn clone(&self) -> StrRange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for StrRange

fn default() -> StrRange

Returns the "default value" for a type.