Struct Split3 &nbsp; Copy item path

impl<'a, Spec> Split3<'a, Spec>
where Spec: BstSpec,

pub fn new<Seek1, Seek2>( node: &'a mut Option<BstRoot<Spec>>, start: Bound<Seek1>, end: Bound<Seek2>, ) -> Self
where Seek1: BstSeeker<Spec = Spec>, Seek2: BstSeeker<Spec = Spec>,

Examples found in repository ?

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

153    pub fn seek_by_key<K, Q, R>(node: &'a mut Option<BstRoot<Spec>>, range: R) -> Self
154    where
155        Spec: BstSpec<Data: BstDataAccess<data::marker::Key, Value = K>>,
156        K: Borrow<Q>,
157        Q: Ord + ?Sized,
158        R: RangeBounds<Q>,
159    {
160        let start = match range.start_bound() {
161            Bound::Included(key) => Bound::Included(SeekByKey::new(key)),
162            Bound::Excluded(key) => Bound::Excluded(SeekByKey::new(key)),
163            Bound::Unbounded => Bound::Unbounded,
164        };
165        let end = match range.end_bound() {
166            Bound::Included(key) => Bound::Included(SeekByKey::new(key)),
167            Bound::Excluded(key) => Bound::Excluded(SeekByKey::new(key)),
168            Bound::Unbounded => Bound::Unbounded,
169        };
170        Self::new(node, start, end)
171    }
172
173    pub fn seek_by_size<R>(node: &'a mut Option<BstRoot<Spec>>, range: R) -> Self
174    where
175        Spec: BstSpec<Data: BstDataAccess<data::marker::Size, Value = usize>>,
176        R: RangeBounds<usize>,
177    {
178        let start = match range.start_bound() {
179            Bound::Included(&index) => Bound::Included(SeekBySize::new(index)),
180            Bound::Excluded(&index) => Bound::Excluded(SeekBySize::new(index)),
181            Bound::Unbounded => Bound::Unbounded,
182        };
183        let end = match range.end_bound() {
184            Bound::Included(&index) => Bound::Included(SeekBySize::new(index)),
185            Bound::Excluded(&index) => Bound::Excluded(SeekBySize::new(index)),
186            Bound::Unbounded => Bound::Unbounded,
187        };
188        Self::new(node, start, end)
189    }

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

Examples found in repository ?

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

360    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
361    where
362        F: FnMut(&T::Agg) -> bool,
363    {
364        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
365        let front_size = split3
366            .left()
367            .map(|node| node.into_data().size)
368            .unwrap_or_default();
369        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
370        let index = split
371            .left()
372            .map(|node| node.into_data().size)
373            .unwrap_or_default();
374        front_size + index
375    }

More examples

Hide additional examples

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

464    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
465    where
466        F: FnMut(&T::Agg) -> bool,
467    {
468        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
469        let front_size = split3
470            .left()
471            .map(|node| node.into_data().size)
472            .unwrap_or_default();
473        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
474        let index = split
475            .left()
476            .map(|node| node.into_data().size)
477            .unwrap_or_default();
478        front_size + index
479    }

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

Examples found in repository ?

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

469    pub fn fold(&self) -> L::Agg {
470        if let Some(node) = self.split3.mid() {
471            node.reborrow().into_data().value.agg.clone()
472        } else {
473            L::agg_unit()
474        }
475    }

More examples

Hide additional examples

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

276    pub fn fold<R>(&mut self, range: R) -> T::Agg
277    where
278        R: RangeBounds<usize>,
279    {
280        let split = Split3::seek_by_size(&mut self.root, range);
281        split
282            .mid()
283            .map(|node| node.into_data().value.agg.clone())
284            .unwrap_or_else(T::agg_unit)
285    }

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

359    pub fn fold<R>(&mut self, range: R) -> T::Agg
360    where
361        R: RangeBounds<usize>,
362    {
363        let split = Split3::seek_by_size(&mut self.root, range);
364        split
365            .mid()
366            .map(|node| node.into_data().value.agg.clone())
367            .unwrap_or_else(T::agg_unit)
368    }
369
370    pub fn reverse<R>(&mut self, range: R)
371    where
372        R: RangeBounds<usize>,
373    {
374        let mut split = Split3::seek_by_size(&mut self.root, range);
375        if let Some(root) = split.mid_datamut() {
376            ImplicitTreapSpec::<T>::reverse(root);
377        }
378    }
379
380    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
381        if index >= self.length {
382            return None;
383        }
384        let split = Split3::seek_by_size(&mut self.root, index..=index);
385        let node = split.mid()?.node;
386        drop(split);
387        Some(unsafe { &(*node.as_ptr()).data.value.key })
388    }

crates/competitive/src/data_structure/splay_tree.rs (line 360)

358    fn new(split: Split3<'a, SplayTreeSpec<K, V>>) -> Self {
359        let remaining = split
360            .mid()
361            .map(|node| node.into_data().size)
362            .unwrap_or_default();
363        let mut iter = Self {
364            split,
365            front: vec![],
366            back: vec![],
367            remaining,
368        };
369        if let Some(root) = iter.split.mid() {
370            Self::push_left(root.node, &mut iter.front);
371            Self::push_right(root.node, &mut iter.back);
372        }
373        iter
374    }

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

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

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

Examples found in repository ?

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

477    pub fn update_key(&mut self, act: M::Act) {
478        if let Some(node) = self.split3.mid_datamut() {
479            MonoidActElement::<M>::update_act(node, &act);
480            self.key_updated = true;
481        }
482    }
483
484    pub fn update_value(&mut self, act: L::Act) {
485        if let Some(node) = self.split3.mid_datamut() {
486            LazyMapElement::<L>::update_act(node, &act);
487        }
488    }

More examples

Hide additional examples

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

349    pub fn update<R>(&mut self, range: R, x: T::Act)
350    where
351        R: RangeBounds<usize>,
352    {
353        let mut split = Split3::seek_by_size(&mut self.root, range);
354        if let Some(root) = split.mid_datamut() {
355            ImplicitTreapSpec::<T>::update_act(root, &x);
356        }
357    }
358
359    pub fn fold<R>(&mut self, range: R) -> T::Agg
360    where
361        R: RangeBounds<usize>,
362    {
363        let split = Split3::seek_by_size(&mut self.root, range);
364        split
365            .mid()
366            .map(|node| node.into_data().value.agg.clone())
367            .unwrap_or_else(T::agg_unit)
368    }
369
370    pub fn reverse<R>(&mut self, range: R)
371    where
372        R: RangeBounds<usize>,
373    {
374        let mut split = Split3::seek_by_size(&mut self.root, range);
375        if let Some(root) = split.mid_datamut() {
376            ImplicitTreapSpec::<T>::reverse(root);
377        }
378    }
379
380    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
381        if index >= self.length {
382            return None;
383        }
384        let split = Split3::seek_by_size(&mut self.root, index..=index);
385        let node = split.mid()?.node;
386        drop(split);
387        Some(unsafe { &(*node.as_ptr()).data.value.key })
388    }
389
390    pub fn modify<F>(&mut self, index: usize, f: F)
391    where
392        F: FnOnce(&T::Key) -> T::Key,
393    {
394        assert!(index < self.length);
395        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
396        let mut node = split.mid_datamut().unwrap();
397        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
398        {
399            let data = node.data_mut();
400            data.value.key = f(&data.value.key);
401        }
402        ImplicitTreapSpec::<T>::bottom_up(node);
403    }

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

266    pub fn update<R>(&mut self, range: R, act: T::Act)
267    where
268        R: RangeBounds<usize>,
269    {
270        let mut split = Split3::seek_by_size(&mut self.root, range);
271        if let Some(root) = split.mid_datamut() {
272            ImplicitSplayTreeSpec::update_act(root, &act);
273        }
274    }
275
276    pub fn fold<R>(&mut self, range: R) -> T::Agg
277    where
278        R: RangeBounds<usize>,
279    {
280        let split = Split3::seek_by_size(&mut self.root, range);
281        split
282            .mid()
283            .map(|node| node.into_data().value.agg.clone())
284            .unwrap_or_else(T::agg_unit)
285    }
286
287    pub fn reverse<R>(&mut self, range: R)
288    where
289        R: RangeBounds<usize>,
290    {
291        let mut split = Split3::seek_by_size(&mut self.root, range);
292        if let Some(root) = split.mid_datamut() {
293            ImplicitSplayTreeSpec::reverse(root);
294        }
295    }

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

pub fn split_mid<Seek>( &mut self, seeker: Seek, equal_side: EqualSide, ) -> Split<'_, Spec>
where Seek: BstSeeker<Spec = Spec>,

Examples found in repository ?

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

360    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
361    where
362        F: FnMut(&T::Agg) -> bool,
363    {
364        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
365        let front_size = split3
366            .left()
367            .map(|node| node.into_data().size)
368            .unwrap_or_default();
369        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
370        let index = split
371            .left()
372            .map(|node| node.into_data().size)
373            .unwrap_or_default();
374        front_size + index
375    }
376
377    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
378    where
379        F: FnMut(&T::Agg) -> bool,
380    {
381        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
382        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
383        split
384            .left()
385            .map(|node| node.into_data().size)
386            .unwrap_or_default()
387    }

More examples

Hide additional examples

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

464    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
465    where
466        F: FnMut(&T::Agg) -> bool,
467    {
468        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
469        let front_size = split3
470            .left()
471            .map(|node| node.into_data().size)
472            .unwrap_or_default();
473        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
474        let index = split
475            .left()
476            .map(|node| node.into_data().size)
477            .unwrap_or_default();
478        front_size + index
479    }
480
481    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
482    where
483        F: FnMut(&T::Agg) -> bool,
484    {
485        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
486        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
487        split
488            .left()
489            .map(|node| node.into_data().size)
490            .unwrap_or_default()
491    }

pub fn manually_merge<F>(&mut self, f: F)
where F: FnMut(Option<BstRoot<Spec>>, Option<BstRoot<Spec>>) -> Option<BstRoot<Spec>>,

Examples found in repository ?

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

496    fn drop(&mut self) {
497        if self.key_updated {
498            self.split3.manually_merge(TreapSpec::merge_ordered);
499        }
500    }

pub fn seek_by_key<K, Q, R>( node: &'a mut Option<BstRoot<Spec>>, range: R, ) -> Self
where Spec: BstSpec<Data: BstDataAccess<Key, Value = K>>, K: Borrow<Q>, Q: Ord + ?Sized, R: RangeBounds<Q>,

Examples found in repository ?

crates/competitive/src/data_structure/splay_tree.rs (line 331)

325    pub fn range<Q, R>(&mut self, range: R) -> Iter<'_, K, V>
326    where
327        K: Borrow<Q>,
328        Q: Ord + ?Sized,
329        R: RangeBounds<Q>,
330    {
331        Iter::new(Split3::seek_by_key(&mut self.root, range))
332    }

More examples

Hide additional examples

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

399    pub fn range_by_key<Q, R>(&mut self, range: R) -> TreapSplit3<'_, M, L>
400    where
401        M: MonoidAct<Key: Borrow<Q>>,
402        Q: Ord + ?Sized,
403        R: RangeBounds<Q>,
404    {
405        let split3 = Split3::seek_by_key(&mut self.root, range);
406        TreapSplit3 {
407            split3,
408            key_updated: false,
409        }
410    }

pub fn seek_by_size<R>(node: &'a mut Option<BstRoot<Spec>>, range: R) -> Self
where Spec: BstSpec<Data: BstDataAccess<Size, Value = usize>>, R: RangeBounds<usize>,

Examples found in repository ?

crates/competitive/src/data_structure/splay_tree.rs (line 322)

321    pub fn iter(&mut self) -> Iter<'_, K, V> {
322        Iter::new(Split3::seek_by_size(&mut self.root, ..))
323    }
324
325    pub fn range<Q, R>(&mut self, range: R) -> Iter<'_, K, V>
326    where
327        K: Borrow<Q>,
328        Q: Ord + ?Sized,
329        R: RangeBounds<Q>,
330    {
331        Iter::new(Split3::seek_by_key(&mut self.root, range))
332    }
333
334    pub fn range_at<R>(&mut self, range: R) -> Iter<'_, K, V>
335    where
336        R: RangeBounds<usize>,
337    {
338        Iter::new(Split3::seek_by_size(&mut self.root, range))
339    }

More examples

Hide additional examples

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

349    pub fn update<R>(&mut self, range: R, x: T::Act)
350    where
351        R: RangeBounds<usize>,
352    {
353        let mut split = Split3::seek_by_size(&mut self.root, range);
354        if let Some(root) = split.mid_datamut() {
355            ImplicitTreapSpec::<T>::update_act(root, &x);
356        }
357    }
358
359    pub fn fold<R>(&mut self, range: R) -> T::Agg
360    where
361        R: RangeBounds<usize>,
362    {
363        let split = Split3::seek_by_size(&mut self.root, range);
364        split
365            .mid()
366            .map(|node| node.into_data().value.agg.clone())
367            .unwrap_or_else(T::agg_unit)
368    }
369
370    pub fn reverse<R>(&mut self, range: R)
371    where
372        R: RangeBounds<usize>,
373    {
374        let mut split = Split3::seek_by_size(&mut self.root, range);
375        if let Some(root) = split.mid_datamut() {
376            ImplicitTreapSpec::<T>::reverse(root);
377        }
378    }
379
380    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
381        if index >= self.length {
382            return None;
383        }
384        let split = Split3::seek_by_size(&mut self.root, index..=index);
385        let node = split.mid()?.node;
386        drop(split);
387        Some(unsafe { &(*node.as_ptr()).data.value.key })
388    }
389
390    pub fn modify<F>(&mut self, index: usize, f: F)
391    where
392        F: FnOnce(&T::Key) -> T::Key,
393    {
394        assert!(index < self.length);
395        let mut split = Split3::seek_by_size(&mut self.root, index..=index);
396        let mut node = split.mid_datamut().unwrap();
397        ImplicitTreapSpec::<T>::top_down(node.reborrow_datamut());
398        {
399            let data = node.data_mut();
400            data.value.key = f(&data.value.key);
401        }
402        ImplicitTreapSpec::<T>::bottom_up(node);
403    }
404
405    pub fn insert(&mut self, index: usize, x: T::Key) {
406        assert!(index <= self.length);
407        let node = self.node(x);
408        if index == 0 {
409            self.root = ImplicitTreapSpec::<T>::merge(Some(node), self.root.take());
410        } else if index == self.length {
411            self.root = ImplicitTreapSpec::<T>::merge(self.root.take(), Some(node));
412        } else {
413            let mut node = Some(node);
414            let mut split = Split::new(&mut self.root, SeekBySize::new(index), EqualSide::Right);
415            split.manually_merge(|left, right| {
416                ImplicitTreapSpec::<T>::merge(
417                    ImplicitTreapSpec::<T>::merge(left, node.take()),
418                    right,
419                )
420            });
421        }
422        self.length += 1;
423    }
424
425    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
426        if index >= self.length {
427            return None;
428        }
429        let mid;
430        if index == 0 {
431            let (left, right) = ImplicitTreapSpec::<T>::split(
432                self.root.take(),
433                SeekBySize::new(1),
434                EqualSide::Right,
435            );
436            mid = left;
437            self.root = right;
438        } else if index + 1 == self.length {
439            let (left, right) = ImplicitTreapSpec::<T>::split(
440                self.root.take(),
441                SeekBySize::new(index),
442                EqualSide::Right,
443            );
444            mid = right;
445            self.root = left;
446        } else {
447            let (left, rest) = ImplicitTreapSpec::<T>::split(
448                self.root.take(),
449                SeekBySize::new(index),
450                EqualSide::Right,
451            );
452            let (middle, right) =
453                ImplicitTreapSpec::<T>::split(rest, SeekBySize::new(1), EqualSide::Right);
454            mid = middle;
455            self.root = ImplicitTreapSpec::<T>::merge(left, right);
456        }
457        self.length -= 1;
458        let mut node = mid.unwrap();
459        ImplicitTreapSpec::<T>::top_down(node.borrow_datamut());
460        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
461        Some(data.value.key)
462    }
463
464    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
465    where
466        F: FnMut(&T::Agg) -> bool,
467    {
468        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
469        let front_size = split3
470            .left()
471            .map(|node| node.into_data().size)
472            .unwrap_or_default();
473        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
474        let index = split
475            .left()
476            .map(|node| node.into_data().size)
477            .unwrap_or_default();
478        front_size + index
479    }
480
481    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
482    where
483        F: FnMut(&T::Agg) -> bool,
484    {
485        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
486        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
487        split
488            .left()
489            .map(|node| node.into_data().size)
490            .unwrap_or_default()
491    }

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

266    pub fn update<R>(&mut self, range: R, act: T::Act)
267    where
268        R: RangeBounds<usize>,
269    {
270        let mut split = Split3::seek_by_size(&mut self.root, range);
271        if let Some(root) = split.mid_datamut() {
272            ImplicitSplayTreeSpec::update_act(root, &act);
273        }
274    }
275
276    pub fn fold<R>(&mut self, range: R) -> T::Agg
277    where
278        R: RangeBounds<usize>,
279    {
280        let split = Split3::seek_by_size(&mut self.root, range);
281        split
282            .mid()
283            .map(|node| node.into_data().value.agg.clone())
284            .unwrap_or_else(T::agg_unit)
285    }
286
287    pub fn reverse<R>(&mut self, range: R)
288    where
289        R: RangeBounds<usize>,
290    {
291        let mut split = Split3::seek_by_size(&mut self.root, range);
292        if let Some(root) = split.mid_datamut() {
293            ImplicitSplayTreeSpec::reverse(root);
294        }
295    }
296
297    pub fn get(&mut self, index: usize) -> Option<&T::Key> {
298        if index >= self.length {
299            return None;
300        }
301        self.splay(SeekBySize::new(index));
302        Some(&self.root.as_ref()?.reborrow().into_data().value.key)
303    }
304
305    pub fn modify<F>(&mut self, index: usize, f: F)
306    where
307        F: FnOnce(&T::Key) -> T::Key,
308    {
309        assert!(index < self.length);
310        self.splay(SeekBySize::new(index));
311        let mut root = self.root.as_mut().unwrap().borrow_datamut();
312        ImplicitSplayTreeSpec::top_down(root.reborrow_datamut());
313        {
314            let data = root.data_mut();
315            data.value.key = f(&data.value.key);
316        }
317        ImplicitSplayTreeSpec::bottom_up(root);
318    }
319
320    pub fn insert(&mut self, index: usize, key: T::Key) {
321        assert!(index <= self.length);
322        let mut node = self.node(key);
323        if self.root.is_none() {
324            self.root = Some(node);
325        } else if index == self.length {
326            self.splay(SeekBySize::new(index));
327            unsafe { node.borrow_mut().left_mut().set(self.root.take().unwrap()) };
328            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
329            self.root = Some(node);
330        } else {
331            self.splay(SeekBySize::new(index));
332            let mut root = self.root.take().unwrap();
333            let left = unsafe { root.borrow_mut().left_mut().take() };
334            if let Some(left) = left {
335                unsafe { node.borrow_mut().left_mut().set(left) };
336            }
337            ImplicitSplayTreeSpec::bottom_up(root.borrow_datamut());
338            unsafe { node.borrow_mut().right_mut().set(root) };
339            ImplicitSplayTreeSpec::bottom_up(node.borrow_datamut());
340            self.root = Some(node);
341        }
342        self.length += 1;
343    }
344
345    pub fn remove(&mut self, index: usize) -> Option<T::Key> {
346        if index >= self.length {
347            return None;
348        }
349        self.splay(SeekBySize::new(index));
350        let mut node = self.root.take().unwrap();
351        ImplicitSplayTreeSpec::top_down(node.borrow_datamut());
352        let left = unsafe { node.borrow_mut().left_mut().take() };
353        let right = unsafe { node.borrow_mut().right_mut().take() };
354        self.root = ImplicitSplayTreeSpec::merge(left, right);
355        self.length -= 1;
356        let data = unsafe { node.into_dying().into_data(self.allocator.deref_mut()) };
357        Some(data.value.key)
358    }
359
360    pub fn partition_point_acc<F>(&mut self, left: usize, mut pred: F) -> usize
361    where
362        F: FnMut(&T::Agg) -> bool,
363    {
364        let mut split3 = Split3::seek_by_size(&mut self.root, left..);
365        let front_size = split3
366            .left()
367            .map(|node| node.into_data().size)
368            .unwrap_or_default();
369        let split = split3.split_mid(SeekByAccCond::new(|acc| !pred(acc)), EqualSide::Right);
370        let index = split
371            .left()
372            .map(|node| node.into_data().size)
373            .unwrap_or_default();
374        front_size + index
375    }
376
377    pub fn rpartition_point_acc<F>(&mut self, right: usize, mut pred: F) -> usize
378    where
379        F: FnMut(&T::Agg) -> bool,
380    {
381        let mut split3 = Split3::seek_by_size(&mut self.root, ..right);
382        let split = split3.split_mid(SeekByRaccCond::new(|acc| !pred(acc)), EqualSide::Left);
383        split
384            .left()
385            .map(|node| node.into_data().size)
386            .unwrap_or_default()
387    }

Trait Implementations§

impl<'a, Spec> Drop for Split3<'a, Spec>
where Spec: BstSpec,

fn drop(&mut self)

Executes the destructor for this type. Read more

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more

Auto Trait Implementations§

impl<'a, Spec> Freeze for Split3<'a, Spec>
where Option<BstNodeRef<Owned, Spec>>: Freeze, &'a mut Option<BstNodeRef<Owned, Spec>>: Freeze,

impl<'a, Spec> RefUnwindSafe for Split3<'a, Spec>
where Option<BstNodeRef<Owned, Spec>>: RefUnwindSafe, &'a mut Option<BstNodeRef<Owned, Spec>>: RefUnwindSafe,

impl<'a, Spec> Unpin for Split3<'a, Spec>
where Option<BstNodeRef<Owned, Spec>>: Unpin, &'a mut Option<BstNodeRef<Owned, Spec>>: Unpin,

impl<'a, Spec> UnsafeUnpin for Split3<'a, Spec>
where Option<BstNodeRef<Owned, Spec>>: UnsafeUnpin, &'a mut Option<BstNodeRef<Owned, Spec>>: UnsafeUnpin,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToArrayVecScalar for T

fn to_array_vec_scalar(self) -> ArrayVecScalar<T>

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = !

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.