chordparser 4.0.4

A parser library to generate Jazz/Pop/Rock chords from string inputs
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

#[derive(Debug, Clone, PartialEq, Eq)]
#[repr(u8)]
pub enum TokenType<'a> {
    Note(&'a str),
    Sharp,
    Flat,
    Aug,
    Dim,
    Dim7,
    HalfDim,
    Extension(u8),
    Add,
    Omit,
    Alt,
    Sus,
    Minor,
    Hyphen,
    Maj,
    Maj7,
    Slash,
    LParent,
    RParent,
    Comma,
    Bass,
    Illegal,
    Eof,
}
impl<'a> TokenType<'a> {
    pub fn from_string(i: &'_ str) -> Option<TokenType<'_>> {
        match i {
            "BASS" | "Bass" | "bass" => Some(TokenType::Bass),
            "MAJ" | "Maj" | "maj" | "MAJOR" | "Major" | "major" | "MA" | "Ma" | "ma" | "M" => {
                Some(TokenType::Maj)
            }
            "MIN" | "Min" | "min" | "MINOR" | "Minor" | "minor" | "MI" | "Mi" | "mi" | "m" => {
                Some(TokenType::Minor)
            }
            "b" => Some(TokenType::Flat),
            "SUS" | "Sus" | "sus" => Some(TokenType::Sus),
            "DIM" | "Dim" | "dim" | "diminished" => Some(TokenType::Dim),
            "ALT" | "Alt" | "alt" => Some(TokenType::Alt),
            "AUG" | "Aug" | "aug" => Some(TokenType::Aug),
            "ADD" | "Add" | "add" => Some(TokenType::Add),
            "O" | "o" | "°" => Some(TokenType::Dim),
            "OMIT" | "Omit" | "omit" | "NO" | "No" | "no" => Some(TokenType::Omit),
            "A" | "B" | "C" | "D" | "E" | "F" | "G" => Some(TokenType::Note(i)),
            _ => None,
        }
    }
}

impl<'a> Display for TokenType<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TokenType::Note(note) => f.write_str(note)?,
            TokenType::Sharp => f.write_str("#")?,
            TokenType::Flat => f.write_str("b")?,
            TokenType::Aug => f.write_str("+")?,
            TokenType::Dim => f.write_str("°")?,
            TokenType::Dim7 => f.write_str("°7")?,
            TokenType::HalfDim => f.write_str("ø")?,
            TokenType::Extension(ext) => f.write_str(&ext.to_string())?,
            TokenType::Add => f.write_str("Add")?,
            TokenType::Sus => f.write_str("Sus")?,
            TokenType::Minor => f.write_str("-")?,
            TokenType::Hyphen => f.write_str("-")?,
            TokenType::Maj => f.write_str("△")?,
            TokenType::Maj7 => f.write_str("△")?,
            TokenType::Slash => f.write_str("/")?,
            TokenType::Alt => f.write_str("Alt")?,
            TokenType::Illegal => f.write_str("ILLEGAL")?,
            TokenType::Eof => f.write_str("EOF")?,
            TokenType::LParent => f.write_str("(")?,
            TokenType::RParent => f.write_str(")")?,
            TokenType::Omit => f.write_str("Omit")?,
            TokenType::Comma => f.write_str(",")?,
            TokenType::Bass => f.write_str("Bass")?,
        }
        Ok(())
    }
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Token<'a> {
    pub token_type: TokenType<'a>,
    pub pos: usize,
    pub len: usize,
    pub synthetic: bool,
}

impl<'a> Token<'a> {
    pub fn new(token_type: TokenType, pos: usize, len: usize) -> Token {
        Token {
            token_type,
            pos,
            len,
            synthetic: false,
        }
    }
}

use std::fmt::Display;
impl<'a> Display for Token<'a> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("{}", self.token_type))?;
        Ok(())
    }
}