#IntervalTree

#🚀 Key Features

#📥 Installation

moon add kesmeey/IntervalTree

#🚀 Usage Guide

#🔨 Creating an Interval Tree

// Create an empty interval tree
let tree : T[Int, String] = @IntervalTree.new()

// Create with a single interval
let interval = @IntervalTree.make_interval(10, 20)
let single_tree = @IntervalTree.singleton(interval, "data")

// Create from an array of intervals
let intervals = [
  (@IntervalTree.make_interval(10, 20), "A"),
  (@IntervalTree.make_interval(15, 25), "B"),
  (@IntervalTree.make_interval(5, 15), "C"),
]
let tree_from_array = @IntervalTree.from_array(intervals)

#➕ Adding Intervals and Data

  let tree : T[Int, String] = @IntervalTree.new() // Create empty tree
  let p1 = tree.insert(@IntervalTree.make_interval(10, 20), "A") // Returns insertion result, true for successful insertion
  println(p1) // true
  println(tree.size()) // 1

#🔍 Querying Intervals

// Create a new tree and add data
let tree : T[Int, String] = @IntervalTree.new()
ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))
ignore(tree.insert(@IntervalTree.make_interval(5, 15), "C"))
ignore(tree.insert(@IntervalTree.make_interval(30, 40), "D"))

// Find all intervals that overlap with a given interval
let query = @IntervalTree.make_interval(12, 18)
let overlaps = tree.find_overlaps(query)
assert_eq!(overlaps.length(), 3)  // Should find A, B, C

// Find all intervals completely contained within a given interval
let container = @IntervalTree.make_interval(5, 30)
let contained = tree.find_contained(container)
assert_eq!(contained.length(), 3)  // Should find A, B, C

// Check if a specific interval exists
if tree.contains(@IntervalTree.make_interval(10, 20)) {
  // Interval exists
  assert_true!(true)
}

#❌ Removing Intervals

// Create a new tree and add data
let tree : T[Int, String] = @IntervalTree.new()
ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))
ignore(tree.insert(@IntervalTree.make_interval(5, 15), "C"))

// Remove an existing interval
let removed = tree.remove(@IntervalTree.make_interval(10, 20))
assert_eq!(removed, true)  // Returns true if the interval exists and was successfully removed
assert_eq!(tree.size(), 2)

#🧹 Clearing the Tree

// Create a new tree and add data
let tree : T[Int, String] = @IntervalTree.new()
ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))

// Clear the tree
tree.clear()
assert_eq!(tree.size(), 0)
assert_eq!(tree.is_empty(), true)

#📏 Size and Capacity

// Create a new tree and add data
let tree : T[Int, String] = @IntervalTree.new()
ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))

// Check size
let size = tree.size()  // Get the number of intervals
assert_eq!(size, 2)

// Check if empty after clearing
tree.clear()
let empty = tree.is_empty()  // Check if the tree is empty
assert_true!(empty)

#🔄 Iteration

// Create a new tree and add data
let tree : T[Int, String] = @IntervalTree.new()
ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))
ignore(tree.insert(@IntervalTree.make_interval(5, 15), "C"))

// Collect iteration results
let values = []

// Iterate through all intervals and data
tree.each(fn(interval, value) {
  values.push(value)
})
assert_eq!(values.length(), 3)

// Iterate with indices
let idx_values = []
tree.eachi(fn(idx, interval, value) {
  idx_values.push((idx, value))
})
assert_eq!(idx_values.length(), 3)

#📋 Converting to Array

 // Create a new tree and add data
  let tree : T[Int, String] = @IntervalTree.new()
  ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
  ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))

  // Convert to array
  let array = tree.to_array()
  // Returns an array of IntervalMatch objects, each containing interval and data
  assert_eq!(array.length(), 2)
  println(array)
  //[{interval: {low: 10, high: 20}, data: "A"}, {interval: {low: 15, high: 25}, data: "B"}]

#🎯 Index Access

  // Create a new tree and add data
  let tree : T[Int, String] = @IntervalTree.new()
  ignore(tree.insert(@IntervalTree.make_interval(10, 20), "A"))
  ignore(tree.insert(@IntervalTree.make_interval(15, 25), "B"))
  ignore(tree.insert(@IntervalTree.make_interval(5, 15), "C"))

  // Access by index
  let match0 = tree[0]
  // Get the first interval's IntervalMatch
  println(match0) //  {interval: {low: 5, high: 15}, data: "C"}
  let match1 = tree[1]
  // Get the second interval's IntervalMatch
  println(match1) // {interval: {low: 10, high: 20}, data: "A"}

#📐 Interval Types

  // Create a tree with open intervals
  let open_option = IntervalOptions::{
    interval_type: IntervalType::Open,
    allow_duplicates: false,
  }

  let open_tree = @IntervalTree.new_with_options(open_option)
  ignore(open_tree.insert(@IntervalTree.make_interval(10, 20), "A"))
  // Create a tree with closed intervals
  let closed_option = IntervalOptions::{
    interval_type: IntervalType::Closed,
    allow_duplicates: false,
  }

  let closed_tree = @IntervalTree.new_with_options(closed_option)
  ignore(closed_tree.insert(@IntervalTree.make_interval(10, 20), "B"))

#🧠 Generic Support

  // Using Float type intervals
  let float_tree : T[Float, String] = @IntervalTree.new()
  let p1 = float_tree.insert(@IntervalTree.make_interval(10.5, 20.5), "A")
  assert_eq!(p1, true) // Successful insertion

  // Using String type intervals
  let string_tree : T[String, Int] = @IntervalTree.new()
  let p2 = string_tree.insert(@IntervalTree.make_interval("a", "z"), 1)
  assert_eq!(p2, true) // Successful insertion

#📜 License

#📢 Contact & Support