hyperbee 0.5.0

Peer to Peer B-tree
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

use std::{cmp::Ordering, fmt::Debug};

#[derive(Debug, Clone)]
pub enum InfiniteKeys {
    Positive,
    Negative,
}
use InfiniteKeys::{Negative, Positive};

impl PartialEq<[u8]> for InfiniteKeys {
    fn eq(&self, _other: &[u8]) -> bool {
        false
    }
}

impl PartialEq<InfiniteKeys> for [u8] {
    fn eq(&self, _other: &InfiniteKeys) -> bool {
        false
    }
}

impl PartialOrd<[u8]> for InfiniteKeys {
    fn partial_cmp(&self, _other: &[u8]) -> Option<std::cmp::Ordering> {
        Some(match self {
            Positive => Ordering::Greater,
            Negative => Ordering::Less,
        })
    }
}

impl PartialOrd<InfiniteKeys> for [u8] {
    fn partial_cmp(&self, other: &InfiniteKeys) -> Option<Ordering> {
        Some(match other {
            Positive => Ordering::Less,
            Negative => Ordering::Greater,
        })
    }
}

#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn test_slice() {
        let a: Vec<u8> = vec![1, 2, 3];
        let b: &[u8] = &[5, 6, 7];
        assert!(InfiniteKeys::Positive > a[..]);
        assert!(InfiniteKeys::Positive > *b);
        assert!(a[..] < InfiniteKeys::Positive);
        assert!(*b < InfiniteKeys::Positive);
        assert!(a[..] >= InfiniteKeys::Negative);
        assert!(*b >= InfiniteKeys::Negative);
    }
}