zoe 0.0.31

A nightly library for viral genomics
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use std::{
    ops::{Range, RangeBounds, RangeFrom, RangeInclusive, RangeTo, RangeToInclusive},
    slice::SliceIndex,
};

/// A trait alias for range types (with `usize` bounds, used to index into
/// `&[u8]`).
pub trait SliceRange: SliceIndex<[u8], Output = [u8]> + Clone + RangeBounds<usize> {}
impl<T: SliceIndex<[u8], Output = [u8]> + Clone + RangeBounds<usize>> SliceRange for T {}

/// Helper trait for adding a constant value to an index or range.
pub(crate) trait IndexAdjustable {
    /// Adds a constant value to the range or index.
    #[must_use]
    fn add(&self, n: usize) -> Self;

    /// Subtracts a constant value to the range or index.
    #[must_use]
    #[allow(dead_code)]
    fn sub(&self, n: usize) -> Self;

    /// Subtracts a constant value to the range or index, saturating at bounds.
    #[must_use]
    #[allow(dead_code)]
    fn saturating_sub(&self, n: usize) -> Self;
}

impl IndexAdjustable for usize {
    #[inline]
    fn add(&self, n: usize) -> Self {
        self + n
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        self - n
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        usize::saturating_sub(*self, n)
    }
}

impl IndexAdjustable for Range<usize> {
    #[inline]
    fn add(&self, n: usize) -> Self {
        self.start + n..self.end + n
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        self.start - n..self.end - n
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        self.start.saturating_sub(n)..self.end.saturating_sub(n)
    }
}

impl IndexAdjustable for RangeInclusive<usize> {
    #[inline]
    fn add(&self, n: usize) -> Self {
        self.start() + n..=self.end() + n
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        self.start() - n..=self.end() - n
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        self.start().saturating_sub(n)..=self.end().saturating_sub(n)
    }
}

impl IndexAdjustable for RangeFrom<usize> {
    #[inline]
    fn add(&self, n: usize) -> Self {
        self.start + n..
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        self.start - n..
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        self.start.saturating_sub(n)..
    }
}

impl IndexAdjustable for RangeTo<usize> {
    #[inline]
    fn add(&self, n: usize) -> Self {
        ..self.end + n
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        ..self.end - n
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        ..self.end.saturating_sub(n)
    }
}

impl IndexAdjustable for RangeToInclusive<usize> {
    #[inline]
    fn add(&self, n: usize) -> Self {
        ..=self.end + n
    }

    #[inline]
    fn sub(&self, n: usize) -> Self {
        ..=self.end - n
    }

    #[inline]
    fn saturating_sub(&self, n: usize) -> Self {
        ..=self.end.saturating_sub(n)
    }
}