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

use crate::types::SymbolId;

/// A symbol token encountered in a text or binary Ion stream.
/// [RawSymbolToken]s do not store import source information for the token encountered. Similarly,
/// a [RawSymbolToken] cannot store both a symbol ID _and_ text, which means that it is not suitable
/// for representing a resolved symbol.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RawSymbolToken {
    SymbolId(SymbolId),
    Text(String),
}

impl RawSymbolToken {
    pub fn matches(&self, sid: SymbolId, text: &str) -> bool {
        match self {
            RawSymbolToken::SymbolId(s) if *s == sid => true,
            RawSymbolToken::Text(t) if t == text => true,
            _ => false,
        }
    }

    pub fn local_sid(&self) -> Option<SymbolId> {
        match self {
            RawSymbolToken::SymbolId(s) => Some(*s),
            RawSymbolToken::Text(_t) => None,
        }
    }

    pub fn text(&self) -> Option<&str> {
        match self {
            RawSymbolToken::SymbolId(_s) => None,
            RawSymbolToken::Text(t) => Some(t.as_str()),
        }
    }
}

/// Constructs a [`RawSymbolToken`] with unknown text and a local ID.
/// A common case for binary parsing (though technically relevant in text).
#[inline]
pub fn local_sid_token(local_sid: SymbolId) -> RawSymbolToken {
    RawSymbolToken::SymbolId(local_sid)
}

/// Constructs an [`RawSymbolToken`] with just text.
/// A common case for text and synthesizing tokens.
#[inline]
pub fn text_token<T: Into<String>>(text: T) -> RawSymbolToken {
    RawSymbolToken::Text(text.into())
}

impl From<SymbolId> for RawSymbolToken {
    fn from(symbol_id: SymbolId) -> Self {
        RawSymbolToken::SymbolId(symbol_id)
    }
}

impl From<String> for RawSymbolToken {
    fn from(text: String) -> Self {
        RawSymbolToken::Text(text)
    }
}

impl From<&str> for RawSymbolToken {
    fn from(text: &str) -> Self {
        RawSymbolToken::Text(text.to_string())
    }
}

impl<T> From<&T> for RawSymbolToken
where
    T: Clone + Into<RawSymbolToken>,
{
    fn from(value: &T) -> Self {
        value.clone().into()
    }
}