intervalmap 0.1.1

//! An interval set/map library inspired by Boost.Icl.
//!
//! This crate provides two main data structures:
//!
//! - [`IntervalSet`]: A collection of non-overlapping intervals with automatic merging
//! - [`IntervalMap`]: A mapping from intervals to values with split/merge behavior
//!
//! # Examples
//!
//! ## IntervalSet
//!
//! ```
//! use intervalmap::IntervalSet;
//!
//! let mut set = IntervalSet::new();
//! set.insert(0..10);
//! set.insert(5..15);  // Merges with [0, 10) to form [0, 15)
//!
//! assert!(set.contains(7));
//! assert!(!set.contains(20));
//! ```
//!
//! ## IntervalMap
//!
//! ```
//! use intervalmap::IntervalMap;
//!
//! let mut map = IntervalMap::new();
//! map.insert(0..10, "first");
//! map.insert(5..15, "second");  // Splits: [0,5)->"first", [5,15)->"second"
//!
//! assert_eq!(map.get(3), Some(&"first"));
//! assert_eq!(map.get(7), Some(&"second"));
//! ```
//!
//! ## Using Macros
//!
//! ```
//! use intervalmap::{interval_set, interval_map};
//!
//! let set = interval_set![0..10, 20..30];
//! assert!(set.contains(5));
//!
//! let map = interval_map![(0..10) => "a", (20..30) => "b"];
//! assert_eq!(map.get(5), Some(&"a"));
//! ```

mod index;
mod interval;
pub mod interval_map;
mod interval_set;

pub use index::IndexType;
pub use interval::Interval;
pub use interval_map::{Entry, IntervalMap, OccupiedEntry, VacantEntry};
pub use interval_set::IntervalSet;

/// Creates an [`IntervalSet`] from a list of ranges.
///
/// # Examples
///
/// ```
/// use intervalmap::interval_set;
///
/// // Empty set
/// let empty: intervalmap::IntervalSet<u32> = interval_set!{};
/// assert!(empty.is_empty());
///
/// // Set with intervals
/// let set = interval_set!{ 0..10, 20..30, 40..50 };
/// assert!(set.contains(5));
/// assert!(set.contains(25));
/// assert!(!set.contains(15));
///
/// // With explicit index type
/// let set = interval_set!{ [u64] 0..10, 20..30 };
/// ```
#[macro_export]
macro_rules! interval_set {
    () => {
        $crate::IntervalSet::new()
    };
    // With explicit index type: interval_set!{ [u8] 0..10, 20..30 }
    ([$ix:ty] $($range:expr),+ $(,)?) => {{
        let mut set = $crate::IntervalSet::<$ix>::new();
        $(
            set.insert($range);
        )+
        set
    }};
    // Without index type: interval_set!{ 0..10, 20..30 }
    ($($range:expr),+ $(,)?) => {{
        let mut set = $crate::IntervalSet::new();
        $(
            set.insert($range);
        )+
        set
    }};
}

/// Creates an [`IntervalMap`] from a list of range-value pairs.
///
/// # Examples
///
/// ```
/// use intervalmap::interval_map;
///
/// // Empty map
/// let empty: intervalmap::IntervalMap<u32, i32> = interval_map!{};
/// assert!(empty.is_empty());
///
/// // Map with intervals
/// let map = interval_map!{
///     0..10 => "first",
///     20..30 => "second",
/// };
/// assert_eq!(map.get(5), Some(&"first"));
/// assert_eq!(map.get(25), Some(&"second"));
///
/// // With explicit index type
/// let map = interval_map!{ [u8] 0..10 => "a", 20..30 => "b" };
/// ```
#[macro_export]
macro_rules! interval_map {
    () => {
        $crate::IntervalMap::new()
    };
    // With explicit index type: interval_map!{ [u8] 0..10 => "a", 20..30 => "b" }
    ([$ix:ty] $($range:expr => $value:expr),+ $(,)?) => {{
        let mut map = $crate::IntervalMap::<$ix, _>::new();
        $(
            map.insert($range, $value);
        )+
        map
    }};
    // Without index type: interval_map!{ 0..10 => "a", 20..30 => "b" }
    ($($range:expr => $value:expr),+ $(,)?) => {{
        let mut map = $crate::IntervalMap::new();
        $(
            map.insert($range, $value);
        )+
        map
    }};
}