orx-priority-queue 1.8.0

Priority queue traits and high performance d-ary heap implementations.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use crate::priority_queue::PriorityQueue;

impl<N, K> PriorityQueue<N, K> for alloc::collections::BinaryHeap<(N, K)>
where
    K: PartialOrd + Ord,
    N: Ord,
{
    type NodeKey<'a> = &'a (N, K) where Self: 'a, N: 'a, K: 'a;
    type Iter<'a> = alloc::collections::binary_heap::Iter<'a, (N, K)> where Self: 'a, N: 'a, K: 'a;

    #[inline(always)]
    fn len(&self) -> usize {
        alloc::collections::BinaryHeap::len(self)
    }

    #[inline(always)]
    fn capacity(&self) -> usize {
        alloc::collections::BinaryHeap::capacity(self)
    }

    #[inline(always)]
    fn peek(&self) -> Option<&(N, K)> {
        alloc::collections::BinaryHeap::peek(self)
    }

    #[inline(always)]
    fn clear(&mut self) {
        alloc::collections::BinaryHeap::clear(self)
    }

    #[inline(always)]
    fn pop(&mut self) -> Option<(N, K)> {
        alloc::collections::BinaryHeap::pop(self)
    }

    #[inline(always)]
    fn pop_node(&mut self) -> Option<N> {
        alloc::collections::BinaryHeap::pop(self).map(|x| x.0)
    }

    #[inline(always)]
    fn pop_key(&mut self) -> Option<K> {
        alloc::collections::BinaryHeap::pop(self).map(|x| x.1)
    }

    #[inline(always)]
    fn push(&mut self, node: N, key: K) {
        alloc::collections::BinaryHeap::push(self, (node, key))
    }

    #[inline(always)]
    fn push_then_pop(&mut self, node: N, key: K) -> (N, K) {
        alloc::collections::BinaryHeap::push(self, (node, key));
        alloc::collections::BinaryHeap::pop(self).expect("queue cannot be empty")
    }

    #[inline(always)]
    fn iter(&self) -> Self::Iter<'_> {
        self.iter()
    }
}