Struct LazyMapElement 

pub struct LazyMapElement<L>
where
    L: LazyMapMonoid,
{
    pub key: L::Key,
    pub agg: L::Agg,
    pub act: L::Act,
}

Fields

key: L::Key

agg: L::Agg

act: L::Act

Implementations

impl<L> LazyMapElement<L>

where L: LazyMapMonoid,

pub fn from_key(key: L::Key) -> Self

Examples found in repository

crates/competitive/src/tree/link_cut_tree.rs (line 458)

    fn new(value: Self::Value) -> Self::Data {
        Self::Data {
            value: LazyMapElement::from_key(value),
        }
    }

crates/competitive/src/data_structure/implicit_splay_tree.rs (line 240)

    fn node(&mut self, key: T::Key) -> ImplicitSplayTreeRoot<T> {
        BstRoot::from_data(
            ImplicitSplayTreeData {
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

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

    fn node(&mut self, key: T::Key) -> ImplicitTreapRoot<T> {
        BstRoot::from_data(
            ImplicitTreapData {
                priority: self.rng.rand64(),
                value: LazyMapElement::from_key(key),
                size: 1,
                rev: false,
            },
            self.allocator.deref_mut(),
        )
    }

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

    pub fn insert(&mut self, key: M::Key, value: L::Key) -> BstNodeId<TreapSpec<M, L>> {
        let (left, right) =
            TreapSpec::split(self.root.take(), SeekByKey::new(&key), EqualSide::Right);
        let data = TreapData {
            priority: self.rng.rand64(),
            key: MonoidActElement::from_key(key),
            value: LazyMapElement::from_key(value),
        };
        let node = BstRoot::from_data(data, self.allocator.deref_mut());
        let node_id = self.node_id_manager.register(&node);
        self.root = TreapSpec::merge(TreapSpec::merge(left, Some(node)), right);
        node_id
    }

pub fn update_act<Spec>(node: BstDataMutRef<'_, Spec>, act: &L::Act)

where Spec: BstSpec<Data: BstDataAccess<LazyMap, Value = Self>>,

Examples found in repository

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

    pub fn update_value(&mut self, act: L::Act) {
        if let Some(node) = self.split3.mid_datamut() {
            LazyMapElement::<L>::update_act(node, &act);
        }
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 170)

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(&node.reborrow().into_data().bst_data().act) {
            return;
        }
        let act = replace(&mut node.data_mut().bst_data_mut().act, L::act_unit());
        if let Ok(left) = node.reborrow_datamut().left().descend() {
            Self::update_act(left, &act);
        }
        if let Ok(right) = node.reborrow_datamut().right().descend() {
            Self::update_act(right, &act);
        }
    }

pub fn top_down<Spec>(node: BstDataMutRef<'_, Spec>)

where Spec: BstSpec<Data: BstDataAccess<LazyMap, Value = Self>>,

Examples found in repository

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

    fn top_down(mut node: BstDataMutRef<'_, Self>) {
        MonoidActElement::<M>::top_down(node.reborrow_datamut());
        LazyMapElement::<L>::top_down(node.reborrow_datamut());
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 156)

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

pub fn bottom_up<Spec>(node: BstDataMutRef<'_, Spec>)

where Spec: BstSpec<Data: BstDataAccess<LazyMap, Value = Self>>,

Examples found in repository

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

    fn bottom_up(mut node: BstDataMutRef<'_, Self>) {
        LazyMapElement::<L>::bottom_up(node.reborrow_datamut());
    }

crates/competitive/src/data_structure/binary_search_tree/data.rs (line 157)

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        if L::is_act_unit(act) {
            return;
        }
        L::act_operate_assign(&mut node.data_mut().bst_data_mut().act, act);
        node.data_mut().bst_data_mut().key =
            L::act_key(&node.reborrow().into_data().bst_data().key, act);
        if let Some(nxlazy) = L::act_agg(&node.reborrow().into_data().bst_data().agg, act) {
            node.data_mut().bst_data_mut().agg = nxlazy;
        } else {
            Self::top_down(node.reborrow_datamut());
            Self::bottom_up(node.reborrow_datamut());
        }
    }

Trait Implementations

impl<L> Debug for LazyMapElement<L>

where L: LazyMapMonoid<Key: Debug, Agg: Debug, Act: Debug>,

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

Formats the value using the given formatter.