From 344831dc91508536cd3175c182def6318056f64d Mon Sep 17 00:00:00 2001 From: timofey Date: Fri, 16 Jun 2023 05:27:06 +0000 Subject: [PATCH] delete `rbtree` --- src/rstd/collections.rs | 1 - src/rstd/collections/rbtree.rs | 263 --------------------------------- 2 files changed, 264 deletions(-) delete mode 100644 src/rstd/collections/rbtree.rs diff --git a/src/rstd/collections.rs b/src/rstd/collections.rs index 73697df..3db9aad 100644 --- a/src/rstd/collections.rs +++ b/src/rstd/collections.rs @@ -2,5 +2,4 @@ pub mod avl; pub mod pair; -pub mod rbtree; pub mod stack; diff --git a/src/rstd/collections/rbtree.rs b/src/rstd/collections/rbtree.rs deleted file mode 100644 index f76a71e..0000000 --- a/src/rstd/collections/rbtree.rs +++ /dev/null @@ -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 { - Boolean(BooleanParseError), - Point(PointParseError), - Key(E), -} - -impl From for TreeParseError { - fn from(value: BooleanParseError) -> Self { - Self::Boolean(value) - } -} - -impl From for TreeParseError { - fn from(value: PointParseError) -> Self { - Self::Point(value) - } -} - -impl Display for TreeParseError { - 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 Error for TreeParseError {} - -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, -} - -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, -} - -#[derive(Clone)] -pub struct RBFactory { - key_factory: F, -} - -#[derive(Clone)] -pub struct BFactory { - key_factory: F, -} - -#[derive(Clone)] -pub struct RFactory { - 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; - - 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; - - 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; - - 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 { - type Mtbl = RBNode<'a, Ctx, F::Mtbl>; - - type ParseError = TreeParseError; - - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: std::rc::Rc>, - 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 { - type Mtbl = BNode<'a, Ctx, F::Mtbl>; - - type ParseError = TreeParseError; - - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: std::rc::Rc>, - 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 { - type Mtbl = RNode<'a, Ctx, F::Mtbl>; - - type ParseError = TreeParseError; - - fn deserialize( - &self, - deserializer: &mut dyn Deserializer, - resolver: std::rc::Rc>, - 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)) - } -}