radn-rs/src/rstd/collections/rbtree.rs

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))
    }
}