hash-roll 0.3.0

Rolling hashes & Content Defined Chunking (cdc)
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::ops::Bound::{self, *};

pub trait RangeExt<T> {
    fn exceeds_max(&self, other: &T) -> bool
    where
        T: PartialOrd<T>;

    fn under_min(&self, item: &T) -> bool
    where
        T: PartialOrd<T>;

    fn contains(&self, item: &T) -> bool
    where
        T: PartialOrd<T>;

    fn into_tuple(self) -> (std::ops::Bound<T>, std::ops::Bound<T>)
    where
        T: Copy + std::marker::Sized;
}

impl<T, R: std::ops::RangeBounds<T>> RangeExt<T> for R {
    fn exceeds_max(&self, item: &T) -> bool
    where
        T: PartialOrd<T>,
    {
        match self.end_bound() {
            Included(ref i) => {
                if item > i {
                    return true;
                }
            }
            Excluded(ref i) => {
                if item >= i {
                    return true;
                }
            }
            Unbounded => {}
        }

        false
    }

    fn under_min(&self, item: &T) -> bool
    where
        T: PartialOrd<T>,
    {
        match self.start_bound() {
            Included(ref i) => {
                if item < i {
                    return true;
                }
            }
            Excluded(ref i) => {
                if item <= i {
                    return true;
                }
            }
            Unbounded => {}
        }

        false
    }

    fn contains(&self, item: &T) -> bool
    where
        T: PartialOrd<T>,
    {
        /* not excluded by lower */
        if self.under_min(item) {
            return false;
        }

        if self.exceeds_max(item) {
            return false;
        }

        true
    }

    fn into_tuple(self) -> (std::ops::Bound<T>, std::ops::Bound<T>)
    where
        T: Copy + std::marker::Sized,
    {
        (
            bound_cloned(self.start_bound()),
            bound_cloned(self.end_bound()),
        )
    }
}

/// Map a `Bound<&T>` to a `Bound<T>` by cloning the contents of the bound.
///
/// # Examples
///
/// ```
/// use std::ops::Bound::*;
/// use std::ops::RangeBounds;
/// use hash_roll::range::bound_cloned;
///
/// assert_eq!((1..12).start_bound(), Included(&1));
/// assert_eq!(bound_cloned((1..12).start_bound()), Included(1));
/// ```
pub fn bound_cloned<T: Clone>(src: std::ops::Bound<&T>) -> std::ops::Bound<T> {
    match src {
        Bound::Unbounded => Bound::Unbounded,
        Bound::Included(x) => Bound::Included(x.clone()),
        Bound::Excluded(x) => Bound::Excluded(x.clone()),
    }
}