RangeSet

ranges_ext

Struct RangeSet 

Source 
pub struct RangeSet<T, K = (), const C: usize = 128>
where
    T: Ord + Copy,
    K: Debug + Eq + Clone,
{ /* private fields */ }
Expand description

一个「区间集合」数据结构：维护一组有序、互不重叠的半开区间 [start, end)。

  • 插入时会把重叠/相邻且 kind 相等的区间自动合并。
  • 删除一个区间时，会从集合里移除交集；必要时把已有区间拆成左右两段。

约定：空区间（start >= end）会被忽略。

Implementations§

Source§

impl<T, K, const C: usize> RangeSet<T, K, C>
where T: Ord + Copy, K: Debug + Eq + Clone,

Source

pub fn new() -> Self

创建空集合。

Examples found in repository?
examples/debug_demo.rs (line 4)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    let mut set: RangeSet<i32, (), 16> = RangeSet::new();
5    set.add(1..5, ())?;
6    set.add(3..8, ())?;
7    set.add(10..15, ())?;
8    set.add(12..18, ())?;
9
10    println!("=== 区间合并结果 ===");
11    for (i, info) in set.iter().enumerate() {
12        println!("Element {}: [{}, {})", i, info.range.start, info.range.end);
13    }
14
15    println!("\n=== Debug 格式 ===");
16    for (i, info) in set.iter().enumerate() {
17        println!("Element {}: {:?}", i, info);
18    }
19
20    println!("\n=== 完整切片 ===");
21    println!("{:?}", set.as_slice());
22
23    Ok(())
24}
More examples
Hide additional examples
examples/key_demo.rs (line 5)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    // 使用字符串作为 kind 的示例
5    let mut set: RangeSet<i32, &str> = RangeSet::new();
6
7    // 添加不同类型的区间（使用不同的 kind）
8    set.add(0..10, "type_a")?;
9    set.add(5..15, "type_b")?; // 与 type_a 重叠，但 kind 不同，会分割
10    set.add(20..30, "type_a")?;
11    set.add(25..35, "type_a")?; // 与上一个 type_a 重叠，会合并
12
13    println!("=== 带 kind 的区间集合 ===");
14    for info in set.iter() {
15        println!(
16            "Range: [{}, {}), Kind: {:?}",
17            info.range.start, info.range.end, info.kind
18        );
19    }
20
21    // 演示：只有 kind 相同的相邻区间才会合并
22    let mut set2: RangeSet<i32, i32> = RangeSet::new();
23    set2.add(0..10, 1)?;
24    set2.add(10..20, 1)?; // kind 相同且相邻，会合并
25    set2.add(20..30, 2)?; // kind 不同，不合并
26    set2.add(30..40, 2)?; // kind 相同且相邻，会合并
27
28    println!("\n=== 相邻区间合并示例 ===");
29    for info in set2.iter() {
30        println!(
31            "Range: [{}, {}), Kind: {}",
32            info.range.start, info.range.end, info.kind
33        );
34    }
35
36    Ok(())
37}
examples/overlap_demo.rs (line 6)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("=== 测试：kind 不同时，后者覆盖交集 ===\n");
5
6    let mut set = RangeSet::<i32, &str>::new();
7
8    // 场景 1: 完全覆盖
9    println!("场景 1: 完全覆盖");
10    set.add(10..20, "A")?;
11    println!("添加 [10, 20) kind=A");
12    for info in set.iter() {
13        println!(
14            "  [{}, {}) kind={}",
15            info.range.start, info.range.end, info.kind
16        );
17    }
18
19    set.add(10..20, "B")?;
20    println!("添加 [10, 20) kind=B (完全覆盖)");
21    for info in set.iter() {
22        println!(
23            "  [{}, {}) kind={}",
24            info.range.start, info.range.end, info.kind
25        );
26    }
27
28    // 场景 2: 部分覆盖（左侧）
29    println!("\n场景 2: 部分覆盖（左侧）");
30    set.clear();
31    set.add(10..30, "A")?;
32    println!("添加 [10, 30) kind=A");
33    for info in set.iter() {
34        println!(
35            "  [{}, {}) kind={}",
36            info.range.start, info.range.end, info.kind
37        );
38    }
39
40    set.add(5..20, "B")?;
41    println!("添加 [5, 20) kind=B (覆盖左侧)");
42    for info in set.iter() {
43        println!(
44            "  [{}, {}) kind={}",
45            info.range.start, info.range.end, info.kind
46        );
47    }
48
49    // 场景 3: 部分覆盖（右侧）
50    println!("\n场景 3: 部分覆盖（右侧）");
51    set.clear();
52    set.add(10..30, "A")?;
53    println!("添加 [10, 30) kind=A");
54    for info in set.iter() {
55        println!(
56            "  [{}, {}) kind={}",
57            info.range.start, info.range.end, info.kind
58        );
59    }
60
61    set.add(20..35, "B")?;
62    println!("添加 [20, 35) kind=B (覆盖右侧)");
63    for info in set.iter() {
64        println!(
65            "  [{}, {}) kind={}",
66            info.range.start, info.range.end, info.kind
67        );
68    }
69
70    // 场景 4: 中间覆盖（分裂原区间）
71    println!("\n场景 4: 中间覆盖（分裂原区间）");
72    set.clear();
73    set.add(10..40, "A")?;
74    println!("添加 [10, 40) kind=A");
75    for info in set.iter() {
76        println!(
77            "  [{}, {}) kind={}",
78            info.range.start, info.range.end, info.kind
79        );
80    }
81
82    set.add(20..30, "B")?;
83    println!("添加 [20, 30) kind=B (覆盖中间，分裂 A)");
84    for info in set.iter() {
85        println!(
86            "  [{}, {}) kind={}",
87            info.range.start, info.range.end, info.kind
88        );
89    }
90
91    // 场景 5: kind 相同时合并
92    println!("\n场景 5: kind 相同时合并（对比）");
93    set.clear();
94    set.add(10..20, "A")?;
95    set.add(30..40, "A")?;
96    println!("添加 [10, 20) kind=A 和 [30, 40) kind=A");
97    for info in set.iter() {
98        println!(
99            "  [{}, {}) kind={}",
100            info.range.start, info.range.end, info.kind
101        );
102    }
103
104    set.add(15..35, "A")?;
105    println!("添加 [15, 35) kind=A (相同 kind，合并)");
106    for info in set.iter() {
107        println!(
108            "  [{}, {}) kind={}",
109            info.range.start, info.range.end, info.kind
110        );
111    }
112
113    // 场景 6: 复杂场景 - 多个区间
114    println!("\n场景 6: 复杂场景 - 覆盖多个不同 kind 的区间");
115    set.clear();
116    set.add(0..10, "A")?;
117    set.add(10..20, "B")?;
118    set.add(20..30, "C")?;
119    println!("初始状态:");
120    for info in set.iter() {
121        println!(
122            "  [{}, {}) kind={}",
123            info.range.start, info.range.end, info.kind
124        );
125    }
126
127    set.add(5..25, "D")?;
128    println!("添加 [5, 25) kind=D (覆盖三个区间的部分)");
129    for info in set.iter() {
130        println!(
131            "  [{}, {}) kind={}",
132            info.range.start, info.range.end, info.kind
133        );
134    }
135
136    Ok(())
137}
Source

pub fn as_slice(&self) -> &[RangeInfo<T, K>]

返回内部区间的切片（已排序、已合并、互不重叠）。

Examples found in repository?
examples/debug_demo.rs (line 21)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    let mut set: RangeSet<i32, (), 16> = RangeSet::new();
5    set.add(1..5, ())?;
6    set.add(3..8, ())?;
7    set.add(10..15, ())?;
8    set.add(12..18, ())?;
9
10    println!("=== 区间合并结果 ===");
11    for (i, info) in set.iter().enumerate() {
12        println!("Element {}: [{}, {})", i, info.range.start, info.range.end);
13    }
14
15    println!("\n=== Debug 格式 ===");
16    for (i, info) in set.iter().enumerate() {
17        println!("Element {}: {:?}", i, info);
18    }
19
20    println!("\n=== 完整切片 ===");
21    println!("{:?}", set.as_slice());
22
23    Ok(())
24}
Source

pub fn iter(&self) -> impl Iterator<Item = &RangeInfo<T, K>>

返回区间迭代器（零拷贝）。

Examples found in repository?
examples/debug_demo.rs (line 11)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    let mut set: RangeSet<i32, (), 16> = RangeSet::new();
5    set.add(1..5, ())?;
6    set.add(3..8, ())?;
7    set.add(10..15, ())?;
8    set.add(12..18, ())?;
9
10    println!("=== 区间合并结果 ===");
11    for (i, info) in set.iter().enumerate() {
12        println!("Element {}: [{}, {})", i, info.range.start, info.range.end);
13    }
14
15    println!("\n=== Debug 格式 ===");
16    for (i, info) in set.iter().enumerate() {
17        println!("Element {}: {:?}", i, info);
18    }
19
20    println!("\n=== 完整切片 ===");
21    println!("{:?}", set.as_slice());
22
23    Ok(())
24}
More examples
Hide additional examples
examples/key_demo.rs (line 14)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    // 使用字符串作为 kind 的示例
5    let mut set: RangeSet<i32, &str> = RangeSet::new();
6
7    // 添加不同类型的区间（使用不同的 kind）
8    set.add(0..10, "type_a")?;
9    set.add(5..15, "type_b")?; // 与 type_a 重叠，但 kind 不同，会分割
10    set.add(20..30, "type_a")?;
11    set.add(25..35, "type_a")?; // 与上一个 type_a 重叠，会合并
12
13    println!("=== 带 kind 的区间集合 ===");
14    for info in set.iter() {
15        println!(
16            "Range: [{}, {}), Kind: {:?}",
17            info.range.start, info.range.end, info.kind
18        );
19    }
20
21    // 演示：只有 kind 相同的相邻区间才会合并
22    let mut set2: RangeSet<i32, i32> = RangeSet::new();
23    set2.add(0..10, 1)?;
24    set2.add(10..20, 1)?; // kind 相同且相邻，会合并
25    set2.add(20..30, 2)?; // kind 不同，不合并
26    set2.add(30..40, 2)?; // kind 相同且相邻，会合并
27
28    println!("\n=== 相邻区间合并示例 ===");
29    for info in set2.iter() {
30        println!(
31            "Range: [{}, {}), Kind: {}",
32            info.range.start, info.range.end, info.kind
33        );
34    }
35
36    Ok(())
37}
examples/overlap_demo.rs (line 12)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("=== 测试：kind 不同时，后者覆盖交集 ===\n");
5
6    let mut set = RangeSet::<i32, &str>::new();
7
8    // 场景 1: 完全覆盖
9    println!("场景 1: 完全覆盖");
10    set.add(10..20, "A")?;
11    println!("添加 [10, 20) kind=A");
12    for info in set.iter() {
13        println!(
14            "  [{}, {}) kind={}",
15            info.range.start, info.range.end, info.kind
16        );
17    }
18
19    set.add(10..20, "B")?;
20    println!("添加 [10, 20) kind=B (完全覆盖)");
21    for info in set.iter() {
22        println!(
23            "  [{}, {}) kind={}",
24            info.range.start, info.range.end, info.kind
25        );
26    }
27
28    // 场景 2: 部分覆盖（左侧）
29    println!("\n场景 2: 部分覆盖（左侧）");
30    set.clear();
31    set.add(10..30, "A")?;
32    println!("添加 [10, 30) kind=A");
33    for info in set.iter() {
34        println!(
35            "  [{}, {}) kind={}",
36            info.range.start, info.range.end, info.kind
37        );
38    }
39
40    set.add(5..20, "B")?;
41    println!("添加 [5, 20) kind=B (覆盖左侧)");
42    for info in set.iter() {
43        println!(
44            "  [{}, {}) kind={}",
45            info.range.start, info.range.end, info.kind
46        );
47    }
48
49    // 场景 3: 部分覆盖（右侧）
50    println!("\n场景 3: 部分覆盖（右侧）");
51    set.clear();
52    set.add(10..30, "A")?;
53    println!("添加 [10, 30) kind=A");
54    for info in set.iter() {
55        println!(
56            "  [{}, {}) kind={}",
57            info.range.start, info.range.end, info.kind
58        );
59    }
60
61    set.add(20..35, "B")?;
62    println!("添加 [20, 35) kind=B (覆盖右侧)");
63    for info in set.iter() {
64        println!(
65            "  [{}, {}) kind={}",
66            info.range.start, info.range.end, info.kind
67        );
68    }
69
70    // 场景 4: 中间覆盖（分裂原区间）
71    println!("\n场景 4: 中间覆盖（分裂原区间）");
72    set.clear();
73    set.add(10..40, "A")?;
74    println!("添加 [10, 40) kind=A");
75    for info in set.iter() {
76        println!(
77            "  [{}, {}) kind={}",
78            info.range.start, info.range.end, info.kind
79        );
80    }
81
82    set.add(20..30, "B")?;
83    println!("添加 [20, 30) kind=B (覆盖中间，分裂 A)");
84    for info in set.iter() {
85        println!(
86            "  [{}, {}) kind={}",
87            info.range.start, info.range.end, info.kind
88        );
89    }
90
91    // 场景 5: kind 相同时合并
92    println!("\n场景 5: kind 相同时合并（对比）");
93    set.clear();
94    set.add(10..20, "A")?;
95    set.add(30..40, "A")?;
96    println!("添加 [10, 20) kind=A 和 [30, 40) kind=A");
97    for info in set.iter() {
98        println!(
99            "  [{}, {}) kind={}",
100            info.range.start, info.range.end, info.kind
101        );
102    }
103
104    set.add(15..35, "A")?;
105    println!("添加 [15, 35) kind=A (相同 kind，合并)");
106    for info in set.iter() {
107        println!(
108            "  [{}, {}) kind={}",
109            info.range.start, info.range.end, info.kind
110        );
111    }
112
113    // 场景 6: 复杂场景 - 多个区间
114    println!("\n场景 6: 复杂场景 - 覆盖多个不同 kind 的区间");
115    set.clear();
116    set.add(0..10, "A")?;
117    set.add(10..20, "B")?;
118    set.add(20..30, "C")?;
119    println!("初始状态:");
120    for info in set.iter() {
121        println!(
122            "  [{}, {}) kind={}",
123            info.range.start, info.range.end, info.kind
124        );
125    }
126
127    set.add(5..25, "D")?;
128    println!("添加 [5, 25) kind=D (覆盖三个区间的部分)");
129    for info in set.iter() {
130        println!(
131            "  [{}, {}) kind={}",
132            info.range.start, info.range.end, info.kind
133        );
134    }
135
136    Ok(())
137}
Source

pub fn is_empty(&self) -> bool

Source

pub fn len(&self) -> usize

Source

pub fn clear(&mut self)

Examples found in repository?
examples/overlap_demo.rs (line 30)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("=== 测试：kind 不同时，后者覆盖交集 ===\n");
5
6    let mut set = RangeSet::<i32, &str>::new();
7
8    // 场景 1: 完全覆盖
9    println!("场景 1: 完全覆盖");
10    set.add(10..20, "A")?;
11    println!("添加 [10, 20) kind=A");
12    for info in set.iter() {
13        println!(
14            "  [{}, {}) kind={}",
15            info.range.start, info.range.end, info.kind
16        );
17    }
18
19    set.add(10..20, "B")?;
20    println!("添加 [10, 20) kind=B (完全覆盖)");
21    for info in set.iter() {
22        println!(
23            "  [{}, {}) kind={}",
24            info.range.start, info.range.end, info.kind
25        );
26    }
27
28    // 场景 2: 部分覆盖（左侧）
29    println!("\n场景 2: 部分覆盖（左侧）");
30    set.clear();
31    set.add(10..30, "A")?;
32    println!("添加 [10, 30) kind=A");
33    for info in set.iter() {
34        println!(
35            "  [{}, {}) kind={}",
36            info.range.start, info.range.end, info.kind
37        );
38    }
39
40    set.add(5..20, "B")?;
41    println!("添加 [5, 20) kind=B (覆盖左侧)");
42    for info in set.iter() {
43        println!(
44            "  [{}, {}) kind={}",
45            info.range.start, info.range.end, info.kind
46        );
47    }
48
49    // 场景 3: 部分覆盖（右侧）
50    println!("\n场景 3: 部分覆盖（右侧）");
51    set.clear();
52    set.add(10..30, "A")?;
53    println!("添加 [10, 30) kind=A");
54    for info in set.iter() {
55        println!(
56            "  [{}, {}) kind={}",
57            info.range.start, info.range.end, info.kind
58        );
59    }
60
61    set.add(20..35, "B")?;
62    println!("添加 [20, 35) kind=B (覆盖右侧)");
63    for info in set.iter() {
64        println!(
65            "  [{}, {}) kind={}",
66            info.range.start, info.range.end, info.kind
67        );
68    }
69
70    // 场景 4: 中间覆盖（分裂原区间）
71    println!("\n场景 4: 中间覆盖（分裂原区间）");
72    set.clear();
73    set.add(10..40, "A")?;
74    println!("添加 [10, 40) kind=A");
75    for info in set.iter() {
76        println!(
77            "  [{}, {}) kind={}",
78            info.range.start, info.range.end, info.kind
79        );
80    }
81
82    set.add(20..30, "B")?;
83    println!("添加 [20, 30) kind=B (覆盖中间，分裂 A)");
84    for info in set.iter() {
85        println!(
86            "  [{}, {}) kind={}",
87            info.range.start, info.range.end, info.kind
88        );
89    }
90
91    // 场景 5: kind 相同时合并
92    println!("\n场景 5: kind 相同时合并（对比）");
93    set.clear();
94    set.add(10..20, "A")?;
95    set.add(30..40, "A")?;
96    println!("添加 [10, 20) kind=A 和 [30, 40) kind=A");
97    for info in set.iter() {
98        println!(
99            "  [{}, {}) kind={}",
100            info.range.start, info.range.end, info.kind
101        );
102    }
103
104    set.add(15..35, "A")?;
105    println!("添加 [15, 35) kind=A (相同 kind，合并)");
106    for info in set.iter() {
107        println!(
108            "  [{}, {}) kind={}",
109            info.range.start, info.range.end, info.kind
110        );
111    }
112
113    // 场景 6: 复杂场景 - 多个区间
114    println!("\n场景 6: 复杂场景 - 覆盖多个不同 kind 的区间");
115    set.clear();
116    set.add(0..10, "A")?;
117    set.add(10..20, "B")?;
118    set.add(20..30, "C")?;
119    println!("初始状态:");
120    for info in set.iter() {
121        println!(
122            "  [{}, {}) kind={}",
123            info.range.start, info.range.end, info.kind
124        );
125    }
126
127    set.add(5..25, "D")?;
128    println!("添加 [5, 25) kind=D (覆盖三个区间的部分)");
129    for info in set.iter() {
130        println!(
131            "  [{}, {}) kind={}",
132            info.range.start, info.range.end, info.kind
133        );
134    }
135
136    Ok(())
137}
Source

pub fn add(&mut self, range: Range<T>, kind: K) -> Result<(), CapacityError>

添加一个区间；会把与其重叠或相邻且 kind 相等的区间自动合并。 对于 kind 不同的重叠区间，新区间会覆盖旧区间。

§Errors

如果容量不足，返回 CapacityError。

Examples found in repository?
examples/debug_demo.rs (line 5)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    let mut set: RangeSet<i32, (), 16> = RangeSet::new();
5    set.add(1..5, ())?;
6    set.add(3..8, ())?;
7    set.add(10..15, ())?;
8    set.add(12..18, ())?;
9
10    println!("=== 区间合并结果 ===");
11    for (i, info) in set.iter().enumerate() {
12        println!("Element {}: [{}, {})", i, info.range.start, info.range.end);
13    }
14
15    println!("\n=== Debug 格式 ===");
16    for (i, info) in set.iter().enumerate() {
17        println!("Element {}: {:?}", i, info);
18    }
19
20    println!("\n=== 完整切片 ===");
21    println!("{:?}", set.as_slice());
22
23    Ok(())
24}
More examples
Hide additional examples
examples/key_demo.rs (line 8)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    // 使用字符串作为 kind 的示例
5    let mut set: RangeSet<i32, &str> = RangeSet::new();
6
7    // 添加不同类型的区间（使用不同的 kind）
8    set.add(0..10, "type_a")?;
9    set.add(5..15, "type_b")?; // 与 type_a 重叠，但 kind 不同，会分割
10    set.add(20..30, "type_a")?;
11    set.add(25..35, "type_a")?; // 与上一个 type_a 重叠，会合并
12
13    println!("=== 带 kind 的区间集合 ===");
14    for info in set.iter() {
15        println!(
16            "Range: [{}, {}), Kind: {:?}",
17            info.range.start, info.range.end, info.kind
18        );
19    }
20
21    // 演示：只有 kind 相同的相邻区间才会合并
22    let mut set2: RangeSet<i32, i32> = RangeSet::new();
23    set2.add(0..10, 1)?;
24    set2.add(10..20, 1)?; // kind 相同且相邻，会合并
25    set2.add(20..30, 2)?; // kind 不同，不合并
26    set2.add(30..40, 2)?; // kind 相同且相邻，会合并
27
28    println!("\n=== 相邻区间合并示例 ===");
29    for info in set2.iter() {
30        println!(
31            "Range: [{}, {}), Kind: {}",
32            info.range.start, info.range.end, info.kind
33        );
34    }
35
36    Ok(())
37}
examples/overlap_demo.rs (line 10)
3fn main() -> Result<(), Box<dyn std::error::Error>> {
4    println!("=== 测试：kind 不同时，后者覆盖交集 ===\n");
5
6    let mut set = RangeSet::<i32, &str>::new();
7
8    // 场景 1: 完全覆盖
9    println!("场景 1: 完全覆盖");
10    set.add(10..20, "A")?;
11    println!("添加 [10, 20) kind=A");
12    for info in set.iter() {
13        println!(
14            "  [{}, {}) kind={}",
15            info.range.start, info.range.end, info.kind
16        );
17    }
18
19    set.add(10..20, "B")?;
20    println!("添加 [10, 20) kind=B (完全覆盖)");
21    for info in set.iter() {
22        println!(
23            "  [{}, {}) kind={}",
24            info.range.start, info.range.end, info.kind
25        );
26    }
27
28    // 场景 2: 部分覆盖（左侧）
29    println!("\n场景 2: 部分覆盖（左侧）");
30    set.clear();
31    set.add(10..30, "A")?;
32    println!("添加 [10, 30) kind=A");
33    for info in set.iter() {
34        println!(
35            "  [{}, {}) kind={}",
36            info.range.start, info.range.end, info.kind
37        );
38    }
39
40    set.add(5..20, "B")?;
41    println!("添加 [5, 20) kind=B (覆盖左侧)");
42    for info in set.iter() {
43        println!(
44            "  [{}, {}) kind={}",
45            info.range.start, info.range.end, info.kind
46        );
47    }
48
49    // 场景 3: 部分覆盖（右侧）
50    println!("\n场景 3: 部分覆盖（右侧）");
51    set.clear();
52    set.add(10..30, "A")?;
53    println!("添加 [10, 30) kind=A");
54    for info in set.iter() {
55        println!(
56            "  [{}, {}) kind={}",
57            info.range.start, info.range.end, info.kind
58        );
59    }
60
61    set.add(20..35, "B")?;
62    println!("添加 [20, 35) kind=B (覆盖右侧)");
63    for info in set.iter() {
64        println!(
65            "  [{}, {}) kind={}",
66            info.range.start, info.range.end, info.kind
67        );
68    }
69
70    // 场景 4: 中间覆盖（分裂原区间）
71    println!("\n场景 4: 中间覆盖（分裂原区间）");
72    set.clear();
73    set.add(10..40, "A")?;
74    println!("添加 [10, 40) kind=A");
75    for info in set.iter() {
76        println!(
77            "  [{}, {}) kind={}",
78            info.range.start, info.range.end, info.kind
79        );
80    }
81
82    set.add(20..30, "B")?;
83    println!("添加 [20, 30) kind=B (覆盖中间，分裂 A)");
84    for info in set.iter() {
85        println!(
86            "  [{}, {}) kind={}",
87            info.range.start, info.range.end, info.kind
88        );
89    }
90
91    // 场景 5: kind 相同时合并
92    println!("\n场景 5: kind 相同时合并（对比）");
93    set.clear();
94    set.add(10..20, "A")?;
95    set.add(30..40, "A")?;
96    println!("添加 [10, 20) kind=A 和 [30, 40) kind=A");
97    for info in set.iter() {
98        println!(
99            "  [{}, {}) kind={}",
100            info.range.start, info.range.end, info.kind
101        );
102    }
103
104    set.add(15..35, "A")?;
105    println!("添加 [15, 35) kind=A (相同 kind，合并)");
106    for info in set.iter() {
107        println!(
108            "  [{}, {}) kind={}",
109            info.range.start, info.range.end, info.kind
110        );
111    }
112
113    // 场景 6: 复杂场景 - 多个区间
114    println!("\n场景 6: 复杂场景 - 覆盖多个不同 kind 的区间");
115    set.clear();
116    set.add(0..10, "A")?;
117    set.add(10..20, "B")?;
118    set.add(20..30, "C")?;
119    println!("初始状态:");
120    for info in set.iter() {
121        println!(
122            "  [{}, {}) kind={}",
123            info.range.start, info.range.end, info.kind
124        );
125    }
126
127    set.add(5..25, "D")?;
128    println!("添加 [5, 25) kind=D (覆盖三个区间的部分)");
129    for info in set.iter() {
130        println!(
131            "  [{}, {}) kind={}",
132            info.range.start, info.range.end, info.kind
133        );
134    }
135
136    Ok(())
137}
Source

pub fn contains(&self, value: T) -> bool

查询某个值是否落在任意一个区间中。

Source

pub fn remove(&mut self, range: Range<T>) -> Result<(), CapacityError>

删除一个区间：从集合中移除与其相交的部分。

若被删除区间位于某个已有区间内部，会导致该已有区间被拆分为两段（保留原有 kind）。

§Errors

如果容量不足（删除操作导致区间分裂，新区间数量超过容量），返回 CapacityError。

Source

pub fn extend<I>(&mut self, ranges: I) -> Result<(), CapacityError>
where I: IntoIterator<Item = (Range<T>, K)>,

批量添加多个区间。

§Errors

如果容量不足，返回 CapacityError。

Trait Implementations§

Source§

impl<T, K, const C: usize> Clone for RangeSet<T, K, C>
where T: Ord + Copy + Clone, K: Debug + Eq + Clone + Clone,

Source§

fn clone(&self) -> RangeSet<T, K, C>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<T, K, const C: usize> Debug for RangeSet<T, K, C>
where T: Ord + Copy + Debug, K: Debug + Eq + Clone + Debug,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<T, K, const C: usize> Default for RangeSet<T, K, C>
where T: Ord + Copy, K: Debug + Eq + Clone,

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<T, K, const C: usize> Freeze for RangeSet<T, K, C>
where K: Freeze, T: Freeze,

§

impl<T, K, const C: usize> RefUnwindSafe for RangeSet<T, K, C>
where K: RefUnwindSafe, T: RefUnwindSafe,

§

impl<T, K, const C: usize> Send for RangeSet<T, K, C>
where K: Send, T: Send,

§

impl<T, K, const C: usize> Sync for RangeSet<T, K, C>
where K: Sync, T: Sync,

§

impl<T, K, const C: usize> Unpin for RangeSet<T, K, C>
where K: Unpin, T: Unpin,

§

impl<T, K, const C: usize> UnwindSafe for RangeSet<T, K, C>
where K: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.