yggdrasil/discrete_range_map
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename overly complicated name for DiscreteRangeBounds to interval

Browse Source
This commit is contained in:
ripytide
2023-06-11 12:39:38 +01:00
parent f640c58f86
commit f114f2898b
7 changed files with 108 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+4 -4
View File
@@ -40,7 +40,7 @@ assert_eq!(map.contains_point(5), true);
```rust
use discrete_range_map::test_ranges::ie;
use discrete_range_map::{
DiscreteFinite, DiscreteFiniteBounds, DiscreteRangeMap,
DiscreteFinite, Interval, DiscreteRangeMap,
FiniteRange,
};
@@ -70,9 +70,9 @@ impl FiniteRange<i8> for Reservation {
}
}
// Second, we need to implement From<DiscreteFiniteBounds<i8>>
impl From<DiscreteFiniteBounds<i8>> for Reservation {
fn from(bounds: DiscreteFiniteBounds<i8>) -> Self {
// Second, we need to implement From<Interval<i8>>
impl From<Interval<i8>> for Reservation {
fn from(bounds: Interval<i8>) -> Self {
if bounds.end == i8::MAX {
Reservation::Infinite(bounds.start)
} else {
src/discrete_range_map.rs
+54 -58
View File
@@ -33,7 +33,7 @@ use serde::ser::SerializeMap;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::discrete_finite::DiscreteFinite;
use crate::discrete_finite_bounds::DiscreteFiniteBounds;
use crate::interval::Interval;
use crate::utils::{cmp_point_with_range, cut_range, is_valid_range, overlaps};
/// An ordered map of non-overlapping ranges based on [`BTreeMap`].
@@ -90,17 +90,15 @@ pub struct OverlapError;
impl<I, K, V> DiscreteRangeMap<I, K, V>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>>,
K: FiniteRange<I> + Copy + From<Interval<I>>,
{
/// Makes a new, empty `DiscreteRangeMap`.
///
/// # Examples
/// ```
/// use discrete_range_map::{
/// DiscreteFiniteBounds, DiscreteRangeMap,
/// };
/// use discrete_range_map::{DiscreteRangeMap, Interval};
///
/// let map: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool> =
/// let map: DiscreteRangeMap<i8, Interval<i8>, bool> =
/// DiscreteRangeMap::new();
/// ```
pub fn new() -> Self {
@@ -368,7 +366,7 @@ where
.get_key_value(overlapping_comp(point))
.ok_or_else(|| K::from(self.get_gap_at_raw(point)))
}
fn get_gap_at_raw(&self, point: I) -> DiscreteFiniteBounds<I> {
fn get_gap_at_raw(&self, point: I) -> Interval<I> {
let lower = self
.inner
.upper_bound(overlapping_comp(point), SearchBoundCustom::Included);
@@ -376,7 +374,7 @@ where
.inner
.lower_bound(overlapping_comp(point), SearchBoundCustom::Included);
DiscreteFiniteBounds {
Interval {
start: lower
.key()
.map_or(I::MIN, |lower| lower.end().up().unwrap()),
@@ -655,7 +653,7 @@ where
.into_iter()
.chain(self.remove_overlapping(range).map(|(key, value)| {
(
K::from(DiscreteFiniteBounds {
K::from(Interval {
start: key.start(),
end: key.end(),
}),
@@ -744,7 +742,7 @@ where
let inner_gaps = overlapping
.tuple_windows()
.map(|(first, second)| {
K::from(DiscreteFiniteBounds {
K::from(Interval {
start: first.1.up().unwrap(),
end: second.0.down().unwrap(),
})
@@ -857,17 +855,15 @@ where
let matching_end = get_end(self, &value);
let returning = match (matching_start, matching_end) {
(Some(matching_start), Some(matching_end)) => {
K::from(DiscreteFiniteBounds {
start: matching_start.start(),
end: matching_end.end(),
})
}
(Some(matching_start), None) => K::from(DiscreteFiniteBounds {
(Some(matching_start), Some(matching_end)) => K::from(Interval {
start: matching_start.start(),
end: matching_end.end(),
}),
(Some(matching_start), None) => K::from(Interval {
start: matching_start.start(),
end: range.end(),
}),
(None, Some(matching_end)) => K::from(DiscreteFiniteBounds {
(None, Some(matching_end)) => K::from(Interval {
start: range.start(),
end: matching_end.end(),
}),
@@ -1455,7 +1451,7 @@ impl<I, K, V> Default for DiscreteRangeMap<I, K, V> {
impl<I, K, V> Serialize for DiscreteRangeMap<I, K, V>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Serialize,
K: FiniteRange<I> + Copy + From<Interval<I>> + Serialize,
V: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -1473,7 +1469,7 @@ where
impl<'de, I, K, V> Deserialize<'de> for DiscreteRangeMap<I, K, V>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Deserialize<'de>,
K: FiniteRange<I> + Copy + From<Interval<I>> + Deserialize<'de>,
V: Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1497,7 +1493,7 @@ struct DiscreteRangeMapVisitor<I, K, V> {
impl<'de, I, K, V> Visitor<'de> for DiscreteRangeMapVisitor<I, K, V>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Deserialize<'de>,
K: FiniteRange<I> + Copy + From<Interval<I>> + Deserialize<'de>,
V: Deserialize<'de>,
{
type Value = DiscreteRangeMap<I, K, V>;
@@ -1534,7 +1530,7 @@ mod tests {
pub(crate) const NUMBERS_DOMAIN: &'static [i8] =
&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
fn basic() -> DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool> {
fn basic() -> DiscreteRangeMap<i8, Interval<i8>, bool> {
DiscreteRangeMap::from_slice_strict([
(ui(4), false),
(ee(5, 7), true),
@@ -1543,7 +1539,7 @@ mod tests {
])
.unwrap()
}
fn basic_slice() -> [(DiscreteFiniteBounds<i8>, bool); 4] {
fn basic_slice() -> [(Interval<i8>, bool); 4] {
[
(ui(4), false),
(ee(5, 7), true),
@@ -1586,10 +1582,10 @@ mod tests {
);
}
fn assert_insert_strict<const N: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_insert: (DiscreteFiniteBounds<i8>, bool),
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_insert: (Interval<i8>, bool),
result: Result<(), OverlapError>,
after: [(DiscreteFiniteBounds<i8>, bool); N],
after: [(Interval<i8>, bool); N],
) {
assert_eq!(before.insert_strict(to_insert.0, to_insert.1), result);
assert_eq!(before, DiscreteRangeMap::from_slice_strict(after).unwrap())
@@ -1601,7 +1597,7 @@ mod tests {
for overlap_range in all_valid_test_bounds() {
//you can't overlap nothing
assert!(
DiscreteRangeMap::<i8, DiscreteFiniteBounds<i8>, ()>::new()
DiscreteRangeMap::<i8, Interval<i8>, ()>::new()
.overlapping(overlap_range)
.next()
.is_none()
@@ -1705,10 +1701,10 @@ mod tests {
);
}
fn assert_remove_overlapping<const N: usize, const Y: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_remove: DiscreteFiniteBounds<i8>,
result: [(DiscreteFiniteBounds<i8>, bool); N],
after: [(DiscreteFiniteBounds<i8>, bool); Y],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_remove: Interval<i8>,
result: [(Interval<i8>, bool); N],
after: [(Interval<i8>, bool); Y],
) {
assert_eq!(
before.remove_overlapping(to_remove).collect::<Vec<_>>(),
@@ -1755,10 +1751,10 @@ mod tests {
);
}
fn assert_cut<const N: usize, const Y: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_cut: DiscreteFiniteBounds<i8>,
result: [(DiscreteFiniteBounds<i8>, bool); Y],
after: [(DiscreteFiniteBounds<i8>, bool); N],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_cut: Interval<i8>,
result: [(Interval<i8>, bool); Y],
after: [(Interval<i8>, bool); N],
) {
assert_eq!(before.cut(to_cut).collect::<Vec<_>>(), result);
assert_eq!(before, DiscreteRangeMap::from_slice_strict(after).unwrap());
@@ -1794,9 +1790,9 @@ mod tests {
);
}
fn assert_gaps<const N: usize>(
map: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
outer_range: DiscreteFiniteBounds<i8>,
result: [DiscreteFiniteBounds<i8>; N],
map: DiscreteRangeMap<i8, Interval<i8>, bool>,
outer_range: Interval<i8>,
result: [Interval<i8>; N],
) {
assert_eq!(map.gaps(outer_range).collect::<Vec<_>>(), result);
}
@@ -1844,10 +1840,10 @@ mod tests {
);
}
fn assert_insert_merge_touching<const N: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_insert: (DiscreteFiniteBounds<i8>, bool),
result: Result<DiscreteFiniteBounds<i8>, OverlapError>,
after: [(DiscreteFiniteBounds<i8>, bool); N],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_insert: (Interval<i8>, bool),
result: Result<Interval<i8>, OverlapError>,
after: [(Interval<i8>, bool); N],
) {
assert_eq!(
before.insert_merge_touching(to_insert.0, to_insert.1),
@@ -1900,10 +1896,10 @@ mod tests {
);
}
fn assert_insert_merge_touching_if_values_equal<const N: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_insert: (DiscreteFiniteBounds<i8>, bool),
result: Result<DiscreteFiniteBounds<i8>, OverlapError>,
after: [(DiscreteFiniteBounds<i8>, bool); N],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_insert: (Interval<i8>, bool),
result: Result<Interval<i8>, OverlapError>,
after: [(Interval<i8>, bool); N],
) {
assert_eq!(
before.insert_merge_touching_if_values_equal(
@@ -1964,10 +1960,10 @@ mod tests {
);
}
fn assert_insert_merge_overlapping<const N: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_insert: (DiscreteFiniteBounds<i8>, bool),
result: DiscreteFiniteBounds<i8>,
after: [(DiscreteFiniteBounds<i8>, bool); N],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_insert: (Interval<i8>, bool),
result: Interval<i8>,
after: [(Interval<i8>, bool); N],
) {
assert_eq!(
before.insert_merge_overlapping(to_insert.0, to_insert.1),
@@ -2040,10 +2036,10 @@ mod tests {
);
}
fn assert_insert_merge_touching_or_overlapping<const N: usize>(
mut before: DiscreteRangeMap<i8, DiscreteFiniteBounds<i8>, bool>,
to_insert: (DiscreteFiniteBounds<i8>, bool),
result: DiscreteFiniteBounds<i8>,
after: [(DiscreteFiniteBounds<i8>, bool); N],
mut before: DiscreteRangeMap<i8, Interval<i8>, bool>,
to_insert: (Interval<i8>, bool),
result: Interval<i8>,
after: [(Interval<i8>, bool); N],
) {
assert_eq!(
before
@@ -2141,7 +2137,7 @@ mod tests {
}
}
}
fn con(x: Option<DiscreteFiniteBounds<i8>>, point: &i8) -> bool {
fn con(x: Option<Interval<i8>>, point: &i8) -> bool {
match x {
Some(y) => contains_point(y, *point),
None => false,
@@ -2175,7 +2171,7 @@ mod tests {
// Test Helper Functions
//======================
fn all_non_overlapping_test_bound_entries()
-> Vec<(DiscreteFiniteBounds<i8>, DiscreteFiniteBounds<i8>)> {
-> Vec<(Interval<i8>, Interval<i8>)> {
let mut output = Vec::new();
for test_bounds1 in all_valid_test_bounds() {
for test_bounds2 in all_valid_test_bounds() {
@@ -2188,12 +2184,12 @@ mod tests {
return output;
}
fn all_valid_test_bounds() -> Vec<DiscreteFiniteBounds<i8>> {
fn all_valid_test_bounds() -> Vec<Interval<i8>> {
let mut output = Vec::new();
for i in NUMBERS {
for j in NUMBERS {
if i <= j {
output.push(DiscreteFiniteBounds { start: *i, end: *j });
output.push(Interval { start: *i, end: *j });
}
}
}
src/discrete_range_set.rs
+5 -5
View File
@@ -6,10 +6,10 @@ use serde::ser::SerializeSeq;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::discrete_finite::DiscreteFinite;
use crate::discrete_finite_bounds::DiscreteFiniteBounds;
use crate::discrete_range_map::{
FiniteRange, IntoIter as DiscreteRangeMapIntoIter,
};
use crate::interval::Interval;
use crate::{DiscreteRangeMap, OverlapError};
/// An ordered set of non-overlapping ranges based on [`DiscreteRangeMap`].
@@ -31,7 +31,7 @@ pub struct DiscreteRangeSet<I, K> {
impl<I, K> DiscreteRangeSet<I, K>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>>,
K: FiniteRange<I> + Copy + From<Interval<I>>,
{
/// See [`DiscreteRangeMap::new()`] for more details.
pub fn new() -> Self {
@@ -199,7 +199,7 @@ where
impl<I, K> Serialize for DiscreteRangeSet<I, K>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Serialize,
K: FiniteRange<I> + Copy + From<Interval<I>> + Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -216,7 +216,7 @@ where
impl<'de, I, K> Deserialize<'de> for DiscreteRangeSet<I, K>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Deserialize<'de>,
K: FiniteRange<I> + Copy + From<Interval<I>> + Deserialize<'de>,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
@@ -237,7 +237,7 @@ struct DiscreteRangeSetVisitor<I, K> {
impl<'de, I, K> Visitor<'de> for DiscreteRangeSetVisitor<I, K>
where
I: Ord + Copy + DiscreteFinite,
K: FiniteRange<I> + Copy + From<DiscreteFiniteBounds<I>> + Deserialize<'de>,
K: FiniteRange<I> + Copy + From<Interval<I>> + Deserialize<'de>,
{
type Value = DiscreteRangeSet<I, K>;
src/discrete_finite_bounds.rs → src/interval.rs
+3 -3
View File
@@ -19,14 +19,14 @@ along with discrete_range_map. If not, see <https://www.gnu.org/licenses/>.
use crate::discrete_range_map::FiniteRange;
///both ends are always included
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct DiscreteFiniteBounds<I> {
//both are always included
pub struct Interval<I> {
pub start: I,
pub end: I,
}
impl<I> FiniteRange<I> for DiscreteFiniteBounds<I>
impl<I> FiniteRange<I> for Interval<I>
where
I: Copy,
{
src/lib.rs
+6 -7
View File
@@ -48,8 +48,7 @@ along with discrete_range_map. If not, see <https://www.gnu.org/licenses/>.
//! ```rust
//! use discrete_range_map::test_ranges::ie;
//! use discrete_range_map::{
//! DiscreteFinite, DiscreteFiniteBounds, DiscreteRangeMap,
//! FiniteRange,
//! DiscreteFinite, DiscreteRangeMap, FiniteRange, Interval,
//! };
//!
//! #[derive(Debug, Copy, Clone)]
@@ -78,9 +77,9 @@ along with discrete_range_map. If not, see <https://www.gnu.org/licenses/>.
//! }
//! }
//!
//! // Second, we need to implement From<DiscreteFiniteBounds<i8>>
//! impl From<DiscreteFiniteBounds<i8>> for Reservation {
//! fn from(bounds: DiscreteFiniteBounds<i8>) -> Self {
//! // Second, we need to implement From<Interval<i8>>
//! impl From<Interval<i8>> for Reservation {
//! fn from(bounds: Interval<i8>) -> Self {
//! if bounds.end == i8::MAX {
//! Reservation::Infinite(bounds.start)
//! } else {
@@ -271,14 +270,14 @@ pub mod test_ranges;
pub(crate) mod utils;
pub mod discrete_finite;
pub mod discrete_finite_bounds;
pub mod interval;
pub mod discrete_range_map;
pub mod discrete_range_set;
pub use crate::discrete_finite::DiscreteFinite;
pub use crate::discrete_finite_bounds::DiscreteFiniteBounds;
pub use crate::discrete_range_map::{
DiscreteRangeMap, FiniteRange, OverlapError,
};
pub use crate::discrete_range_set::DiscreteRangeSet;
pub use crate::interval::Interval;
src/test_ranges.rs
+17 -17
View File
@@ -1,26 +1,26 @@
use crate::discrete_finite::DiscreteFinite;
use crate::discrete_finite_bounds::DiscreteFiniteBounds;
use crate::interval::Interval;
pub fn uu() -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn uu() -> Interval<i8> {
Interval {
start: i8::MIN,
end: i8::MAX,
}
}
pub fn ui(x: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn ui(x: i8) -> Interval<i8> {
Interval {
start: i8::MIN,
end: x,
}
}
pub fn ue(x: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn ue(x: i8) -> Interval<i8> {
Interval {
start: i8::MIN,
end: x.down().unwrap(),
}
}
pub fn iu(x: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn iu(x: i8) -> Interval<i8> {
Interval {
start: x,
end: i8::MAX,
}
@@ -28,23 +28,23 @@ pub fn iu(x: i8) -> DiscreteFiniteBounds<i8> {
//fn eu(x: i8) -> TestBounds {
//(Bound::Excluded(x), Bound::Unbounded)
//}
pub fn ii(x1: i8, x2: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds { start: x1, end: x2 }
pub fn ii(x1: i8, x2: i8) -> Interval<i8> {
Interval { start: x1, end: x2 }
}
pub fn ie(x1: i8, x2: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn ie(x1: i8, x2: i8) -> Interval<i8> {
Interval {
start: x1,
end: x2.down().unwrap(),
}
}
pub fn ei(x1: i8, x2: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn ei(x1: i8, x2: i8) -> Interval<i8> {
Interval {
start: x1.up().unwrap(),
end: x2,
}
}
pub fn ee(x1: i8, x2: i8) -> DiscreteFiniteBounds<i8> {
DiscreteFiniteBounds {
pub fn ee(x1: i8, x2: i8) -> Interval<i8> {
Interval {
start: x1.up().unwrap(),
end: x2.down().unwrap(),
}
src/utils.rs
+19 -19
View File
@@ -20,8 +20,8 @@ along with discrete_range_map. If not, see <https://www.gnu.org/licenses/>.
use std::cmp::Ordering;
use crate::discrete_finite::DiscreteFinite;
use crate::discrete_finite_bounds::DiscreteFiniteBounds;
use crate::discrete_range_map::FiniteRange;
use crate::interval::Interval;
pub(crate) fn cmp_point_with_range<I, K>(point: I, range: K) -> Ordering
where
@@ -71,9 +71,9 @@ where
}
enum SortedConfig<I> {
NonOverlapping(DiscreteFiniteBounds<I>, DiscreteFiniteBounds<I>),
PartialOverlap(DiscreteFiniteBounds<I>, DiscreteFiniteBounds<I>),
Swallowed(DiscreteFiniteBounds<I>, DiscreteFiniteBounds<I>),
NonOverlapping(Interval<I>, Interval<I>),
PartialOverlap(Interval<I>, Interval<I>),
Swallowed(Interval<I>, Interval<I>),
}
fn sorted_config<I, A, B>(a: A, b: B) -> SortedConfig<I>
where
@@ -81,11 +81,11 @@ where
B: FiniteRange<I> + Copy,
I: Ord,
{
let ae = DiscreteFiniteBounds {
let ae = Interval {
start: a.start(),
end: a.end(),
};
let be = DiscreteFiniteBounds {
let be = Interval {
start: b.start(),
end: b.end(),
};
@@ -114,9 +114,9 @@ where
#[derive(Debug)]
pub(crate) struct CutResult<I> {
pub(crate) before_cut: Option<DiscreteFiniteBounds<I>>,
pub(crate) inside_cut: Option<DiscreteFiniteBounds<I>>,
pub(crate) after_cut: Option<DiscreteFiniteBounds<I>>,
pub(crate) before_cut: Option<Interval<I>>,
pub(crate) inside_cut: Option<Interval<I>>,
pub(crate) after_cut: Option<Interval<I>>,
}
pub(crate) fn cut_range<I, B, C>(base: B, cut: C) -> CutResult<I>
where
@@ -132,34 +132,34 @@ where
match config(base, cut) {
Config::LeftFirstNonOverlapping => {
result.before_cut = Some(DiscreteFiniteBounds {
result.before_cut = Some(Interval {
start: base.start(),
end: base.end(),
});
}
Config::LeftFirstPartialOverlap => {
result.before_cut = Some(DiscreteFiniteBounds {
result.before_cut = Some(Interval {
start: base.start(),
end: cut.start().down().unwrap(),
});
result.inside_cut = Some(DiscreteFiniteBounds {
result.inside_cut = Some(Interval {
start: cut.start(),
end: base.end(),
});
}
Config::LeftContainsRight => {
result.before_cut = Some(DiscreteFiniteBounds {
result.before_cut = Some(Interval {
start: base.start(),
end: cut.start().down().unwrap(),
});
result.inside_cut = Some(DiscreteFiniteBounds {
result.inside_cut = Some(Interval {
start: cut.start(),
end: cut.end(),
});
//if cut is already max then we don't need to have an
//after_cut
if let Some(upped_end) = cut.end().up() {
result.after_cut = Some(DiscreteFiniteBounds {
result.after_cut = Some(Interval {
start: upped_end,
end: base.end(),
});
@@ -167,23 +167,23 @@ where
}
Config::RightFirstNonOverlapping => {
result.after_cut = Some(DiscreteFiniteBounds {
result.after_cut = Some(Interval {
start: base.start(),
end: base.end(),
});
}
Config::RightFirstPartialOverlap => {
result.after_cut = Some(DiscreteFiniteBounds {
result.after_cut = Some(Interval {
start: cut.end().up().unwrap(),
end: base.end(),
});
result.inside_cut = Some(DiscreteFiniteBounds {
result.inside_cut = Some(Interval {
start: base.start(),
end: cut.end(),
});
}
Config::RightContainsLeft => {
result.inside_cut = Some(DiscreteFiniteBounds {
result.inside_cut = Some(Interval {
start: base.start(),
end: base.end(),
});