use nodit::interval::ie;
use nodit::NoditMap;

let mut map = NoditMap::new();

map.insert_strict(ie(0, 5), true);
map.insert_strict(ie(5, 10), false);

assert_eq!(map.overlaps(ie(-2, 12)), true);
assert_eq!(map.contains_point(20), false);
assert_eq!(map.contains_point(5), true);

但仅限于某些方法，因此如果您不确定，请检查方法的特征限制。

use std::ops::{Bound, RangeBounds};

use nodit::interval::ie;
use nodit::{
	DiscreteFinite, InclusiveInterval, Interval, NoditMap,
};

#[derive(Debug, Copy, Clone)]
enum Reservation {
	// Start, End (Inclusive-Inclusive)
	Finite(i8, i8),
	// Start (Inclusive-Infinity)
	Infinite(i8),
}

// First, we need to implement InclusiveInterval
impl InclusiveInterval<i8> for Reservation {
	fn start(&self) -> i8 {
		match self {
			Reservation::Finite(start, _) => *start,
			Reservation::Infinite(start) => *start,
		}
	}
	fn end(&self) -> i8 {
		match self {
			Reservation::Finite(_, end) => *end,
			Reservation::Infinite(_) => i8::MAX,
		}
	}
}

// Second, we need to implement From<Interval<i8>>
impl From<Interval<i8>> for Reservation {
	fn from(value: Interval<i8>) -> Self {
		if value.end() == i8::MAX {
			Reservation::Infinite(value.start())
		} else {
			Reservation::Finite(
				value.start(),
				value.end().up().unwrap(),
			)
		}
	}
}

// Next we can create a custom typed NoditMap
let reservation_map = NoditMap::from_slice_strict([
	(Reservation::Finite(10, 20), "Ferris".to_string()),
	(Reservation::Infinite(21), "Corro".to_string()),
])
.unwrap();

for (reservation, name) in reservation_map.overlapping(ie(16, 17))
{
	println!(
		"{name} has reserved {reservation:?} inside the interval 16..17"
	);
}

for (reservation, name) in reservation_map.iter() {
	println!("{name} has reserved {reservation:?}");
}

assert_eq!(
	reservation_map.overlaps(Reservation::Infinite(0)),
	true
);

示例使用包含-排除区间

示例使用自定义区间类型

此软件包旨在与离散类型（如Discrete）一起使用，而不是与连续类型（如Continuous）一起使用。例如，u8是一种离散类型，但如果将其解析为十进制值，则String是一种连续类型。

之所以如此，是因为常见的区间数学运算取决于基础类型是离散类型还是连续类型。例如，5..=6触及7..=8，因为整数是离散的，但5.0..=6.0不会触及7.0..=8.0，因为存在值6.5。

重要的是，这也使得包含/不包含端点的区间很容易处理，因为它们可以无损地在彼此之间转换。例如，3..6等同于3..=5。

有限性

目前，此软件包仅设计用于与有限类型（如u8或i128）一起使用，而不是与无限类型（如BigInt）一起使用，后者来自num_bigint软件包。这是因为如果类型是无限类型（如BigInt），则get_key_value_at_point()方法将无法从空映射中返回任何内容，因为它没有最大值。

当您不需要达到类型的顶部端点时，可以使用实际无限来模拟无限类型，这是一种有用的技巧。例如，如果您使用u8作为您的点类型，则可以创建一个包装类型，如下所示

use std::cmp::Ordering;

use nodit::DiscreteFinite;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum WithInfinity<T> {
	Finite(T),
	Infinity,
}

impl<T> Ord for WithInfinity<T>
where
	T: Ord,
{
	fn cmp(&self, other: &Self) -> Ordering {
		match (self, other) {
			(
				WithInfinity::Finite(x),
				WithInfinity::Finite(y),
			) => x.cmp(y),
			(WithInfinity::Finite(_), WithInfinity::Infinity) => {
				Ordering::Less
			}
			(WithInfinity::Infinity, WithInfinity::Finite(_)) => {
				Ordering::Greater
			}
			(WithInfinity::Infinity, WithInfinity::Infinity) => {
				Ordering::Equal
			}
		}
	}
}

impl<T> PartialOrd for WithInfinity<T>
where
	T: Ord,
{
	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
		Some(self.cmp(other))
	}
}

impl<T> DiscreteFinite for WithInfinity<T>
where
	T: DiscreteFinite,
{
	const MIN: Self = WithInfinity::Finite(T::MIN);
	const MAX: Self = WithInfinity::Infinity;

	fn up(self) -> Option<Self>
	where
		Self: Sized,
	{
		match self {
			WithInfinity::Finite(x) => match x.up() {
				Some(y) => Some(WithInfinity::Finite(y)),
				None => Some(WithInfinity::Infinity),
			},
			WithInfinity::Infinity => None,
		}
	}
	fn down(self) -> Option<Self>
	where
		Self: Sized,
	{
		match self {
			WithInfinity::Finite(x) => {
				Some(WithInfinity::Finite(x.down()?))
			}
			WithInfinity::Infinity => {
				Some(WithInfinity::Finite(T::MAX))
			}
		}
	}
}

// And then you this means you can be explicit with when
// Infinity is encountered such as when it might be
// returned by `get_key_value_at_point()`, for example:

use nodit::interval::uu;
use nodit::{Interval, NoditMap};

let map: NoditMap<
	WithInfinity<u8>,
	Interval<WithInfinity<u8>>,
	bool,
> = NoditMap::new();

let mut gap = map.get_key_value_at_point(WithInfinity::Finite(4));

assert_eq!(gap, Err(uu()));

无效区间

在此软件包中，并非所有区间都被认为是有效的区间。此软件包中使用的区间有效性的定义是：一个区间仅当它包含基础域的至少一个值时才有效。

例如，4..6 被视为有效，因为它包含值 4 和 5，但是 4..4 被视为无效，因为它不包含任何值。另一个无效区间的例子是起始值大于结束值的区间。例如，5..2 或 100..=40。

以下是几个区间及其有效性的示例

重叠

如果有某个点同时包含在两个区间内，则称两个区间“重叠”。例如，2..4 和 2..6 重叠，但 2..4 和 4..8 不重叠。