Rust范围处理库slot-range-helper的使用指南

概述

slot-range-helper是一个专门用于高效处理区间操作和范围计算的Rust库。它提供了丰富的API来处理各种范围操作，包括范围合并、拆分、查找、重叠检测等，特别适合需要处理大量区间操作的场景。

主要特性

• 高效的范围合并与拆分
• 快速的范围重叠检测
• 范围集合操作（并集、交集、差集）
• 内存高效的数据结构
• 支持开闭区间
• 线程安全设计

安装

在Cargo.toml中添加依赖：

[dependencies]
slot-range-helper = "0.3"

基本使用方法

创建范围

use slot_range_helper::{Range, RangeSet};

// 创建单个范围
let range1 = Range::new(10, 20); // [10, 20]
let range2 = Range::new_closed(5, 15); // [5, 15]
let range3 = Range::new_open(30, 40); // (30, 40)

范围操作

// 检查范围是否重叠
if range1.overlaps(&range2) {
    println!("范围重叠!");
}

// 合并两个范围
if let Some(merged) = range1.merge(&range2) {
    println!("合并后的范围: {:?}", merged);
}

// 计算交集
if let Some(intersection) = range1.intersection(&range2) {
    println!("交集范围: {:?}", intersection);
}

使用RangeSet处理多个范围

let mut range_set = RangeSet::new();

// 添加范围
range_set.insert(Range::new(10, 20));
range_set.insert(Range::new(15, 25));
range_set.insert(Range::new(30, 40));

// 自动合并重叠范围
range_set.optimize();

// 检查是否包含某个值
if range_set.contains(18) {
    println!("包含18");
}

// 获取所有不重叠的范围
for range in range_set.ranges() {
    println!("范围: {:?}", range);
}

高级用法

范围拆分

let range = Range::new(0, 100);
let split_point = 50;

let (left, right) = range.split_at(split_point);
println!("拆分结果: {:?} 和 {:?}", left, right);

范围差集

let range1 = Range::new(10, 30);
let range2 = Range::new(20, 40);

let difference = range1.difference(&range2);
println!("差集范围: {:?}", difference); // 将输出[10, 20)

批量操作

let mut set1 = RangeSet::new();
set1.insert(Range::new(10, 20));
set1.insert(Range::new(30, 40));

let mut set2 = RangeSet::new();
set2.insert(Range::new(15, 25));
set2.insert(Range::new(35, 45));

// 并集
let union = set1.union(&set2);
println!("并集: {:?}", union);

// 交集
let intersection = set1.intersection(&set2);
println!("交集: {:?}", intersection);

性能提示

1. 对于大量范围操作，建议使用RangeSet而不是单独处理每个Range
2. 在多次插入后调用optimize()方法可以合并重叠范围，提高后续查询效率
3. 范围查询(contains)的时间复杂度是O(log n)，非常高效

实际应用示例

时间区间管理

use slot_range_helper::{Range, RangeSet};

struct Meeting {
    time_range: Range<i64>, // 使用时间戳表示
    title: String,
}

fn schedule_meetings(meetings: Vec<Meeting>) -> Vec<Meeting> {
    let mut scheduled = Vec::new();
    let mut busy_times = RangeSet::new();
    
    for meeting in meetings {
        if !busy_times.overlaps_with_range(&meeting.time_range) {
            busy_times.insert(meeting.time_range.clone());
            scheduled.push(meeting);
        }
    }
    
    scheduled
}

资源分配系统

use slot_range_helper::{Range, RangeSet};

struct ResourceAllocator {
    available: RangeSet<u32>,
}

impl ResourceAllocator {
    fn allocate(&mut self, size: u32) -> Option<Range<u32>> {
        for range in self.available.ranges() {
            if range.size() >= size {
                let allocated = Range::new(range.start(), range.start() + size);
                self.available.remove(&allocated);
                return Some(allocated);
            }
        }
        None
    }
    
    fn free(&mut self, range: Range<u32>) {
        self.available.insert(range);
        self.available.optimize();
    }
}

完整示例代码

以下是一个完整的示例，展示如何使用slot-range-helper库来处理会议时间调度：

use slot_range_helper::{Range, RangeSet};
use chrono::{DateTime, Utc};

// 会议结构体
#[derive(Debug, Clone)]
struct Meeting {
    title: String,
    start: DateTime<Utc>,
    end: DateTime<Utc>,
}

impl Meeting {
    // 将会议转换为时间范围
    fn to_range(&self) -> Range<i64> {
        Range::new(self.start.timestamp(), self.end.timestamp())
    }
}

// 会议调度器
struct MeetingScheduler {
    scheduled_meetings: Vec<Meeting>,
    busy_times: RangeSet<i64>,
}

impl MeetingScheduler {
    fn new() -> Self {
        MeetingScheduler {
            scheduled_meetings: Vec::new(),
            busy_times: RangeSet::new(),
        }
    }
    
    // 尝试安排会议
    fn schedule_meeting(&mut self, meeting: Meeting) -> bool {
        let meeting_range = meeting.to_range();
        
        if !self.busy_times.overlaps_with_range(&meeting_range) {
            self.busy_times.insert(meeting_range);
            self.scheduled_meetings.push(meeting);
            self.busy_times.optimize(); // 优化范围集合
            true
        } else {
            false
        }
    }
    
    // 获取所有已安排的会议
    fn get_scheduled_meetings(&self) -> &[Meeting] {
        &self.scheduled_meetings
    }
    
    // 检查时间是否可用
    fn is_time_available(&self, start: DateTime<Utc>, end: DateTime<Utc>) -> bool {
        let range = Range::new(start.timestamp(), end.timestamp());
        !self.busy_times.overlaps_with_range(&range)
    }
}

fn main() {
    use chrono::TimeZone;
    
    let mut scheduler = MeetingScheduler::new();
    
    // 创建几个会议时间
    let meeting1 = Meeting {
        title: "项目启动会".to_string(),
        start: Utc.with_ymd_and_hms(2023, 6, 1, 9, 0, 0).unwrap(),
        end: Utc.with_ymd_and_hms(2023, 6, 1, 10, 0, 0).unwrap(),
    };
    
    let meeting2 = Meeting {
        title: "技术讨论".to_string(),
        start: Utc.with_ymd_and_hms(2023, 6, 1, 10, 30, 0).unwrap(),
        end: Utc.with_ymd_and_hms(2023, 6, 1, 11, 30, 0).unwrap(),
    };
    
    // 尝试安排重叠的会议
    let conflicting_meeting = Meeting {
        title: "冲突会议".to_string(),
        start: Utc.with_ymd_and_hms(2023, 6, 1, 9, 30, 0).unwrap(),
        end: Utc.with_ymd_and_hms(2023, 6, 1, 10, 30, 0).unwrap(),
    };
    
    // 安排会议
    scheduler.schedule_meeting(meeting1);
    scheduler.schedule_meeting(meeting2);
    let success = scheduler.schedule_meeting(conflicting_meeting);
    
    println!("冲突会议是否安排成功: {}", success);
    
    // 打印已安排的会议
    for meeting in scheduler.get_scheduled_meetings() {
        println!("已安排会议: {} ({} - {})", 
            meeting.title, 
            meeting.start.format("%Y-%m-%d %H:%M"), 
            meeting.end.format("%Y-%m-%d %H:%M"));
    }
    
    // 检查特定时间是否可用
    let check_start = Utc.with_ymd_and_hms(2023, 6, 1, 13, 0, 0).unwrap();
    let check_end = Utc.with_ymd_and_hms(2023, 6, 1, 14, 0, 0).unwrap();
    println!("13:00-14:00 是否可用: {}", 
        scheduler.is_time_available(check_start, check_end));
}

这个完整示例展示了如何使用slot-range-helper库来管理会议时间调度，包括安排会议、检测时间冲突以及查询时间可用性等功能。