segmap 0.1.0

Map and set data structures whose keys are stored as ranges. Contiguous and overlapping ranges that map to the same value are coalesced into a single range. Originated as a fork of Jeff Parsons' "rangemap"
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use crate::segment::{Segment, Start};
use core::{cmp::Ordering, fmt::Debug, ops::Bound};

/// Wrapper type for items the map (range should only ever be increasing)
#[derive(Clone)]
pub(crate) struct Key<T>(pub(crate) Segment<T>);

impl<T: Clone> Key<&T> {
    pub(crate) fn cloned(&self) -> Key<T> {
        Key(self.0.cloned())
    }
}

impl<T: Copy> Copy for Key<T> {}
impl<T: Debug> Debug for Key<T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{:?}", self.0)
    }
}

impl<T> core::borrow::Borrow<Start<T>> for Key<T> {
    fn borrow(&self) -> &Start<T> {
        &self.0.start
    }
}
// impl<T> core::borrow::Borrow<Start<&T>> for Key<T> {
//     fn borrow(&self) -> &Start<&T> {
//         &self.0.start.as_ref()
//     }
// }
// impl<'a, T> core::borrow::Borrow<Start<&'a T>> for Key<T> {
//     fn borrow(&self) -> &Start<&'a T> {
//         match &self.0.start.0 {
//             Bound::Included(x) => Bound::Included(x),
//             Bound::Excluded(x) => Bound::Excluded(x),
//             Bound::Unbounded => Bound::Unbounded,
//         }
//     }
// }
impl<T> core::borrow::Borrow<Bound<T>> for Key<T> {
    fn borrow(&self) -> &Bound<T> {
        &self.0.start.0
    }
}

// impl<'a, T> core::borrow::Borrow<Bound<&'a T>> for Key<&'a T> {
//     fn borrow(&self) -> &Bound<&'a T> {
//         // self.0.start.as_bound_inner_ref();

//         &self.0.start.0
//         // match &self.0.start.0 {
//         //     Bound::Included(x) => &Bound::Included(x),
//         //     Bound::Excluded(x) => &Bound::Excluded(x),
//         //     Bound::Unbounded => &Bound::Unbounded,
//         // }
//     }
// }

impl<T: PartialEq> PartialEq for Key<T> {
    fn eq(&self, other: &Key<T>) -> bool {
        self.0.start == other.0.start
    }
}
impl<T: PartialEq> PartialEq<Bound<T>> for Key<T> {
    fn eq(&self, other: &Bound<T>) -> bool {
        self.0.start.0.eq(other)
    }
}
impl<T: PartialEq> PartialEq<T> for Key<T> {
    fn eq(&self, other: &T) -> bool {
        if let Bound::Included(start) = &self.0.start.0 {
            start == other
        } else {
            false
        }
    }
}
impl<T: Eq> Eq for Key<T> {}
impl<T: Ord> Ord for Key<T> {
    fn cmp(&self, other: &Key<T>) -> Ordering {
        self.0.start.cmp(&other.0.start)
    }
}
impl<T> PartialOrd for Key<T>
where
    T: Ord,
{
    fn partial_cmp(&self, other: &Key<T>) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}