ranges 0.4.0

This crate provides a generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible.
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

use core::{cmp::Ordering, ops::Bound};

use arbitrary::{Arbitrary, Result, Unstructured};

use crate::{Domain, GenericRange};

#[allow(clippy::missing_docs_in_private_items)]
enum RangeType {
    Unbounded,
    SingleBound,
    DoubleBound,
}

#[allow(clippy::missing_docs_in_private_items)]
enum SingleBoundType {
    LeftInclude,
    LeftExclude,
    RightInclude,
    RightExclude,
}

#[allow(clippy::missing_docs_in_private_items)]
enum DoubleBoundType {
    InIn,
    InEx,
    ExIn,
    ExEx,
}

impl<'data, T: Arbitrary<'data> + Domain> Arbitrary<'data> for GenericRange<T> {
    #[allow(clippy::min_ident_chars)]
    fn arbitrary(u: &mut Unstructured<'data>) -> Result<Self> {
        let ty = u.choose(&[RangeType::Unbounded, RangeType::SingleBound, RangeType::DoubleBound])?;

        Ok(match *ty {
            RangeType::Unbounded => Self::full(),
            RangeType::SingleBound => {
                let bound = u.choose(&[
                    SingleBoundType::LeftInclude,
                    SingleBoundType::LeftExclude,
                    SingleBoundType::RightInclude,
                    SingleBoundType::RightExclude,
                ])?;

                let val = u.arbitrary::<T>()?;

                match *bound {
                    SingleBoundType::LeftInclude => Self::new_with_bounds(Bound::Included(val), Bound::Unbounded),
                    SingleBoundType::LeftExclude => Self::new_with_bounds(Bound::Excluded(val), Bound::Unbounded),
                    SingleBoundType::RightInclude => Self::new_with_bounds(Bound::Unbounded, Bound::Included(val)),
                    SingleBoundType::RightExclude => Self::new_with_bounds(Bound::Unbounded, Bound::Excluded(val)),
                }
            }
            RangeType::DoubleBound => {
                // no unbound
                let bound = u.choose(&[
                    DoubleBoundType::InIn,
                    DoubleBoundType::InEx,
                    DoubleBoundType::ExIn,
                    DoubleBoundType::ExEx,
                ])?;

                let val1 = u.arbitrary::<T>()?;
                let val2 = u.arbitrary::<T>()?;

                let (big, small) = match val1.cmp(&val2) {
                    Ordering::Less => (val2, val1),
                    Ordering::Equal | Ordering::Greater => (val1, val2),
                };

                match *bound {
                    DoubleBoundType::InIn => Self::new_with_bounds(Bound::Included(small), Bound::Included(big)),
                    DoubleBoundType::InEx => Self::new_with_bounds(Bound::Included(small), Bound::Excluded(big)),
                    DoubleBoundType::ExIn => Self::new_with_bounds(Bound::Excluded(small), Bound::Included(big)),
                    DoubleBoundType::ExEx => Self::new_with_bounds(Bound::Excluded(small), Bound::Excluded(big)),
                }
            }
        })
    }
}