tinyrs 0.2.0

Parse Tiny format mappings in Rust.
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

use crate::identifier;
use nom::{
    branch::alt,
    character::complete::char,
    combinator::{map, value},
    error::{context, ParseError},
    multi::many1_count,
    sequence::{pair, preceded, terminated},
    IResult,
};
use serde::{Deserialize, Serialize};

pub type DimensionSize = usize;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub enum JavaType {
    Void,
    Char,
    Byte,
    Short,
    Int,
    Long,
    Boolean,
    Float,
    Double,
    Class(String),
    Array(DimensionSize, Box<JavaType>),
}

fn dataless<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, JavaType, E> {
    context(
        "dataless",
        alt((
            value(JavaType::Void, char('V')),
            value(JavaType::Char, char('C')),
            value(JavaType::Byte, char('B')),
            value(JavaType::Short, char('S')),
            value(JavaType::Int, char('I')),
            value(JavaType::Long, char('J')),
            value(JavaType::Boolean, char('Z')),
            value(JavaType::Float, char('F')),
            value(JavaType::Double, char('D')),
        )),
    )(input)
}

fn class<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, JavaType, E> {
    context(
        "class",
        map(
            preceded(char('L'), terminated(identifier, char(';'))),
            |name: &str| JavaType::Class(name.into()),
        ),
    )(input)
}

fn array<'a, E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, JavaType, E> {
    context(
        "array",
        map(
            pair(many1_count(char('[')), parse_java_type),
            |(dim, java)| JavaType::Array(dim, Box::new(java)),
        ),
    )(input)
}

pub fn parse_java_type<'a, E: ParseError<&'a str>>(
    input: &'a str,
) -> IResult<&'a str, JavaType, E> {
    alt((dataless, class, array))(input)
}