Insert a key-value pair and handle splitting if necessary.

Returns an iterator over key-value pairs in a range using Rust's range syntax. # Examples ``` use bplustree::BPlusTreeMap; let mut tree = BPlusTree

Returns an iterator over all key-value pairs in sorted order.

Standard tree with capacity 4 (most common pattern)

Return an iterator over (key, value) pairs in the given range

Return an iterator over keys in the given range

Returns an iterator over key-value pairs in a range. If start_key is None, starts from the beginning. If end_key is None, goes to the end.

Helper function to check tree invariants

Insert a key-value pair. Returns old value if key exists.

Standard invariant check with panic on failure

Returns the number of leaf nodes in the tree.

Get statistics for the leaf node arena.

Create tree with capacity 4 and insert 0..count sequential data

Helper function to check tree invariants

Insert sequential data 0..count with string values

Check invariants with detailed error reporting.

Return an iterator over (key, value) pairs in the specified range. Args: start_key: Start of range (inclusive). Use None for begi

Check if key exists in the tree. # Arguments `key` - The key to check for existence # Returns `true` if the key exists, `false` otherwise. # Exam

Execute deletion range attack (delete items from start to end)

Optimized lookup.

Inline functions for fast array access */

Iterate over key-value pairs in range.

Remove and return value for key with optional default (dict-like API). Args: key: The key to remove. *args: Optional

Update tree with key-value pairs from other mapping or iterable.

Insert with optimized array access.

Returns true if this leaf node is empty.

Prints the node chain for debugging.

Generic integer tree creation with custom capacity

Get statistics for the branch node arena.

Helper function to check tree invariants

Returns the sizes of all leaf nodes (for testing/debugging).

Benchmark a function and return execution time.

Remove a key from the tree and return its associated value. # Arguments `key` - The key to remove from the tree # Returns `Some(value)` - The value

Context manager to measure execution time.

Alias for check_invariants_detailed (for test compatibility).

Check if an ID is valid and allocated

Find where a key should be inserted. Returns (position, exists) where exists is True if key already exists.

Get the number of allocated items

Remove all items from the tree.

Create a shallow copy of the tree.

Count the number of leaf and branch nodes actually in the tree structure.

Insert data with custom key multiplier (common pattern: i * multiplier)

Get a reference to the keys in this leaf node.

Return the number of leaf nodes

Remove and return value for key with optional default.

Check if leaf can give a key to a sibling (has more than minimum).

Clear all items from the arena

Find which child a key should go to

Returns True if this is a leaf node

Get the number of allocated leaf nodes in the arena.

Get value for a key, returns None if not found

Generic tree creation with custom capacity

Get value with default.

Get a reference to the value associated with a key. # Arguments `key` - The key to look up # Returns A reference to the value if the key exists, `

Get value for a key, returning an error if the key doesn't exist. This is equivalent to Python's `tree[key]`. # Arguments `key` - The key to look up

Insert key-value pair. Returns True if successful.

Split this leaf node, returning the new right node.

Check all B+ tree invariants. Args: root: The root node of the tree leaves: Optional head of the leaf linked

Generate test data for performance tests.

Get multiple keys with detailed error reporting. # Arguments `keys` - Slice of keys to look up # Returns A vector of references to the values if a

Run the main fuzz test with specified number of operations

Get value for key, setting and returning default if not present.

Check if the tree maintains B+ tree invariants. Returns true if all invariants are satisfied.

Legacy compatibility - create attack tree

Create test data for benchmarks.

Unsafe fast access without bounds checking or allocation verification # Safety Caller must ensure id is valid and allocated

Insert a key-value pair at the specified index.

Log an operation for replay in case of errors

Measure operation time and return per-operation time in nanoseconds.

Binary search to find position for key */

Pop the last key-value pair.

Remove and return an arbitrary (key, value) pair.

Time an operation and store the result.

Helper function to check tree invariants

Helper function to check tree invariants

Fast equality comparison function */