Enum EqualSide 

pub enum EqualSide {
    Left,
    Right,
}

Variants

Left

Right

Implementations

impl EqualSide

pub fn goes_left(self, ordering: Ordering) -> bool

Examples found in repository

crates/competitive/src/data_structure/splay_operations.rs (line 428)

pub fn split<Spec, Data, Seeker>(
    root: Option<BstRoot<Spec>>,
    seeker: Seeker,
    equal_side: EqualSide,
) -> (Option<BstRoot<Spec>>, Option<BstRoot<Spec>>)
where
    Spec: BstSpec<Data = Data, Parent = WithNoParent<Data>>,
    Seeker: BstSeeker<Spec = Spec>,
{
    let Some(root) = root else {
        return (None, None);
    };
    let (ordering, mut root) = splay(root, seeker);
    if equal_side.goes_left(ordering) {
        let right = unsafe { root.borrow_mut().right_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (Some(root), right)
    } else {
        let left = unsafe { root.borrow_mut().left_mut().take() };
        Spec::bottom_up(root.borrow_datamut());
        (left, Some(root))
    }
}

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

    fn split<Seeker>(
        node: Option<TreapRoot<M, L>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<TreapRoot<M, L>>, Option<TreapRoot<M, L>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }

crates/competitive/src/data_structure/implicit_treap.rs (line 191)

    fn split<Seeker>(
        node: Option<ImplicitTreapRoot<T>>,
        mut seeker: Seeker,
        equal_side: EqualSide,
    ) -> (Option<ImplicitTreapRoot<T>>, Option<ImplicitTreapRoot<T>>)
    where
        Seeker: BstSeeker<Spec = Self>,
    {
        match node {
            None => (None, None),
            Some(mut node) => {
                Self::top_down(node.borrow_datamut());
                if equal_side.goes_left(seeker.bst_seek(node.reborrow())) {
                    unsafe {
                        let right = node.borrow_mut().right().take();
                        let (l, r) = Self::split(right, seeker, equal_side);
                        if let Some(l) = l {
                            node.borrow_mut().right().set(l);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (Some(node), r)
                    }
                } else {
                    unsafe {
                        let left = node.borrow_mut().left().take();
                        let (l, r) = Self::split(left, seeker, equal_side);
                        if let Some(r) = r {
                            node.borrow_mut().left().set(r);
                        }
                        Self::bottom_up(node.borrow_datamut());
                        (l, Some(node))
                    }
                }
            }
        }
    }

Trait Implementations

impl Clone for EqualSide

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for EqualSide

impl Debug for EqualSide

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for EqualSide

impl PartialEq for EqualSide

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for EqualSide