vdf-reader 0.3.3

Rust parser for valve vdf files.
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

use crate::reader::quoted_string;
use crate::Token;
use logos::{Lexer, Span};
use std::borrow::Cow;

#[derive(Clone, Debug)]
pub struct SpannedToken {
    pub token: Token,
    pub span: Span,
}

impl SpannedToken {
    pub fn string<'source>(&self, source: &'source str) -> Cow<'source, str> {
        let full = &source[self.span.clone()];
        match self.token {
            Token::QuotedItem | Token::QuotedStatement => quoted_string(full),
            _ => full.into(),
        }
    }
}

pub struct Tokenizer<'source> {
    lexer: Lexer<'source, Token>,
    /// The number of tokens tokenized so far
    pub count: usize,
}

impl<'source> Tokenizer<'source> {
    pub fn from_str(input: &'source str) -> Self {
        Tokenizer {
            lexer: Lexer::new(input),
            count: 0,
        }
    }

    pub fn source(&self) -> &'source str {
        self.lexer.source()
    }
}

impl Iterator for Tokenizer<'_> {
    type Item = Result<SpannedToken, Span>;

    fn next(&mut self) -> Option<Self::Item> {
        let token = match self.lexer.next() {
            Some(Ok(token)) => token,
            Some(Err(_)) => {
                return Some(Err(self.lexer.span()));
            }
            None => {
                return None;
            }
        };
        self.count += 1;
        Some(Ok(SpannedToken {
            token,
            span: self.lexer.span(),
        }))
    }
}