### iter

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Returns an inorder iterator through all intervals stored in the tree, sorted by their start bound.

```APIDOC
## GET /iter

### Description
Returns an inorder iterator through all intervals stored in the tree, yielding references to the stored ranges sorted by their start bound.

### Method
GET

### Endpoint
/iter

### Parameters
None

### Response
#### Success Response (200)
- **intervals** (Iterator<&Interval>) - An iterator yielding intervals in inorder.

#### Response Example
```json
// This is an iterator, not a direct JSON response. Example of collected values:
[
  "(Unbounded, Included(50))",
  "(Excluded(-10), Included(-5))",
  "(Included(10), Excluded(20))",
  "(Included(40), Unbounded)"
]
```
```

--------------------------------

### Iterate over intervals in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Performs an inorder traversal of the tree, yielding intervals sorted by their start bound.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

let mut tree = IntervalTree::default();

tree.insert((Included(10), Excluded(20)));
tree.insert((Included(40), Unbounded));
tree.insert((Unbounded, Included(50)));
tree.insert((Excluded(-10), Included(-5)));

// Iterate in sorted order by start bound
let intervals: Vec<_> = tree.iter().collect();
assert_eq!(intervals, vec![
    &(Unbounded, Included(50)),        // Unbounded start comes first
    &(Excluded(-10), Included(-5)),
    &(Included(10), Excluded(20)),
    &(Included(40), Unbounded)
]);

// Use iterator methods
for (start, end) in tree.iter() {
    println!("Start: {:?}, End: {:?}", start, end);
}

assert_eq!(tree.iter().count(), 4);
```

--------------------------------

### Basic Interval Tree Usage in Rust

Source: https://github.com/jonathangb/unbounded-interval-tree/blob/master/README.md

Demonstrates the basic usage of the IntervalTree, including initialization, insertion of various interval types, iteration, and querying for overlaps and differences. Ensure necessary bounds traits are implemented for interval values.

```rust
use unbounded_interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

// Default interval tree.
let mut tree = IntervalTree::default();

// Ranges are defined as a 2-ple of Bounds.
let interval1 = (Included(5), Excluded(9));
let interval2 = (Unbounded, Included(-2));
let interval3 = (Included(30), Included(30));

// Add intervals to the tree.
tree.insert(interval1);
tree.insert(interval2);
tree.insert(interval3);

// Iterate through the intervals inorder.
for (start, end) in tree.iter() {
  println!("Start: {:?}\tEnd: {:?}", start, end);
}

// Get overlapping intervals.
let overlaps = tree.get_interval_overlaps(&(0..30));

// Get the difference between the database
// of intervals and the query interval.
let diff = tree.get_interval_difference(&(0..=30));

```

--------------------------------

### Interval Tree Creation

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Demonstrates various methods for creating an IntervalTree instance, including using `default()`, collecting from an iterator, and converting from an array.

```APIDOC
## Interval Tree Creation

### Description
Demonstrates various methods for creating an `IntervalTree` instance, including using `default()`, collecting from an iterator, and converting from an array.

### Method
N/A (Constructor/Factory Methods)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

// Method 1: Create an empty default interval tree
let mut tree = IntervalTree::default();
assert!(tree.is_empty());

// Method 2: Create from an iterator of ranges
let ranges = vec!["hello"..="hi", "Allo"..="Bonjour"];
let tree_from_iter = ranges.into_iter().collect::<IntervalTree<_>>();
assert_eq!(tree_from_iter.len(), 2);

// Method 3: Create from an array
let ranges = [(1, 5)..(1, 9), (2, 3)..(3, 7)];
let tree_from_array = IntervalTree::from(ranges);
assert_eq!(tree_from_array.len(), 2);
```

### Response
N/A
```

--------------------------------

### Create Interval Tree in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Demonstrates three methods for creating an IntervalTree: using default() for an empty tree, collecting from an iterator of ranges, and converting from an array of ranges. Ensure the necessary bounds are imported.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

// Method 1: Create an empty default interval tree
let mut tree = IntervalTree::default();
assert!(tree.is_empty());

// Method 2: Create from an iterator of ranges
let ranges = vec!["hello"..="hi", "Allo"..="Bonjour"];
let tree_from_iter = ranges.into_iter().collect::<IntervalTree<_>>();
assert_eq!(tree_from_iter.len(), 2);

// Method 3: Create from an array
let ranges = [(1, 5)..(1, 9), (2, 3)..(3, 7)];
let tree_from_array = IntervalTree::from(ranges);
assert_eq!(tree_from_array.len(), 2);
```

--------------------------------

### Serde Serialization and Deserialization

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Demonstrates how to serialize an IntervalTree to JSON and deserialize it back using Serde. Requires the 'serde' feature to be enabled.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded};
// Requires serde and serde_json dependencies

let mut tree = IntervalTree::default();
tree.insert((Included(2), Included(4)));
tree.insert((Included(1), Excluded(3)));

// Serialize to JSON
// let json = serde_json::to_string(&tree).unwrap();

// Deserialize from JSON
// let restored: IntervalTree<i32> = serde_json::from_str(&json).unwrap();
// assert_eq!(tree, restored);

// JSON structure example:
// {
//   "root": {
//     "key": [{"Included": 2}, {"Included": 4}],
//     "left": {
//       "key": [{"Included": 1}, {"Excluded": 3}],
//       "left": null,
//       "right": null,
//       "value": {"Excluded": 3}
//     },
//     "right": null,
//     "value": {"Included": 4}
//   },
//   "size": 2
// }
```

--------------------------------

### Manage tree size and state in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Utility methods for checking tree size and clearing all stored intervals.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

let mut tree = IntervalTree::default();

// Check initial state
assert_eq!(tree.len(), 0);
assert!(tree.is_empty());

// Add intervals
tree.insert((Included(5), Excluded(9)));
tree.insert((Unbounded, Included(10)));
tree.insert(20..30);

assert_eq!(tree.len(), 3);
assert!(!tree.is_empty());

// Clear all intervals
tree.clear();

assert_eq!(tree.len(), 0);
assert!(tree.is_empty());
```

--------------------------------

### Insert Intervals into Interval Tree in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Shows how to insert intervals into an IntervalTree using both explicit bounds (e.g., (Included(5), Excluded(9))) and Rust's standard range syntax (e.g., ..=10, 20..30, 50..). Supports various types including strings.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();

// Insert using explicit bounds (inclusive start, exclusive end)
tree.insert((Included(5), Excluded(9)));

// Insert using Rust range syntax
tree.insert(..=10);        // Unbounded start, inclusive end at 10
tree.insert(20..30);       // Half-open range [20, 30)
tree.insert(50..);         // From 50 to unbounded

// Insert with string types
let mut str_tree: IntervalTree<&str> = IntervalTree::default();
str_tree.insert("Noria"..);
str_tree.insert((Excluded("abc"), Included("xyz")));

assert_eq!(tree.len(), 4);
assert_eq!(str_tree.len(), 2);
```

--------------------------------

### len, is_empty, and clear

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Utility methods for checking the size of the tree and clearing all stored intervals.

```APIDOC
## Utility Methods: len, is_empty, clear

### Description
Provides methods to get the number of intervals in the tree, check if the tree is empty, and remove all intervals from the tree.

### Methods
- **len()**: Returns the number of intervals in the tree.
- **is_empty()**: Returns `true` if the tree contains no intervals, `false` otherwise.
- **clear()**: Removes all intervals from the tree.

### Endpoints
These are typically called as methods on the tree object, not as separate API endpoints.

### Parameters
None for `len()` and `is_empty()`. `clear()` takes no parameters.

### Response
#### Success Response (200)
- **len()**: Returns an integer representing the count.
- **is_empty()**: Returns a boolean.
- **clear()**: Typically returns `void` or `Ok(())`.

#### Response Example
```json
// Example for len():
{
  "count": 3
}

// Example for is_empty():
{
  "is_empty": false
}
```
```

--------------------------------

### insert

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Inserts an interval into the tree. Supports various range syntaxes and explicit bound tuples.

```APIDOC
## POST /insert

### Description
Inserts an interval into the tree while maintaining binary search tree properties. Accepts any type implementing `RangeBounds<K>`, including Rust's standard range syntax (`..`, `..=`, etc.) and explicit bound tuples.

### Method
POST

### Endpoint
`/insert`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **interval** (RangeBounds<K>) - Required - The interval to insert. Can be represented using Rust's range syntax (e.g., `..=10`, `20..30`, `50..`) or explicit bounds (e.g., `(Included(5), Excluded(9))`).

### Request Example
```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();

// Insert using explicit bounds (inclusive start, exclusive end)
tree.insert((Included(5), Excluded(9)));

// Insert using Rust range syntax
tree.insert(..=10);        // Unbounded start, inclusive end at 10
tree.insert(20..30);       // Half-open range [20, 30)
tree.insert(50..);         // From 50 to unbounded

// Insert with string types
let mut str_tree: IntervalTree<&str> = IntervalTree::default();
str_tree.insert("Noria"..);
str_tree.insert((Excluded("abc"), Included("xyz")));

assert_eq!(tree.len(), 4);
assert_eq!(str_tree.len(), 2);
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful insertion.

#### Response Example
```json
{
  "message": "Interval inserted successfully"
}
```
```

--------------------------------

### Check Interval Coverage in Interval Tree in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Verifies if a given query interval is entirely covered by the intervals stored in the tree. This requires every point within the query interval to be contained in at least one stored interval.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();
tree.insert((Included(20), Included(30)));
tree.insert((Excluded(30), Excluded(50)));

// [20, 40] is fully covered by [20, 30] and (30, 50)
assert!(tree.contains_interval(&(20..=40)));

// [30, 50] is NOT fully covered because 50 is excluded from (30, 50)
assert!(!tree.contains_interval(&(&30..=&50)));

// Check coverage with string intervals
let mut str_tree: IntervalTree<&str> = IntervalTree::default();
str_tree.insert((Included("a"), Excluded("h")));
str_tree.insert((Excluded("M"), Excluded("O")));

assert!(str_tree.contains_interval(&("a".."h")));
assert!(str_tree.contains_interval(&("N"..="N")));
assert!(!str_tree.contains_interval(&("N"..="O")));  // O is excluded
```

--------------------------------

### Find interval differences in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Identifies subintervals within a query range that are not covered by any intervals in the tree.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

let mut tree = IntervalTree::default();
tree.insert((Included(0), Excluded(10)));
tree.insert((Excluded(10), Included(30)));
tree.insert((Excluded(50), Unbounded));

// Find uncovered portions of [-5, 30]
let diff = tree.get_interval_difference(&(-5..=30));
assert_eq!(diff, vec![
    (Included(&-5), Excluded(&0)),   // Gap before first interval
    (Included(&10), Included(&10))   // Single point gap at 10
]);

// Find uncovered portions of (-inf, 10)
let diff = tree.get_interval_difference(&(..10));
assert_eq!(diff, vec![(Unbounded, Excluded(&0))]);

// No gaps when range is fully covered
let diff = tree.get_interval_difference(&(100..));
assert!(diff.is_empty());  // (50, +inf) covers [100, +inf)

// Complex example with multiple gaps
let mut tree2 = IntervalTree::default();
tree2.insert(2..10);
tree2.insert((Excluded(10), Excluded(20)));
tree2.insert(30..=40);

let diff = tree2.get_interval_difference(&(0..=50));
assert_eq!(diff, vec![
    (Included(&0), Excluded(&2)),
    (Included(&10), Included(&10)),
    (Included(&20), Excluded(&30)),
    (Excluded(&40), Included(&50))
]);
```

--------------------------------

### Find interval overlaps in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Retrieves an inorder list of intervals that overlap with a specified query range.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

let mut tree = IntervalTree::default();
tree.insert((Included(0), Included(5)));
tree.insert((Included(7), Excluded(10)));
tree.insert((Excluded(3), Unbounded));

// Find intervals overlapping with [-5, 7)
let overlaps = tree.get_interval_overlaps(&(-5..7));
assert_eq!(overlaps, vec![
    &(Included(0), Included(5)),
    &(Excluded(3), Unbounded)
]);

// Find intervals overlapping with [10, +inf)
let overlaps = tree.get_interval_overlaps(&(10..));
assert_eq!(overlaps, vec![&(Excluded(3), Unbounded)]);

// No overlaps found
let overlaps = tree.get_interval_overlaps(&(-100..-50));
assert!(overlaps.is_empty());

// All intervals overlapping with unbounded range
let all = tree.get_interval_overlaps(&(..));
assert_eq!(all.len(), 3);
```

--------------------------------

### Check Point Containment in Interval Tree in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Implements a 'stabbing query' to determine if a given point falls within any stored intervals. This method works with borrowed types and handles various interval definitions, including unbounded ones.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();
tree.insert((Included(10), Excluded(20)));
tree.insert((Excluded(30), Excluded(40)));
tree.insert(40..);  // [40, +inf)

// Check if points are contained in any interval
assert!(tree.contains_point(&10));   // true: 10 is in [10, 20)
assert!(!tree.contains_point(&20));  // false: 20 is excluded from [10, 20)
assert!(!tree.contains_point(&30));  // false: 30 is excluded from (30, 40)
assert!(tree.contains_point(&35));   // true: 35 is in (30, 40)
assert!(tree.contains_point(&40));   // true: 40 is in [40, +inf)
assert!(tree.contains_point(&1000)); // true: 1000 is in [40, +inf)

// Works with String types and borrowed str
let mut str_tree = IntervalTree::default();
str_tree.insert(String::from("a")..String::from("h"));

assert!(str_tree.contains_point("b"));    // Borrowed &str works
assert!(str_tree.contains_point(&String::from("g")));
assert!(!str_tree.contains_point("z"));
```

--------------------------------

### get_interval_overlaps

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Returns an inorder list of references to all intervals in the tree that overlap with a given query interval.

```APIDOC
## GET /get_interval_overlaps

### Description
Returns an inorder list of references to all intervals in the tree that overlap (partially or completely) with the given query interval.

### Method
GET

### Endpoint
/get_interval_overlaps

### Parameters
#### Query Parameters
- **query_interval** (Interval) - Required - The interval to check for overlaps.

### Request Example
```rust
// Example usage within the library, not a direct API call
let overlaps = tree.get_interval_overlaps(&(-5..7));
```

### Response
#### Success Response (200)
- **overlaps** (Vec<&Interval>) - A list of intervals that overlap with the query interval.

#### Response Example
```json
{
  "overlaps": [
    "(Included(0), Included(5))",
    "(Excluded(3), Unbounded)"
  ]
}
```
```

--------------------------------

### contains_interval

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Checks if an entire query interval is covered by intervals stored in the tree.

```APIDOC
## GET /contains_interval

### Description
Checks whether an entire interval is fully covered by the intervals stored in the tree. Returns true only if every point in the query interval is contained within at least one stored interval.

### Method
GET

### Endpoint
`/contains_interval`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
- **query_interval** (RangeBounds<T>) - Required - The interval to check for full coverage.

#### Request Body
N/A

### Request Example
```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();
tree.insert((Included(20), Included(30)));
tree.insert((Excluded(30), Excluded(50)));

// [20, 40] is fully covered by [20, 30] and (30, 50)
assert!(tree.contains_interval(&(20..=40)));

// [30, 50] is NOT fully covered because 50 is excluded from (30, 50)
assert!(!tree.contains_interval(&(&30..=&50)));

// Check coverage with string intervals
let mut str_tree: IntervalTree<&str> = IntervalTree::default();
str_tree.insert((Included("a"), Excluded("h")));
str_tree.insert((Excluded("M"), Excluded("O")));

assert!(str_tree.contains_interval(&("a".."h")));
assert!(str_tree.contains_interval(&("N"..="N")));
assert!(!str_tree.contains_interval(&("N"..="O")));  // O is excluded
```

### Response
#### Success Response (200)
- **is_covered** (boolean) - True if the query interval is fully contained within the stored intervals, false otherwise.

#### Response Example
```json
{
  "is_covered": true
}
```
```

--------------------------------

### get_interval_difference

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Returns the ordered list of subintervals within the query range that are NOT covered by any intervals in the tree.

```APIDOC
## GET /get_interval_difference

### Description
Returns the ordered list of subintervals within the query range that are NOT covered by any intervals in the tree. Useful for finding gaps or uncovered segments.

### Method
GET

### Endpoint
/get_interval_difference

### Parameters
#### Query Parameters
- **query_range** (Interval) - Required - The range to find uncovered portions within.

### Request Example
```rust
// Example usage within the library, not a direct API call
let diff = tree.get_interval_difference(&(-5..=30));
```

### Response
#### Success Response (200)
- **differences** (Vec<(Bound, Bound)>) - A list of subintervals representing the uncovered portions.

#### Response Example
```json
{
  "differences": [
    "(Included(-5), Excluded(0))",
    "(Included(10), Included(10))"
  ]
}
```
```

--------------------------------

### contains_point

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Checks if a given point is contained within any interval in the tree.

```APIDOC
## GET /contains_point

### Description
Performs a "stabbing query" to check whether a given point is contained in any of the intervals stored in the tree. Supports borrowed forms of the stored type.

### Method
GET

### Endpoint
`/contains_point`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
- **point** (T) - Required - The point to check for containment. Must be of a type that can be borrowed from the tree's stored type.

#### Request Body
N/A

### Request Example
```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded);

let mut tree = IntervalTree::default();
tree.insert((Included(10), Excluded(20)));
tree.insert((Excluded(30), Excluded(40)));
tree.insert(40..);  // [40, +inf)

// Check if points are contained in any interval
assert!(tree.contains_point(&10));   // true: 10 is in [10, 20)
assert!(!tree.contains_point(&20));  // false: 20 is excluded from [10, 20)
assert!(!tree.contains_point(&30));  // false: 30 is excluded from (30, 40)
assert!(tree.contains_point(&35));   // true: 35 is in (30, 40)
assert!(tree.contains_point(&40));   // true: 40 is in [40, +inf)
assert!(tree.contains_point(&1000)); // true: 1000 is in [40, +inf)

// Works with String types and borrowed str
let mut str_tree = IntervalTree::default();
str_tree.insert(String::from("a")..String::from("h"));

assert!(str_tree.contains_point("b"));    // Borrowed &str works
assert!(str_tree.contains_point(&String::from("g")));
assert!(!str_tree.contains_point("z"));
```

### Response
#### Success Response (200)
- **contains** (boolean) - True if the point is contained in any interval, false otherwise.

#### Response Example
```json
{
  "contains": true
}
```
```

--------------------------------

### remove_random_leaf

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Removes a random leaf node from the tree and returns the interval that was stored in it.

```APIDOC
## DELETE /remove_random_leaf

### Description
Removes a random leaf node from the tree and returns the interval that was stored in it. Returns `None` if the tree is empty. This method is useful for probabilistic algorithms or when specific removal order is not important.

### Method
DELETE

### Endpoint
/remove_random_leaf

### Parameters
None

### Response
#### Success Response (200)
- **deleted_interval** (Interval | null) - The interval that was removed, or null if the tree was empty.

#### Response Example
```json
{
  "deleted_interval": "(Included(5), Excluded(9))"
}
```
```

--------------------------------

### Remove random leaf in Rust

Source: https://context7.com/jonathangb/unbounded-interval-tree/llms.txt

Removes a random leaf node from the tree, returning the interval it contained. Returns None if the tree is empty.

```rust
use unbounded_interval_tree::interval_tree::IntervalTree;
use std::ops::Bound::{Included, Excluded, Unbounded};

let mut tree = IntervalTree::default();

tree.insert((Included(5), Excluded(9)));
tree.insert((Unbounded, Included(10)));

assert_eq!(tree.len(), 2);
assert!(tree.contains_point(&10));
assert!(tree.contains_point(&6));

// Remove a random leaf
let deleted = tree.remove_random_leaf();
assert!(deleted.is_some());
assert_eq!(tree.len(), 1);

// Remove remaining node
let deleted = tree.remove_random_leaf();
assert!(deleted.is_some());
assert!(tree.is_empty());

// Returns None when tree is empty
let deleted = tree.remove_random_leaf();
assert!(deleted.is_none());
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.