delete rbtree
This commit is contained in:
parent
9d3da4f97c
commit
344831dc91
@ -2,5 +2,4 @@
|
||||
|
||||
pub mod avl;
|
||||
pub mod pair;
|
||||
pub mod rbtree;
|
||||
pub mod stack;
|
||||
|
||||
@ -1,263 +0,0 @@
|
||||
pub mod subset;
|
||||
|
||||
use std::{error::Error, fmt::Display, rc::Rc};
|
||||
|
||||
use crate::rcore::*;
|
||||
use crate::rstd::{
|
||||
atomic::{boolean::*, *},
|
||||
nullable::*,
|
||||
point::*,
|
||||
};
|
||||
|
||||
const B: bool = false;
|
||||
const R: bool = true;
|
||||
type RB = bool;
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum TreeParseError<E> {
|
||||
Boolean(BooleanParseError),
|
||||
Point(PointParseError),
|
||||
Key(E),
|
||||
}
|
||||
|
||||
impl<E> From<BooleanParseError> for TreeParseError<E> {
|
||||
fn from(value: BooleanParseError) -> Self {
|
||||
Self::Boolean(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E> From<PointParseError> for TreeParseError<E> {
|
||||
fn from(value: PointParseError) -> Self {
|
||||
Self::Point(value)
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Display> Display for TreeParseError<E> {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Self::Boolean(boolean_error) => {
|
||||
f.write_fmt(format_args!("failed to parse RB flag: {boolean_error}"))
|
||||
}
|
||||
Self::Point(point_error) => f.write_fmt(format_args!(
|
||||
"failed to parse RB tree reference: {point_error}"
|
||||
)),
|
||||
Self::Key(key_error) => {
|
||||
f.write_fmt(format_args!("failed to parse RB tree key: {key_error}"))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<E: Error> Error for TreeParseError<E> {}
|
||||
|
||||
pub enum RBNode<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> {
|
||||
R(RNode<'a, Ctx, A>),
|
||||
B(BNode<'a, Ctx, A>),
|
||||
}
|
||||
|
||||
pub struct BNode<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> {
|
||||
cl: Nullable<'a, Ctx, RBNode<'a, Ctx, A>>,
|
||||
cr: Nullable<'a, Ctx, RBNode<'a, Ctx, A>>,
|
||||
key: Rc<A>,
|
||||
}
|
||||
|
||||
pub struct RNode<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> {
|
||||
cl: Nullable<'a, Ctx, BNode<'a, Ctx, A>>,
|
||||
cr: Nullable<'a, Ctx, BNode<'a, Ctx, A>>,
|
||||
key: Rc<A>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct RBFactory<F> {
|
||||
key_factory: F,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct BFactory<F> {
|
||||
key_factory: F,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct RFactory<F> {
|
||||
key_factory: F,
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> RBNode<'a, Ctx, A> {
|
||||
fn key(&self) -> &A {
|
||||
match self {
|
||||
RBNode::R(RNode { key, .. }) => key,
|
||||
RBNode::B(BNode { key, .. }) => key,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Serializable for RBNode<'a, Ctx, A> {
|
||||
fn serialize(&self, serializer: &mut dyn Serializer) {
|
||||
match self {
|
||||
RBNode::R(r) => {
|
||||
R.serialize(serializer);
|
||||
r.serialize(serializer);
|
||||
}
|
||||
RBNode::B(b) => {
|
||||
B.serialize(serializer);
|
||||
b.serialize(serializer);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Serializable for BNode<'a, Ctx, A> {
|
||||
fn serialize(&self, serializer: &mut dyn Serializer) {
|
||||
self.cl.serialize(serializer);
|
||||
self.cr.serialize(serializer);
|
||||
self.key.serialize(serializer);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Serializable for RNode<'a, Ctx, A> {
|
||||
fn serialize(&self, serializer: &mut dyn Serializer) {
|
||||
self.cl.serialize(serializer);
|
||||
self.cr.serialize(serializer);
|
||||
self.key.serialize(serializer);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for RBNode<'a, Ctx, A> {
|
||||
type Fctr = RBFactory<A::Fctr>;
|
||||
|
||||
fn factory(&self) -> Self::Fctr {
|
||||
RBFactory {
|
||||
key_factory: self.key().factory(),
|
||||
}
|
||||
}
|
||||
|
||||
fn points_typed(&self, points: &mut impl TakesPoints<'a, Ctx>) {
|
||||
match self {
|
||||
RBNode::R(r) => r.points_typed(points),
|
||||
RBNode::B(b) => b.points_typed(points),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for BNode<'a, Ctx, A> {
|
||||
type Fctr = BFactory<A::Fctr>;
|
||||
|
||||
fn factory(&self) -> Self::Fctr {
|
||||
BFactory {
|
||||
key_factory: self.key.factory(),
|
||||
}
|
||||
}
|
||||
|
||||
fn points_typed(&self, points: &mut impl TakesPoints<'a, Ctx>) {
|
||||
self.cl.points_typed(points);
|
||||
self.cr.points_typed(points);
|
||||
self.key.points_typed(points);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for RNode<'a, Ctx, A> {
|
||||
type Fctr = RFactory<A::Fctr>;
|
||||
|
||||
fn factory(&self) -> Self::Fctr {
|
||||
RFactory {
|
||||
key_factory: self.key.factory(),
|
||||
}
|
||||
}
|
||||
|
||||
fn points_typed(&self, points: &mut impl TakesPoints<'a, Ctx>) {
|
||||
self.cl.points_typed(points);
|
||||
self.cr.points_typed(points);
|
||||
self.key.points_typed(points);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for RBFactory<F> {
|
||||
type Mtbl = RBNode<'a, Ctx, F::Mtbl>;
|
||||
|
||||
type ParseError = TreeParseError<F::ParseError>;
|
||||
|
||||
fn deserialize(
|
||||
&self,
|
||||
deserializer: &mut dyn Deserializer,
|
||||
resolver: std::rc::Rc<dyn Resolver<'a, Ctx>>,
|
||||
addresses: &mut Addresses,
|
||||
) -> ParseResult<'a, Ctx, Self> {
|
||||
let rb = RB::a_deserialize(deserializer)?;
|
||||
Ok(match rb {
|
||||
R => RBNode::R(
|
||||
RFactory {
|
||||
key_factory: self.key_factory.clone(),
|
||||
}
|
||||
.deserialize(deserializer, resolver, addresses)?,
|
||||
),
|
||||
B => RBNode::B(
|
||||
BFactory {
|
||||
key_factory: self.key_factory.clone(),
|
||||
}
|
||||
.deserialize(deserializer, resolver, addresses)?,
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
fn unexpected_tail(&self, tail: &[u8]) -> Self::ParseError {
|
||||
TreeParseError::Key(self.key_factory.unexpected_tail(tail))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for BFactory<F> {
|
||||
type Mtbl = BNode<'a, Ctx, F::Mtbl>;
|
||||
|
||||
type ParseError = TreeParseError<F::ParseError>;
|
||||
|
||||
fn deserialize(
|
||||
&self,
|
||||
deserializer: &mut dyn Deserializer,
|
||||
resolver: std::rc::Rc<dyn Resolver<'a, Ctx>>,
|
||||
addresses: &mut Addresses,
|
||||
) -> ParseResult<'a, Ctx, Self> {
|
||||
let nullable_factory = NullableFactory::new(RBFactory {
|
||||
key_factory: self.key_factory.clone(),
|
||||
});
|
||||
let cl = nullable_factory.deserialize(deserializer, resolver.clone(), addresses)?;
|
||||
let cr = nullable_factory.deserialize(deserializer, resolver.clone(), addresses)?;
|
||||
let key = self
|
||||
.key_factory
|
||||
.deserialize(deserializer, resolver, addresses)
|
||||
.map_err(TreeParseError::Key)?
|
||||
.into();
|
||||
Ok(BNode { cl, cr, key })
|
||||
}
|
||||
|
||||
fn unexpected_tail(&self, tail: &[u8]) -> Self::ParseError {
|
||||
TreeParseError::Key(self.key_factory.unexpected_tail(tail))
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ctx: Context<'a>, F: Factory<'a, Ctx>> Factory<'a, Ctx> for RFactory<F> {
|
||||
type Mtbl = RNode<'a, Ctx, F::Mtbl>;
|
||||
|
||||
type ParseError = TreeParseError<F::ParseError>;
|
||||
|
||||
fn deserialize(
|
||||
&self,
|
||||
deserializer: &mut dyn Deserializer,
|
||||
resolver: std::rc::Rc<dyn Resolver<'a, Ctx>>,
|
||||
addresses: &mut Addresses,
|
||||
) -> ParseResult<'a, Ctx, Self> {
|
||||
let nullable_factory = NullableFactory::new(BFactory {
|
||||
key_factory: self.key_factory.clone(),
|
||||
});
|
||||
let cl = nullable_factory.deserialize(deserializer, resolver.clone(), addresses)?;
|
||||
let cr = nullable_factory.deserialize(deserializer, resolver.clone(), addresses)?;
|
||||
let key = self
|
||||
.key_factory
|
||||
.deserialize(deserializer, resolver, addresses)
|
||||
.map_err(TreeParseError::Key)?
|
||||
.into();
|
||||
Ok(RNode { cl, cr, key })
|
||||
}
|
||||
|
||||
fn unexpected_tail(&self, tail: &[u8]) -> Self::ParseError {
|
||||
TreeParseError::Key(self.key_factory.unexpected_tail(tail))
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user