scnr 0.8.0

Scanner/Lexer with regex patterns and multiple modes
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

use serde::{Deserialize, Serialize};

/// A span in an input string.
#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq, Serialize, Deserialize)]
pub struct Span {
    /// The start offset of the span, inclusive.
    pub start: usize,
    /// The end offset of the span, exclusive.
    pub end: usize,
}
impl Span {
    /// Create a new span.
    #[inline]
    pub fn new(start: usize, end: usize) -> Self {
        Span { start, end }
    }

    /// Check if the span is empty.
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.start >= self.end
    }

    /// Get the length of the span.
    #[inline]
    pub fn len(&self) -> usize {
        self.end.saturating_sub(self.start)
    }

    /// Get the span as range.
    #[inline]
    pub fn range(self) -> std::ops::Range<usize> {
        self.start..self.end
    }
}

impl<T> From<std::ops::Range<T>> for Span
where
    T: Into<usize>,
{
    fn from(range: std::ops::Range<T>) -> Self {
        Span {
            start: range.start.into(),
            end: range.end.into(),
        }
    }
}

impl<T> From<std::ops::RangeInclusive<T>> for Span
where
    T: Into<usize> + Copy,
{
    fn from(range: std::ops::RangeInclusive<T>) -> Self {
        Span {
            start: (*range.start()).into(),
            end: (*range.end()).into() + 1,
        }
    }
}

impl<T> From<Span> for std::ops::Range<T>
where
    T: From<usize>,
{
    fn from(span: Span) -> Self {
        span.start.into()..span.end.into()
    }
}

impl<T> From<Span> for std::ops::RangeInclusive<T>
where
    T: From<usize> + Copy,
{
    fn from(span: Span) -> Self {
        span.start.into()..=span.end.into()
    }
}

impl std::fmt::Display for Span {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}..{}", self.start, self.end)
    }
}