space_partitioning/interval_tree/
interval.rs

1//! `Interval<T>` for capturing intervals.
2pub use crate::interval_tree::interval_type::IntervalType;
3use std::fmt::{Debug, Display, Formatter};
4use std::ops::RangeInclusive;
5
6/// Structure to represent an interval.
7#[derive(Default, Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
8pub struct Interval<T>
9where
10    T: IntervalType,
11{
12    pub start: T,
13    pub end: T,
14}
15
16impl<T> Interval<T>
17where
18    T: IntervalType,
19{
20    /// Constructs a new interval.
21    ///
22    /// # Example
23    /// ```rust
24    /// use space_partitioning::interval_tree::Interval;
25    /// let interval = Interval::new(-2.0, 10.0);
26    /// assert_eq!(interval.start, -2.0);
27    /// assert_eq!(interval.end, 10.0);
28    /// ```
29    pub fn new(low: T, high: T) -> Self {
30        Self {
31            start: low,
32            end: high,
33        }
34    }
35
36    /// Checks whether the current interval overlaps with another one.
37    ///
38    /// # Example
39    /// ```rust
40    /// use space_partitioning::interval_tree::Interval;
41    /// let interval = Interval::from(-2.0..=10.0);
42    /// assert!(interval.overlaps_with(&(0.0..=2.0).into()));
43    /// assert!(!interval.overlaps_with(&(20.0..=30.0).into()));
44    /// ```
45    pub fn overlaps_with(&self, other: &Interval<T>) -> bool {
46        (self.start <= other.end) && (other.start <= self.end)
47    }
48}
49
50impl<T> Debug for Interval<T>
51where
52    T: Debug + IntervalType,
53{
54    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
55        write!(f, "[{:?}, {:?}]", self.start, self.end)
56    }
57}
58
59impl<T> Display for Interval<T>
60where
61    T: Display + IntervalType,
62{
63    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
64        write!(f, "[{}, {}]", self.start, self.end)
65    }
66}
67
68impl<T> From<(T, T)> for Interval<T>
69where
70    T: IntervalType,
71{
72    /// Constructs an interval from a tuple.
73    ///
74    /// # Example
75    /// ```rust
76    /// use space_partitioning::interval_tree::Interval;
77    /// let interval: Interval<_> = (-2.0, 10.0).into();
78    /// assert_eq!(interval.start, -2.0);
79    /// assert_eq!(interval.end, 10.0);
80    /// assert_eq!(interval, Interval::from((-2.0, 10.0)));
81    /// ```
82    fn from(interval: (T, T)) -> Self {
83        Self {
84            start: interval.0,
85            end: interval.1,
86        }
87    }
88}
89
90impl<T> From<std::ops::RangeInclusive<T>> for Interval<T>
91where
92    T: IntervalType,
93{
94    /// Constructs an interval from a `RangeInclusive<T>``.
95    ///
96    /// # Example
97    /// ```rust
98    /// use space_partitioning::interval_tree::Interval;
99    /// let interval: Interval<_> = (-2.0..=10.0).into();
100    /// assert_eq!(interval.start, -2.0);
101    /// assert_eq!(interval.end, 10.0);
102    /// assert_eq!(interval, Interval::from(-2.0..=10.0));
103    /// ```
104    fn from(range: RangeInclusive<T>) -> Self {
105        Self {
106            start: range.start().clone(),
107            end: range.end().clone(),
108        }
109    }
110}
111
112impl<T> From<&std::ops::RangeInclusive<T>> for Interval<T>
113where
114    T: IntervalType,
115{
116    /// Constructs an interval from a `&RangeInclusive<T>``.
117    ///
118    /// # Example
119    /// ```rust
120    /// use space_partitioning::interval_tree::Interval;
121    /// let range = -2.0..=10.0;
122    /// let interval: Interval<_> = (&range).into();
123    /// assert_eq!(interval.start, -2.0);
124    /// assert_eq!(interval.end, 10.0);
125    /// ```
126    fn from(range: &RangeInclusive<T>) -> Self {
127        Self {
128            start: range.start().clone(),
129            end: range.end().clone(),
130        }
131    }
132}
space_partitioning/interval_tree/interval.rs

space_partitioning/interval_tree/
interval.rs
