Struct Split 

pub struct Split<'a, Spec>
where
    Spec: BstSpec,
{
    left: Option<BstRoot<Spec>>,
    right: Option<BstRoot<Spec>>,
    root: &'a mut Option<BstRoot<Spec>>,
}

Fields

left: Option<BstRoot<Spec>>

right: Option<BstRoot<Spec>>

root: &'a mut Option<BstRoot<Spec>>

Implementations

impl<'a, Spec> Split<'a, Spec>

where Spec: BstSpec,

pub fn new<Seek>( node: &'a mut Option<BstRoot<Spec>>, seeker: Seek, eq_left: bool, ) -> Self

where Seek: BstSeeker<Spec = Spec>,

Examples found in repository

crates/competitive/src/data_structure/treap.rs (lines 421-425)

    pub fn find_by_key<Q>(&mut self, key: &Q) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        M: MonoidAct<Key: Borrow<Q>>,
        Q: Ord + ?Sized,
    {
        let split = Split::new(
            &mut self.root,
            SeekByKey::<TreapSpec<M, L>, M::Key, Q>::new(key),
            false,
        );
        let node = split.right()?.leftmost()?;
        matches!(node.into_data().key.key.borrow().cmp(key), Ordering::Equal)
            .then(|| self.node_id_manager.registerd_node_id(node))
            .flatten()
    }

    pub fn find_by_acc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByAccCond::<TreapSpec<M, L>, L, F>::new(f),
            false,
        );
        let node = split.right()?.leftmost()?;
        self.node_id_manager.registerd_node_id(node)
    }

    pub fn find_by_racc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByRaccCond::<TreapSpec<M, L>, L, F>::new(f),
            true,
        );
        let node = split.left()?.rightmost()?;
        self.node_id_manager.registerd_node_id(node)
    }

pub fn left(&self) -> Option<BstImmutRef<'_, Spec>>

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 454)

    pub fn find_by_racc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByRaccCond::<TreapSpec<M, L>, L, F>::new(f),
            true,
        );
        let node = split.left()?.rightmost()?;
        self.node_id_manager.registerd_node_id(node)
    }

pub fn right(&self) -> Option<BstImmutRef<'_, Spec>>

Examples found in repository

crates/competitive/src/data_structure/treap.rs (line 426)

    pub fn find_by_key<Q>(&mut self, key: &Q) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        M: MonoidAct<Key: Borrow<Q>>,
        Q: Ord + ?Sized,
    {
        let split = Split::new(
            &mut self.root,
            SeekByKey::<TreapSpec<M, L>, M::Key, Q>::new(key),
            false,
        );
        let node = split.right()?.leftmost()?;
        matches!(node.into_data().key.key.borrow().cmp(key), Ordering::Equal)
            .then(|| self.node_id_manager.registerd_node_id(node))
            .flatten()
    }

    pub fn find_by_acc_cond<F>(&mut self, f: F) -> Option<BstNodeId<TreapSpec<M, L>>>
    where
        F: FnMut(&L::Agg) -> bool,
    {
        let split = Split::new(
            &mut self.root,
            SeekByAccCond::<TreapSpec<M, L>, L, F>::new(f),
            false,
        );
        let node = split.right()?.leftmost()?;
        self.node_id_manager.registerd_node_id(node)
    }

pub fn left_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>>

pub fn right_datamut(&mut self) -> Option<BstDataMutRef<'_, Spec>>

pub fn manually_merge<F>(&mut self, f: F)

where F: FnMut(Option<BstRoot<Spec>>, Option<BstRoot<Spec>>) -> Option<BstRoot<Spec>>,

Trait Implementations

impl<'a, Spec> Drop for Split<'a, Spec>

where Spec: BstSpec,

fn drop(&mut self)

Executes the destructor for this type.