rbtree: fix compile warnings
This commit is contained in:
parent
c7d5f18a4f
commit
fe50f8ce74
SSH key fingerprint:
SHA256:bB1qbbqmDXZNT0KKD5c2Dfjg53JGhj7B3CFcLIzSqq8
|
|
@ -6,595 +6,4 @@ mod raw_node;
|
|||
|
||||
extern crate alloc;
|
||||
|
||||
pub trait Node {
|
||||
type Id: Eq + Copy;
|
||||
type Key: Ord;
|
||||
|
||||
fn parent(&self) -> Option<Self::Id>;
|
||||
fn set_parent(&mut self, parent: Option<Self::Id>);
|
||||
|
||||
fn left(&self) -> Option<Self::Id>;
|
||||
fn set_left(&mut self, left: Option<Self::Id>);
|
||||
|
||||
fn right(&self) -> Option<Self::Id>;
|
||||
fn set_right(&mut self, right: Option<Self::Id>);
|
||||
|
||||
fn child(&self, left: bool) -> Option<Self::Id> {
|
||||
if left { self.left() } else { self.right() }
|
||||
}
|
||||
|
||||
fn children(&self) -> (Option<Self::Id>, Option<Self::Id>) {
|
||||
(self.left(), self.right())
|
||||
}
|
||||
|
||||
fn key(&self) -> &Self::Key;
|
||||
fn color(&self) -> bool;
|
||||
fn set_color(&mut self, color: bool);
|
||||
}
|
||||
|
||||
#[allow(clippy::missing_safety_doc)]
|
||||
pub trait NodeStore<N: Node> {
|
||||
fn get(&self, id: N::Id) -> Option<&N>;
|
||||
unsafe fn get_unchecked(&self, id: N::Id) -> &N {
|
||||
self.get(id).unwrap()
|
||||
}
|
||||
fn get_mut(&mut self, id: N::Id) -> Option<&mut N>;
|
||||
unsafe fn get_mut_unchecked(&mut self, id: N::Id) -> &mut N {
|
||||
self.get_mut(id).unwrap()
|
||||
}
|
||||
fn insert(&mut self, node: N) -> N::Id;
|
||||
fn remove(&mut self, id: N::Id) -> Option<N>;
|
||||
}
|
||||
|
||||
pub struct RBTree<N: Node, S: NodeStore<N>> {
|
||||
root: Option<N::Id>,
|
||||
store: S,
|
||||
}
|
||||
|
||||
impl<N: Node, S: NodeStore<N>> RBTree<N, S> {
|
||||
pub fn new(store: S) -> Self {
|
||||
Self { root: None, store }
|
||||
}
|
||||
|
||||
fn try_get(&self, id: N::Id) -> Option<&N> {
|
||||
self.store.get(id)
|
||||
}
|
||||
|
||||
fn try_get_mut(&mut self, id: N::Id) -> Option<&mut N> {
|
||||
self.store.get_mut(id)
|
||||
}
|
||||
|
||||
pub fn insert(&mut self, node: N) -> N::Id {
|
||||
self.store.insert(node)
|
||||
}
|
||||
|
||||
pub fn minimum_of(&self, mut id: N::Id) -> N::Id {
|
||||
while let Some(left_id) = self.store.get(id).and_then(|node| node.left()) {
|
||||
id = left_id;
|
||||
}
|
||||
id
|
||||
}
|
||||
|
||||
pub fn maximum_of(&self, mut id: N::Id) -> N::Id {
|
||||
while let Some(right_id) = self.store.get(id).and_then(|node| node.right()) {
|
||||
id = right_id;
|
||||
}
|
||||
id
|
||||
}
|
||||
|
||||
pub fn next_of(&self, mut id: N::Id) -> Option<N::Id> {
|
||||
let node = self.store.get(id)?;
|
||||
match node.right() {
|
||||
Some(r) => Some(self.minimum_of(r)),
|
||||
None => {
|
||||
let mut p = node.parent()?;
|
||||
while id == self.store.get(p)?.right()? {
|
||||
id = p;
|
||||
p = self.store.get(p)?.parent()?;
|
||||
}
|
||||
Some(p)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn next_back_of(&self, mut id: N::Id) -> Option<N::Id> {
|
||||
let node = self.store.get(id)?;
|
||||
match node.left() {
|
||||
Some(l) => Some(self.maximum_of(l)),
|
||||
None => {
|
||||
let mut p = node.parent()?;
|
||||
while id == self.store.get(p)?.left()? {
|
||||
id = p;
|
||||
p = self.store.get(p)?.parent()?;
|
||||
}
|
||||
Some(p)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// x y
|
||||
// / \ / \
|
||||
// a y => x c
|
||||
// / \ / \
|
||||
// b c a b
|
||||
pub fn rotate_left(&mut self, x: N::Id) -> Option<()> {
|
||||
let y = self.right_child_of(x)?;
|
||||
let b = self.left_child_of(y);
|
||||
|
||||
let x_parent = self.parent_of(x);
|
||||
|
||||
if let Some(node) = self.store.get_mut(x) {
|
||||
node.set_right(b)
|
||||
}
|
||||
|
||||
if let Some(b_mut) = b.and_then(|id| self.store.get_mut(id)) {
|
||||
b_mut.set_parent(Some(x));
|
||||
}
|
||||
|
||||
if let Some(node) = self.store.get_mut(y) {
|
||||
node.set_left(Some(x));
|
||||
|
||||
if let Some(parent) = x_parent {
|
||||
node.set_parent(Some(parent));
|
||||
if self.store.get(parent).unwrap().left() == Some(x) {
|
||||
self.store.get_mut(parent).unwrap().set_left(Some(y));
|
||||
} else {
|
||||
self.store.get_mut(parent).unwrap().set_right(Some(y));
|
||||
}
|
||||
} else {
|
||||
self.root = Some(y);
|
||||
self.store.get_mut(y).unwrap().set_parent(None);
|
||||
}
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
// x y
|
||||
// / \ / \
|
||||
// y c => a x
|
||||
// / \ / \
|
||||
// a b b c
|
||||
pub fn rotate_right(&mut self, x: N::Id) -> Option<()> {
|
||||
let y = self.left_child_of(x)?;
|
||||
let b = self.right_child_of(y);
|
||||
|
||||
let x_parent = self.parent_of(x);
|
||||
|
||||
if let Some(node) = self.store.get_mut(x) {
|
||||
node.set_left(b)
|
||||
}
|
||||
|
||||
if let Some(b_mut) = b.and_then(|id| self.store.get_mut(id)) {
|
||||
b_mut.set_parent(Some(x));
|
||||
}
|
||||
|
||||
if let Some(node) = self.store.get_mut(y) {
|
||||
node.set_right(Some(x));
|
||||
|
||||
if let Some(parent) = x_parent {
|
||||
node.set_parent(Some(parent));
|
||||
if self.store.get(parent).unwrap().left() == Some(x) {
|
||||
self.store.get_mut(parent).unwrap().set_left(Some(y));
|
||||
} else {
|
||||
self.store.get_mut(parent).unwrap().set_right(Some(y));
|
||||
}
|
||||
} else {
|
||||
self.root = Some(y);
|
||||
self.store.get_mut(y).unwrap().set_parent(None);
|
||||
}
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub fn rotate(&mut self, x: N::Id, left: bool) -> Option<()> {
|
||||
if left {
|
||||
self.rotate_left(x)
|
||||
} else {
|
||||
self.rotate_right(x)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn find_by_key<Q>(&self, key: &Q) -> SearchResult<N::Id>
|
||||
where
|
||||
N::Key: core::borrow::Borrow<Q>,
|
||||
Q: Ord + ?Sized,
|
||||
{
|
||||
use core::borrow::Borrow;
|
||||
use core::cmp::Ordering::*;
|
||||
|
||||
let Some(mut current) = self.root else {
|
||||
return SearchResult::Empty;
|
||||
};
|
||||
|
||||
loop {
|
||||
let node = self.store.get(current).unwrap();
|
||||
|
||||
match key.cmp(node.key().borrow()) {
|
||||
Less => {
|
||||
if let Some(left) = node.left() {
|
||||
current = left;
|
||||
} else {
|
||||
return SearchResult::NotFoundLeftOf(current);
|
||||
}
|
||||
}
|
||||
Greater => {
|
||||
if let Some(right) = node.right() {
|
||||
current = right;
|
||||
} else {
|
||||
return SearchResult::NotFoundRightOf(current);
|
||||
}
|
||||
}
|
||||
Equal => return SearchResult::FoundAt(current),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn insert_id(&mut self, id: N::Id) {
|
||||
let node = self.store.get(id).unwrap();
|
||||
|
||||
match self.find_by_key(node.key()) {
|
||||
SearchResult::FoundAt(_) => {
|
||||
panic!("Duplicate key insertion is not allowed");
|
||||
}
|
||||
SearchResult::NotFoundRightOf(parent) => {
|
||||
self.store.get_mut(parent).unwrap().set_right(Some(id));
|
||||
self.store.get_mut(id).unwrap().set_parent(Some(parent));
|
||||
self.store.get_mut(id).unwrap().set_color(true); // new node is always red
|
||||
}
|
||||
SearchResult::NotFoundLeftOf(parent) => {
|
||||
self.store.get_mut(parent).unwrap().set_left(Some(id));
|
||||
self.store.get_mut(id).unwrap().set_parent(Some(parent));
|
||||
self.store.get_mut(id).unwrap().set_color(true); // new node is always red
|
||||
}
|
||||
SearchResult::Empty => {
|
||||
let node = self.store.get_mut(id).unwrap();
|
||||
node.set_parent(None);
|
||||
node.set_color(false); // root is always black
|
||||
|
||||
self.root = Some(id);
|
||||
}
|
||||
}
|
||||
|
||||
self.fix_insert(id);
|
||||
}
|
||||
|
||||
fn fix_insert(&mut self, mut id: N::Id) {
|
||||
while let Some(parent) = self
|
||||
.store
|
||||
.get(id)
|
||||
.and_then(|node| node.parent())
|
||||
.filter(|&p| self.store.get(p).unwrap().color())
|
||||
{
|
||||
// gp is guaranteed to exist because parent is red and the root is black
|
||||
let grandparent = self
|
||||
.store
|
||||
.get(parent)
|
||||
.and_then(|node| node.parent())
|
||||
.unwrap();
|
||||
let (uncle, is_left) = if self.store.get(grandparent).unwrap().left() == Some(parent) {
|
||||
(self.store.get(grandparent).unwrap().right(), true)
|
||||
} else {
|
||||
(self.store.get(grandparent).unwrap().left(), false)
|
||||
};
|
||||
|
||||
if let Some(uncle_id) = uncle
|
||||
&& self.store.get(uncle_id).unwrap().color()
|
||||
{
|
||||
// Case 1: Uncle is red
|
||||
self.store.get_mut(parent).unwrap().set_color(false);
|
||||
self.store.get_mut(uncle_id).unwrap().set_color(false);
|
||||
self.store.get_mut(grandparent).unwrap().set_color(true);
|
||||
id = grandparent;
|
||||
} else {
|
||||
// Case 2: Uncle is black
|
||||
if self.store.get(parent).unwrap().child(!is_left) == Some(id) {
|
||||
// Case 2a: id is on the same side as uncle
|
||||
self.rotate(parent, is_left);
|
||||
id = parent;
|
||||
}
|
||||
|
||||
// Case 2b: id is on the opposite side as uncle
|
||||
self.store.get_mut(parent).unwrap().set_color(false);
|
||||
self.store.get_mut(grandparent).unwrap().set_color(true);
|
||||
self.rotate(grandparent, !is_left);
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(root_id) = self.root {
|
||||
self.store.get_mut(root_id).unwrap().set_color(false);
|
||||
}
|
||||
}
|
||||
|
||||
fn color_of(&self, id: Option<N::Id>) -> bool {
|
||||
id.map(|id| self.store.get(id).unwrap().color())
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn set_color_of(&mut self, id: Option<N::Id>, color: bool) {
|
||||
if let Some(id) = id {
|
||||
self.store.get_mut(id).unwrap().set_color(color);
|
||||
}
|
||||
}
|
||||
|
||||
fn parent_of(&self, id: N::Id) -> Option<N::Id> {
|
||||
self.store.get(id).unwrap().parent()
|
||||
}
|
||||
|
||||
fn left_child_of(&self, id: N::Id) -> Option<N::Id> {
|
||||
self.store.get(id).unwrap().left()
|
||||
}
|
||||
|
||||
fn right_child_of(&self, id: N::Id) -> Option<N::Id> {
|
||||
self.store.get(id).unwrap().right()
|
||||
}
|
||||
|
||||
fn child_of(&self, id: N::Id, left: bool) -> Option<N::Id> {
|
||||
self.store.get(id).unwrap().child(left)
|
||||
}
|
||||
|
||||
fn children_of(&self, id: N::Id) -> (Option<N::Id>, Option<N::Id>) {
|
||||
self.store.get(id).unwrap().children()
|
||||
}
|
||||
|
||||
// When removing an node from an RB tree, we have to potentially fix the
|
||||
// invariants of the tree starting from the node X that replaced a deleted
|
||||
// node Y.
|
||||
|
||||
// X is either root, or X is None and the child of a parent node P which is
|
||||
// guaranteed to have a non-nil sibling W, since X is doubly-black, and so
|
||||
// the path through W must hold at least 2 black nodes, including implicit
|
||||
// black nil-leafs.
|
||||
pub fn remove(&mut self, z: N::Id) {
|
||||
// Y is either Z, the removed node in the case that Z has at most
|
||||
// one child, or Y is Z's successor which is guaranteed to have at most one
|
||||
// child (the right child).
|
||||
|
||||
let y = match self.children_of(z) {
|
||||
(None, None) | (Some(_), None) | (None, Some(_)) => z,
|
||||
// z has a successor, since it has two children.
|
||||
_ => self.next_of(z).unwrap(),
|
||||
};
|
||||
|
||||
// In either case, X is the only child of Y, if it exists.
|
||||
let x = match self.children_of(y) {
|
||||
(Some(left), _) => Some(left),
|
||||
(None, Some(right)) => Some(right),
|
||||
(None, None) => None,
|
||||
};
|
||||
// Therefore, X must be red or None, and if X is red Y must be black.
|
||||
|
||||
let parent = self.store.get(y).unwrap().parent();
|
||||
|
||||
// If Y's parent was None, then Y was the root, and the tree is empty.
|
||||
let Some(parent) = parent else {
|
||||
self.root = x;
|
||||
|
||||
if let Some(x) = x {
|
||||
self.store.get_mut(x).unwrap().set_parent(None);
|
||||
self.store.get_mut(x).unwrap().set_color(false);
|
||||
}
|
||||
|
||||
return;
|
||||
};
|
||||
|
||||
// X is promoted to Y's position, and Y is unlinked from the tree.
|
||||
if self.store.get(parent).unwrap().left() == Some(y) {
|
||||
self.store.get_mut(parent).unwrap().set_left(x);
|
||||
} else {
|
||||
self.store.get_mut(parent).unwrap().set_right(x);
|
||||
}
|
||||
|
||||
let color = self.store.get(y).unwrap().color();
|
||||
// If Y is Z's successor, move Y's data into Z (or move Z's meta into Y).
|
||||
if y != z {
|
||||
self.copy_meta_to(z, y);
|
||||
}
|
||||
|
||||
if let Some(x_id) = x {
|
||||
// If X was red, color it black. Since it replaces a black node, the
|
||||
// black-height of the subtree is preserved.
|
||||
let x = self.store.get_mut(x_id).unwrap();
|
||||
x.set_parent(Some(parent));
|
||||
x.set_color(false);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// If X is None and Y was black, then a black node was removed, and the tree
|
||||
// needs to be rebalanced.
|
||||
if !color {
|
||||
// x is the NIL leaf child of parent, and is doubly black.
|
||||
let mut x = None;
|
||||
let mut parent = Some(parent);
|
||||
while x != self.root && !self.color_of(x) {
|
||||
// safe because x is not root.
|
||||
let parent_id = parent.unwrap();
|
||||
|
||||
// w exists because it is the sibling of x; the subtree at x has
|
||||
// a black-height of 2, the subtree at w must equally have a
|
||||
// black-height of 2.
|
||||
let (mut w, is_left) = if self.store.get(parent_id).unwrap().left() == x {
|
||||
(self.store.get(parent_id).unwrap().right().unwrap(), true)
|
||||
} else {
|
||||
(self.store.get(parent_id).unwrap().left().unwrap(), false)
|
||||
};
|
||||
|
||||
// Case 1: w is red -> parent and w's children are black
|
||||
if self.color_of(Some(w)) {
|
||||
// set w to black and parent to red
|
||||
self.set_color_of(Some(w), false);
|
||||
self.set_color_of(Some(parent_id), true);
|
||||
|
||||
// rotate around parent such that w becomes the parent of parent
|
||||
self.rotate(parent_id, is_left);
|
||||
|
||||
// x hasn't change, but now the sibling is the child of w, which is black
|
||||
w = if is_left {
|
||||
self.store.get(parent_id).unwrap().right().unwrap()
|
||||
} else {
|
||||
self.store.get(parent_id).unwrap().left().unwrap()
|
||||
};
|
||||
}
|
||||
|
||||
// Case 2: w is black
|
||||
|
||||
match (
|
||||
self.color_of(self.left_child_of(w)),
|
||||
self.color_of(self.right_child_of(w)),
|
||||
) {
|
||||
(false, false) => {
|
||||
// Case 2a: w's children are both black
|
||||
// x carries a phantom black, and its sibling w is black
|
||||
// we can remove one black from x and w by colouring w
|
||||
// red and giving x's phantom black to the
|
||||
// parent.
|
||||
self.set_color_of(Some(w), true);
|
||||
x = Some(parent_id);
|
||||
parent = self.store.get(parent_id).unwrap().parent();
|
||||
continue;
|
||||
}
|
||||
(near_cousin @ true, false) | (near_cousin @ false, true) => {
|
||||
// Case 2b: x's near-cousin is red and its far-cousin is black
|
||||
// colour the near-cousin black and w red, rotate so
|
||||
// that the near cousin becomes the sibling of x
|
||||
if near_cousin == is_left {
|
||||
self.set_color_of(self.child_of(w, !is_left), false);
|
||||
self.set_color_of(Some(w), true);
|
||||
self.rotate(w, !is_left);
|
||||
}
|
||||
|
||||
// fall through to case 2c
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
|
||||
// Case 2c: x's far-cousin is red
|
||||
// we can now rotate around the parent to balance the
|
||||
// subtree at parent without increasing the
|
||||
// black-height.
|
||||
// However, in the case that the far-cousin is red and
|
||||
// the parent is black, this will result, after
|
||||
// rotating, in the far-cousin's path having fewer black
|
||||
// nodes than the parent's path: we have taken a black
|
||||
// node from above the far-cousin and moved it into its
|
||||
// sibling branch.
|
||||
// This is fixed by colouring w the colour of the
|
||||
// parent, and colouring the parent and w's far-cousin
|
||||
// black.
|
||||
self.set_color_of(Some(w), self.color_of(Some(parent_id)));
|
||||
self.set_color_of(Some(parent_id), false);
|
||||
self.set_color_of(self.child_of(w, !is_left), false);
|
||||
self.rotate(parent_id, is_left);
|
||||
|
||||
// After the rotation, the inbalance has been resolved.
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn copy_meta_to(&mut self, from: N::Id, to: N::Id) {
|
||||
let (parent, color, left, right) = {
|
||||
let from_node = self.store.get(from).unwrap();
|
||||
(
|
||||
from_node.parent(),
|
||||
from_node.color(),
|
||||
from_node.left(),
|
||||
from_node.right(),
|
||||
)
|
||||
};
|
||||
|
||||
let to_node = self.store.get_mut(to).unwrap();
|
||||
|
||||
to_node.set_parent(parent);
|
||||
to_node.set_color(color);
|
||||
to_node.set_left(left);
|
||||
to_node.set_right(right);
|
||||
|
||||
if let Some(parent) = parent {
|
||||
let parent_node = self.store.get_mut(parent).unwrap();
|
||||
if parent_node.left() == Some(from) {
|
||||
parent_node.set_left(Some(to));
|
||||
} else {
|
||||
parent_node.set_right(Some(to));
|
||||
}
|
||||
} else {
|
||||
self.root = Some(to);
|
||||
}
|
||||
|
||||
if let Some(left) = left {
|
||||
self.store.get_mut(left).unwrap().set_parent(Some(to));
|
||||
}
|
||||
if let Some(right) = right {
|
||||
self.store.get_mut(right).unwrap().set_parent(Some(to));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub enum SearchResult<T> {
|
||||
FoundAt(T),
|
||||
NotFoundRightOf(T),
|
||||
NotFoundLeftOf(T),
|
||||
Empty,
|
||||
}
|
||||
|
||||
mod default_node {
|
||||
use crate::Node;
|
||||
|
||||
type DefaultNodeId = u64;
|
||||
|
||||
struct DefaultNodeStore {
|
||||
nodes: alloc::collections::BTreeMap<DefaultNodeId, DefaultNode>,
|
||||
next_id: DefaultNodeId,
|
||||
}
|
||||
|
||||
struct DefaultNode {
|
||||
parent: Option<DefaultNodeId>,
|
||||
left: Option<DefaultNodeId>,
|
||||
right: Option<DefaultNodeId>,
|
||||
key: u64,
|
||||
color: bool,
|
||||
}
|
||||
|
||||
impl Node for DefaultNode {
|
||||
type Id = DefaultNodeId;
|
||||
type Key = u64;
|
||||
|
||||
fn parent(&self) -> Option<Self::Id> {
|
||||
self.parent
|
||||
}
|
||||
|
||||
fn set_parent(&mut self, parent: Option<Self::Id>) {
|
||||
self.parent = parent;
|
||||
}
|
||||
|
||||
fn left(&self) -> Option<Self::Id> {
|
||||
self.left
|
||||
}
|
||||
|
||||
fn set_left(&mut self, left: Option<Self::Id>) {
|
||||
self.left = left;
|
||||
}
|
||||
|
||||
fn right(&self) -> Option<Self::Id> {
|
||||
self.right
|
||||
}
|
||||
|
||||
fn set_right(&mut self, right: Option<Self::Id>) {
|
||||
self.right = right;
|
||||
}
|
||||
|
||||
fn key(&self) -> &Self::Key {
|
||||
&self.key
|
||||
}
|
||||
|
||||
fn color(&self) -> bool {
|
||||
self.color
|
||||
}
|
||||
|
||||
fn set_color(&mut self, color: bool) {
|
||||
self.color = color;
|
||||
}
|
||||
}
|
||||
}
|
||||
pub use raw_node::{RBTree, TreeIter, TreeNodeIter};
|
||||
|
|
|
|||
|
|
@ -28,11 +28,13 @@ pub trait TestDebugInspect: Sized {
|
|||
|
||||
impl<T: Sized> TestDebugInspect for T {}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub trait DebugInspect: Sized {
|
||||
// fn debug_inspect(self) -> Self {
|
||||
// dbg!(&self);
|
||||
// self
|
||||
// }
|
||||
|
||||
fn debug_inspect_with<F: FnOnce(&Self)>(self, f: F) -> Self
|
||||
where
|
||||
Self: core::fmt::Debug,
|
||||
|
|
@ -102,7 +104,7 @@ pub enum LeftOrRight<T> {
|
|||
}
|
||||
|
||||
impl<T> LeftOrRight<Option<T>> {
|
||||
fn transpose(self) -> Option<LeftOrRight<T>> {
|
||||
pub fn transpose(self) -> Option<LeftOrRight<T>> {
|
||||
match self {
|
||||
LeftOrRight::Left(Some(t)) => Some(LeftOrRight::Left(t)),
|
||||
LeftOrRight::Right(Some(t)) => Some(LeftOrRight::Right(t)),
|
||||
|
|
@ -112,33 +114,35 @@ impl<T> LeftOrRight<Option<T>> {
|
|||
}
|
||||
|
||||
impl<T> LeftOrRight<T> {
|
||||
fn map<U, F: FnOnce(T) -> U>(self, f: F) -> LeftOrRight<U> {
|
||||
pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> LeftOrRight<U> {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => LeftOrRight::Left(f(t)),
|
||||
LeftOrRight::Right(t) => LeftOrRight::Right(f(t)),
|
||||
}
|
||||
}
|
||||
fn as_ref(&self) -> LeftOrRight<&T> {
|
||||
|
||||
pub fn as_ref(&self) -> LeftOrRight<&T> {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => LeftOrRight::Left(t),
|
||||
LeftOrRight::Right(t) => LeftOrRight::Right(t),
|
||||
}
|
||||
}
|
||||
|
||||
fn as_inner(&self) -> &T {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => t,
|
||||
LeftOrRight::Right(t) => t,
|
||||
}
|
||||
}
|
||||
fn as_inner_mut(&mut self) -> &mut T {
|
||||
pub fn as_inner(&self) -> &T {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => t,
|
||||
LeftOrRight::Right(t) => t,
|
||||
}
|
||||
}
|
||||
|
||||
fn into_inner(self) -> T {
|
||||
pub fn as_inner_mut(&mut self) -> &mut T {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => t,
|
||||
LeftOrRight::Right(t) => t,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn into_inner(self) -> T {
|
||||
match self {
|
||||
LeftOrRight::Left(t) => t,
|
||||
LeftOrRight::Right(t) => t,
|
||||
|
|
@ -213,10 +217,12 @@ impl<N: UnsafeNode> Handle<N> {
|
|||
}
|
||||
}
|
||||
|
||||
#[expect(dead_code)]
|
||||
fn refresh_from_node(&mut self) {
|
||||
*self = Self::from_node(self.node());
|
||||
}
|
||||
|
||||
#[expect(dead_code)]
|
||||
fn is_root(&self) -> bool {
|
||||
matches!(self, Handle::Root(_) | Handle::EmptyRoot)
|
||||
}
|
||||
|
|
@ -647,12 +653,12 @@ impl<N: UnsafeNode> Handle<N> {
|
|||
}
|
||||
}
|
||||
|
||||
struct RBTree<N: UnsafeNode> {
|
||||
pub struct RBTree<N: UnsafeNode> {
|
||||
root: Option<NonNull<N>>,
|
||||
}
|
||||
|
||||
impl<N: UnsafeNode> RBTree<N> {
|
||||
fn new() -> Self {
|
||||
pub fn new() -> Self {
|
||||
Self { root: None }
|
||||
}
|
||||
|
||||
|
|
@ -669,7 +675,7 @@ impl<N: UnsafeNode> RBTree<N> {
|
|||
self.root = handle.node();
|
||||
}
|
||||
|
||||
fn find_by_key<Q>(&self, key: &Q) -> SearchResult<Handle<N>>
|
||||
pub fn find_by_key<Q>(&self, key: &Q) -> SearchResult<Handle<N>>
|
||||
where
|
||||
N::Key: core::borrow::Borrow<Q>,
|
||||
Q: Ord + ?Sized,
|
||||
|
|
@ -818,7 +824,7 @@ impl<N: UnsafeNode> RBTree<N> {
|
|||
None
|
||||
}
|
||||
|
||||
fn remove<Q>(&mut self, key: &Q) -> Option<NonNull<N>>
|
||||
pub fn remove<Q>(&mut self, key: &Q) -> Option<NonNull<N>>
|
||||
where
|
||||
N::Key: core::borrow::Borrow<Q>,
|
||||
Q: Ord + ?Sized,
|
||||
|
|
@ -987,13 +993,19 @@ impl<N: UnsafeNode> RBTree<N> {
|
|||
z.node()
|
||||
}
|
||||
|
||||
fn iter(&self) -> TreeIter<'_, N> {
|
||||
TreeIter {
|
||||
pub fn iter(&self) -> TreeNodeIter<'_, N> {
|
||||
TreeNodeIter {
|
||||
range: TreeRange::full_range(self.root_handle()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<N: UnsafeNode> Default for RBTree<N> {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
enum RangeHandle<N> {
|
||||
Root(Handle<N>),
|
||||
|
|
@ -1028,6 +1040,7 @@ struct TreeRange<'a, N: UnsafeNode> {
|
|||
}
|
||||
|
||||
impl<'a, N: UnsafeNode + 'a> TreeRange<'a, N> {
|
||||
#[expect(dead_code)]
|
||||
fn new(start: Handle<N>, end: Handle<N>) -> Self {
|
||||
Self {
|
||||
start: Some(RangeHandle::Node(start)),
|
||||
|
|
@ -1104,11 +1117,11 @@ impl<'a, N: UnsafeNode + 'a> TreeRange<'a, N> {
|
|||
}
|
||||
}
|
||||
|
||||
struct TreeIter<'a, N: UnsafeNode> {
|
||||
pub struct TreeNodeIter<'a, N: UnsafeNode> {
|
||||
range: TreeRange<'a, N>,
|
||||
}
|
||||
|
||||
impl<'a, N: UnsafeNode + 'a> Iterator for TreeIter<'a, N> {
|
||||
impl<'a, N: UnsafeNode + 'a> Iterator for TreeNodeIter<'a, N> {
|
||||
type Item = Handle<N>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
|
|
@ -1116,12 +1129,34 @@ impl<'a, N: UnsafeNode + 'a> Iterator for TreeIter<'a, N> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, N: UnsafeNode + 'a> DoubleEndedIterator for TreeIter<'a, N> {
|
||||
impl<'a, N: UnsafeNode + 'a> DoubleEndedIterator for TreeNodeIter<'a, N> {
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.range.next_back()
|
||||
}
|
||||
}
|
||||
|
||||
pub struct TreeIter<'a, N: UnsafeNode> {
|
||||
range: TreeRange<'a, N>,
|
||||
}
|
||||
|
||||
impl<'a, N: UnsafeNode + 'a> Iterator for TreeIter<'a, N> {
|
||||
type Item = &'a N::Key;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.range
|
||||
.next()
|
||||
.map(|n| unsafe { n.node().unwrap().as_ref().key() })
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, N: UnsafeNode + 'a> DoubleEndedIterator for TreeIter<'a, N> {
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.range
|
||||
.next_back()
|
||||
.map(|n| unsafe { n.node().unwrap().as_ref().key() })
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::cell::Cell;
|
||||
|
|
|
|||
Loading…
Reference in a new issue