elyze 1.5.5

Elyze is an extensible general purpose framework parser allowing to parser any type of data without allocation.
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

//! A scanner for a sequence of elements.

use crate::errors::ParseResult;
use crate::visitor::Visitor;
use std::io::Cursor;
use std::ops::Deref;

/// Wrapper around a `Cursor`.
#[derive(Debug, PartialEq, Clone)]
pub struct Scanner<'a, T> {
    /// The internal cursor.
    cursor: Cursor<&'a [T]>,
}

impl<'a, T> Scanner<'a, T> {
    pub fn new(data: &'a [T]) -> Scanner<'a, T> {
        Scanner {
            cursor: Cursor::new(data),
        }
    }
}

impl<'a, T> Scanner<'a, T> {
    /// Move the internal cursor forward by `n` positions.
    ///
    /// # Arguments
    ///
    /// * `n` - The number of positions to move the cursor forward.
    ///
    /// # Panics
    ///
    /// Panics if the internal cursor is moved past the end of the data.
    pub fn bump_by(&mut self, n: usize) {
        self.cursor.set_position(self.cursor.position() + n as u64);
    }

    /// Move the internal cursor to the specified position.
    ///
    /// # Arguments
    ///
    /// * `n` - The position to move the cursor to.
    ///
    /// # Panics
    ///
    /// Panics if the internal cursor is moved past the end of the data.
    pub fn jump_to(&mut self, n: usize) {
        self.cursor.set_position(n as u64);
    }

    /// Move the internal cursor backward by `n` positions.
    ///
    /// # Arguments
    ///
    /// * `n` - The number of positions to move the cursor backward.
    ///
    /// # Panics
    ///
    /// Panics if the internal cursor is moved to a position before the start of the data.
    pub fn rewind(&mut self, n: usize) {
        self.cursor.set_position(self.cursor.position() - n as u64);
    }

    /// Return the current position of the internal cursor.
    ///
    /// # Returns
    ///
    /// The current position of the internal cursor.
    pub fn current_position(&self) -> usize {
        self.cursor.position() as usize
    }

    /// Return a slice of the data that remains to be scanned.
    ///
    /// # Returns
    ///
    /// A slice of the data that remains to be scanned.
    pub fn remaining(&self) -> &'a [T] {
        &self.cursor.get_ref()[self.current_position()..]
    }

    /// Return the original data given to the scanner.
    ///
    /// # Returns
    ///
    /// The original data given to the scanner.
    pub fn data(&self) -> &'a [T] {
        self.cursor.get_ref()
    }

    /// Return true if there are no more elements to scan, false otherwise.
    ///
    /// # Returns
    ///
    /// true if there are no more elements to scan, false otherwise.
    pub fn is_empty(&self) -> bool {
        self.remaining().is_empty()
    }
}

impl<'a, T> Deref for Scanner<'a, T> {
    type Target = [T];
    fn deref(&self) -> &Self::Target {
        self.remaining()
    }
}

impl<'a, T> Scanner<'a, T> {
    /// Run a visitor on the scanner.
    ///
    /// # Type Parameters
    ///
    /// * `V` - The type of the visitor to run.
    ///
    /// # Arguments
    ///
    /// * `&mut self` - The scanner to run the visitor on.
    ///
    /// # Returns
    ///
    /// The result of running the visitor on the scanner.
    pub fn visit<V: Visitor<'a, T>>(&mut self) -> ParseResult<V> {
        V::accept(self)
    }
}