Struct segmap::segment::Segment

pub struct Segment<T> { /* fields omitted */ }

Monotonically increasing segment, for use as a concrete range type in [SegmentMap].

Implementations

impl<T> Segment<T>

pub fn new(start: Bound<T>, end: Bound<T>) -> Self where
    T: Ord, 

Construct a new segment from range bounds

If the range given is backwards (decreasing), it will be reversed

Weird Ranges

Oddly constructed ranges will be coerced to “sane” structure:

• Point ranges (where both start and end are bounded to the same value and at least one is included) will be coerced to (Included, Included)

Panics

Only one range is too strange to be included here. If you pass a point range with both the start and end excluded, this will panic, as the range is impossible to evaluate

let r = Segment::new(Bound::Included(0), Bound::Excluded(5));
assert_eq!(r.start_bound(), Bound::Included(&0));
assert_eq!(r.end_bound(), Bound::Excluded(&5));

See Also

Segment also implements From for all of the core::ops range types, so you may find it more convenient to construct a range like Segment::from(a..b)

pub fn full() -> Self

Construct a new [Range] that spans all possible values

This is the same as Range::from(..).

Examples

let r = Segment::<u32>::full();
assert_eq!(r.start_bound(), Bound::Unbounded);
assert_eq!(r.end_bound(), Bound::Unbounded);

pub fn point(value: T) -> Self where
    T: Clone, 

Constructs a new point segement at the given value

Examples

let r = Segment::point(5);
assert_eq!(r.start_bound(), Bound::Included(&5));
assert_eq!(r.end_bound(), Bound::Included(&5));

pub fn start_value(&self) -> Option<&T>

Get the start value of the range (if it is bounded)

Examples

let bounded = Segment::from(5..10);
assert_eq!(bounded.start_value(), Some(&5));

let unbounded = Segment::from(..10);
assert_eq!(unbounded.start_value(), None);

pub fn end_value(&self) -> Option<&T>

Get the end value of the range (if it is bounded)

Examples

let bounded = Segment::from(5..10);
assert_eq!(bounded.end_value(), Some(&10));

let unbounded = Segment::from(5..);
assert_eq!(unbounded.end_value(), None);

pub fn as_ref(&self) -> Segment<&T>

Converts from Segment<T> to Segment<&T>.

Many iterators from this crate return a Segment<&T> instead of a &Segment<T> since bounds need to be constructed or adjusted. This allows us to avoid cloneing T.

pub fn overlaps(&self, other: &Self) -> bool where
    T: Ord, 

Check whether the range overlaps with another

Examples

// Overlapping Segments
let a = Segment::from(0..10);
let b = Segment::from(5..15);
assert!(a.overlaps(&b));

// Touching Segments
let a = Segment::from(0..10);
let b = Segment::from(10..20);
assert!(!a.overlaps(&b));

// Separate Segments
let a = Segment::from(0..10);
let b = Segment::from(15..20);
assert!(!a.overlaps(&b));

See Also

• Segment::touches for overlapping OR adjacent ranges

pub fn touches(&self, other: &Self) -> bool where
    T: Ord, 

Check whether the range touches another, either overlapping it or directly adjacent to it

Examples

// Overlapping Segments
let a = Segment::from(0..10);
let b = Segment::from(5..15);
assert!(a.touches(&b));

// Touching Segments
let a = Segment::from(0..10);
let b = Segment::from(10..20);
assert!(a.touches(&b));

// Separate Segments
let a = Segment::from(0..10);
let b = Segment::from(15..20);
assert!(!a.touches(&b));

See Also

• Segment::overlaps for only overlapping ranges

Trait Implementations

impl<T: Clone> Clone for Segment<T>

fn clone(&self) -> Segment<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Segment<T>

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

Formats the value using the given formatter.

impl<'a, T: 'a + Ord + Copy> Extend<&'a Segment<T>> for SegmentSet<T>

fn extend<I: IntoIterator<Item = &'a Segment<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Clone + Ord> Extend<Segment<T>> for SegmentSet<T>

fn extend<Iter: IntoIterator<Item = Segment<T>>>(&mut self, iter: Iter)

Insert all the items from iter into self.

NOTE: Inserted items will overwrite existing ranges in self if they overlap. If you don’t want to overwrite existing ranges, use [extend_into_gaps].

Clone is required for insertion, since we can’t guarantee elements in iter are ordered or non-overlapping, so ranges may need to be split.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Ord + Clone, R: RangeBounds<T>> From<&'_ R> for Segment<T>

fn from(r: &R) -> Self

Performs the conversion.

impl<T: Ord> From<Range<T>> for Segment<T>

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

Performs the conversion.

impl<T: Ord> From<RangeFrom<T>> for Segment<T>

fn from(r: RangeFrom<T>) -> Self

Performs the conversion.

impl<T: Ord> From<RangeFull> for Segment<T>

fn from(_: RangeFull) -> Self

Performs the conversion.

impl<T: Ord> From<RangeInclusive<T>> for Segment<T>

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

Performs the conversion.

impl<T: Ord> From<RangeTo<T>> for Segment<T>

fn from(r: RangeTo<T>) -> Self

Performs the conversion.

impl<T: Ord> From<RangeToInclusive<T>> for Segment<T>

fn from(r: RangeToInclusive<T>) -> Self

Performs the conversion.

impl<T: Hash> Hash for Segment<T>

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<T: PartialEq, R: RangeBounds<T>> PartialEq<R> for Segment<T>

fn eq(&self, other: &R) -> 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 !=.

impl<T> RangeBounds<T> for Segment<T>

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

Start index bound.

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

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<T> RangeBounds<T> for &Segment<T>

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

Start index bound.

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

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<T: Copy> Copy for Segment<T>

impl<T: Eq> Eq for Segment<T>

impl<T> StructuralEq for Segment<T>