Files
app
gpio.rsi2c.rslib.rspwm.rsspi.rs
as_slice
lib.rs
byteorder
lib.rs
cty
lib.rs
generic_array
arr.rsfunctional.rshex.rsimpls.rsiter.rslib.rssequence.rs
hash32
fnv.rslib.rsmurmur3.rs
heapless
pool
llsc.rsmod.rssingleton.rs
spsc
mod.rssplit.rs
binary_heap.rshistbuf.rsi.rsindexmap.rsindexset.rslib.rslinear_map.rsmpmc.rssealed.rsstring.rsvec.rs
stable_deref_trait
lib.rs
typenum
array.rsbit.rsint.rslib.rsmarker_traits.rsoperator_aliases.rsprivate.rstype_operators.rsuint.rs
 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

/// Sealed traits and implementations for `binary_heap`
pub mod binary_heap {
    use crate::binary_heap::{Max, Min};
    use core::cmp::Ordering;

    /// The binary heap kind: min-heap or max-heap
    pub unsafe trait Kind {
        #[doc(hidden)]
        fn ordering() -> Ordering;
    }

    unsafe impl Kind for Min {
        fn ordering() -> Ordering {
            Ordering::Less
        }
    }

    unsafe impl Kind for Max {
        fn ordering() -> Ordering {
            Ordering::Greater
        }
    }
}

#[allow(dead_code)]
#[allow(path_statements)]
pub(crate) const fn greater_than_0<const N: usize>() {
    Assert::<N, 0>::GREATER;
}

#[allow(dead_code)]
#[allow(path_statements)]
pub(crate) const fn greater_than_1<const N: usize>() {
    Assert::<N, 1>::GREATER;
}

#[allow(dead_code)]
/// Const assert hack
pub struct Assert<const L: usize, const R: usize>;

#[allow(dead_code)]
impl<const L: usize, const R: usize> Assert<L, R> {
    /// Const assert hack
    pub const GREATER_EQ: usize = L - R;

    /// Const assert hack
    pub const LESS_EQ: usize = R - L;

    /// Const assert hack
    pub const NOT_EQ: isize = 0 / (R as isize - L as isize);

    /// Const assert hack
    pub const EQ: usize = (R - L) + (L - R);

    /// Const assert hack
    pub const GREATER: usize = L - R - 1;

    /// Const assert hack
    pub const LESS: usize = R - L - 1;
}