Struct range_union_find::IntRangeUnionFind

pub struct IntRangeUnionFind<T> where
    T: PrimInt,  { /* fields omitted */ }

Struct representing a union of integer ranges.

Implementations

impl<T> IntRangeUnionFind<T> where
    T: PrimInt, 

pub fn new() -> Self

Constructs a new IntRangeUnionFind object.

pub fn clear(&mut self)

Clears all the ranges stored in this object.

pub fn has_element_enum(&self, element: &T) -> (ContainedType, usize)

Returns a tuple describing the range the element is in, as well as its location. The range_id is a count of which range the element is in. The enum indicates where the element is in the range, with (Exterior,i) meaning the exterior region before the i’th range. See ContainedType for an explanation of the enum values.

If the element is in a single-element range of the form a..=a, the enum will not be Exterior, but its exact value is otherwise unspecified.

Example

let mut range_obj = IntRangeUnionFind::new();
range_obj.insert_range(&(10..20));
assert_eq!(range_obj.has_element_enum(&0),
    (ContainedType::Exterior, 0));
assert_eq!(range_obj.has_element_enum(&10),
    (ContainedType::Start, 0));
assert_eq!(range_obj.has_element_enum(&15),
    (ContainedType::Interior, 0));
assert_eq!(range_obj.has_element_enum(&19),
    (ContainedType::End, 0));
assert_eq!(range_obj.has_element_enum(&25),
    (ContainedType::Exterior, 1));

let mut range_obj = IntRangeUnionFind::new();
range_obj.insert_range(&(8..=8));
let (contain_enum, contain_id) = range_obj.has_element_enum(&8);
assert_ne!(contain_enum, ContainedType::Exterior);
assert_eq!(contain_id, 0);

pub fn has_element(&self, element: &T) -> bool

Returns whether the element is contained in the stored ranges. Returns false when Self::has_element_enum returns a ContainedType::Exterior enum, and true otherwise.

pub fn has_range<U: RangeBounds<T>>(
    &self,
    range: &U
) -> Result<OverlapType<T>, RangeOperationError>

Returns how the given range overlaps with the stored ranges. See OverlapType for a description of the enum values.

Example

let mut range_obj = IntRangeUnionFind::new();
range_obj.insert_range(&(10..20));
range_obj.insert_range(&(-20..-10));
assert_eq!(range_obj.has_range(&(15..17))?,
    OverlapType::Contained);
assert_eq!(range_obj.has_range(&(-5..5))?,
    OverlapType::Disjoint);
assert_eq!(range_obj.has_range(&(0..20))?,
    OverlapType::Partial(10));
assert_eq!(range_obj.has_range(&(-15..15))?,
    OverlapType::Partial(10));

Errors

Returns RangeOperationError if given range is invalid.

pub fn has_range_pair(
    &self,
    start: &T,
    end: &T
) -> Result<OverlapType<T>, RangeOperationError>

Functions like Self::has_range given input start..=end.

pub fn find_range_with_element(
    &self,
    element: &T
) -> Result<impl RangeBounds<T>, impl RangeBounds<T>>

Returns the range the element is in. If the element is in a range, return Ok(range_with_element). Otherwise, return Err(range_between_stored_ranges).

Warning: the impl RangeBounds<T> object does not include a Debug impl, so unwrap and unwrap_err cannot be used on the returned result.

Example

let mut range_obj = IntRangeUnionFind::<i32>::new();
range_obj.insert_range(&(10..=20));

let one_result = range_obj.find_range_with_element(&1);
assert!(match one_result {
    Err(one_err) => {
        assert_eq!(one_err.start_bound(), Bound::Unbounded);
        assert_eq!(one_err.end_bound(), Bound::Excluded(&10));
        true
    },
    Ok(_) => false
});

let twelve_result = range_obj.find_range_with_element(&12);
assert!(match twelve_result {
    Ok(twelve_range) => {
        assert_eq!(twelve_range.start_bound(), Bound::Included(&10));
        assert_eq!(twelve_range.end_bound(), Bound::Included(&20));
        true
    },
    Err(_) => false
});

let seventy_result = range_obj.find_range_with_element(&70);
assert!(match seventy_result {
    Err(seventy_err) => {
        assert_eq!(seventy_err.start_bound(), Bound::Excluded(&20));
        assert_eq!(seventy_err.end_bound(), Bound::Unbounded);
        true
    },
    Ok(_) => false
});

pub fn insert_range<U: RangeBounds<T>>(
    &mut self,
    range: &U
) -> Result<(), RangeOperationError>

Inserts the range into the set of ranges.

Errors

Returns RangeOperationError if the given range is invalid.

pub fn insert_range_pair(
    &mut self,
    start: &T,
    end: &T
) -> Result<(), RangeOperationError>

Functions like Self::insert_range given input start..=end.

pub fn remove_range<U: RangeBounds<T>>(
    &mut self,
    range: &U
) -> Result<(), RangeOperationError>

Removes the range from the set of ranges.

Errors

Returns RangeOperationError if the given range is invalid.

pub fn remove_range_pair(
    &mut self,
    start: &T,
    end: &T
) -> Result<(), RangeOperationError>

Functions like Self::remove_range given input start..=end.

pub fn into_collection<U>(self) -> U where
    U: FromIterator<RangeInclusive<T>>, 

Creates a collection of RangeInclusive with element type T from a IntRangeUnionFind object.

pub fn to_collection<U>(&self) -> U where
    U: FromIterator<RangeInclusive<T>>, 

Converts a IntRangeUnionFind object into a collection of RangeInclusive with element type T.

Trait Implementations

impl<T: PrimInt> BitAnd<&'_ IntRangeUnionFind<T>> for &IntRangeUnionFind<T>

fn bitand(self, rhs: &IntRangeUnionFind<T>) -> Self::Output

Computes the union of the two IntRangeUnionFind objects.

type Output = IntRangeUnionFind<T>

The resulting type after applying the & operator.

impl<T: PrimInt> BitOr<&'_ IntRangeUnionFind<T>> for &IntRangeUnionFind<T>

fn bitor(self, rhs: &IntRangeUnionFind<T>) -> Self::Output

Computes the union of the two IntRangeUnionFind objects.

type Output = IntRangeUnionFind<T>

The resulting type after applying the | operator.

impl<T: PrimInt> BitXor<&'_ IntRangeUnionFind<T>> for &IntRangeUnionFind<T>

type Output = IntRangeUnionFind<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &IntRangeUnionFind<T>) -> Self::Output

Performs the ^ operation.

impl<T: Clone> Clone for IntRangeUnionFind<T> where
    T: PrimInt, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for IntRangeUnionFind<T> where
    T: PrimInt + Debug, 

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

Formats the value using the given formatter.

impl<T: Default> Default for IntRangeUnionFind<T> where
    T: PrimInt, 

fn default() -> IntRangeUnionFind<T>

Returns the “default value” for a type.

impl<T, U> Extend<U> for IntRangeUnionFind<T> where
    T: PrimInt,
    U: RangeBounds<T>, 

fn extend<I: IntoIterator<Item = U>>(&mut self, iter: I)

Calls Self::insert_range for each range in the iterator.

Panics

Panics if any of the range insertions return an Err.

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: PrimInt> From<IntRangeUnionFind<T>> for Vec<RangeInclusive<T>>

fn from(union_obj: IntRangeUnionFind<T>) -> Vec<RangeInclusive<T>>

Performs the conversion.

impl<T, U> FromIterator<U> for IntRangeUnionFind<T> where
    T: PrimInt,
    U: RangeBounds<T>, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = U>, 

Calls Self::insert_range for each range in the iterator.

Panics

Panics if any of the range insertions return an Err.

impl<T: Hash> Hash for IntRangeUnionFind<T> where
    T: PrimInt, 

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: PrimInt> Not for &IntRangeUnionFind<T>

type Output = IntRangeUnionFind<T>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: PartialEq> PartialEq<IntRangeUnionFind<T>> for IntRangeUnionFind<T> where
    T: PrimInt, 

fn eq(&self, other: &IntRangeUnionFind<T>) -> bool

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

fn ne(&self, other: &IntRangeUnionFind<T>) -> bool

This method tests for !=.

impl<T: PrimInt> Sub<&'_ IntRangeUnionFind<T>> for &IntRangeUnionFind<T>

fn sub(self, rhs: &IntRangeUnionFind<T>) -> Self::Output

Subtracts the rhs IntRangeUnionFind object from the lhs one.

type Output = IntRangeUnionFind<T>

The resulting type after applying the - operator.

impl<T: Eq> Eq for IntRangeUnionFind<T> where
    T: PrimInt, 

impl<T> StructuralEq for IntRangeUnionFind<T> where
    T: PrimInt, 

impl<T> StructuralPartialEq for IntRangeUnionFind<T> where
    T: PrimInt,