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/data_structure/treap.rs (line 376)

    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), false);
        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 490)

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

    pub fn top_down<Spec>(mut node: BstDataMutRef<'_, Spec>)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        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 153)

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        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 154)

    pub fn update_act<Spec>(mut node: BstDataMutRef<'_, Spec>, act: &L::Act)
    where
        Spec: BstSpec<Data: BstDataAccess<marker::LazyMap, Value = Self>>,
    {
        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.