thrift-parser 0.0.5

A simple thrift parser.
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

use nom::branch::alt;
use nom::combinator::{map, opt};
use nom::multi::many0;
use nom::sequence::delimited;
use nom::IResult;

use crate::basic::Separator;
use crate::definition::{
    Const, ConstRef, Enum, EnumRef, Exception, ExceptionRef, Service, ServiceRef, Struct,
    StructRef, Typedef, TypedefRef, Union, UnionRef,
};
use crate::header::{CppInclude, CppIncludeRef, Include, IncludeRef, Namespace, NamespaceRef};
use crate::Parser;

#[derive(PartialEq, Debug, Clone, Default)]
pub struct DocumentRef<'a> {
    pub includes: Vec<IncludeRef<'a>>,
    pub cpp_includes: Vec<CppIncludeRef<'a>>,
    pub namespaces: Vec<NamespaceRef<'a>>,
    pub typedefs: Vec<TypedefRef<'a>>,
    pub consts: Vec<ConstRef<'a>>,
    pub enums: Vec<EnumRef<'a>>,
    pub structs: Vec<StructRef<'a>>,
    pub unions: Vec<UnionRef<'a>>,
    pub exceptions: Vec<ExceptionRef<'a>>,
    pub services: Vec<ServiceRef<'a>>,
}

impl<'a> Parser<'a> for DocumentRef<'a> {
    fn parse(input: &'a str) -> IResult<&'a str, Self> {
        let mut target = Self::default();
        let includes = &mut target.includes;
        let cpp_includes = &mut target.cpp_includes;
        let namespaces = &mut target.namespaces;
        let typedefs = &mut target.typedefs;
        let consts = &mut target.consts;
        let enums = &mut target.enums;
        let structs = &mut target.structs;
        let unions = &mut target.unions;
        let exceptions = &mut target.exceptions;
        let services = &mut target.services;

        let (remains, _) = many0(delimited(
            opt(Separator::parse),
            alt((
                map(IncludeRef::parse, |i| includes.push(i)),
                map(CppIncludeRef::parse, |i| cpp_includes.push(i)),
                map(NamespaceRef::parse, |i| namespaces.push(i)),
                map(TypedefRef::parse, |i| typedefs.push(i)),
                map(ConstRef::parse, |i| consts.push(i)),
                map(EnumRef::parse, |i| enums.push(i)),
                map(StructRef::parse, |i| structs.push(i)),
                map(UnionRef::parse, |i| unions.push(i)),
                map(ExceptionRef::parse, |i| exceptions.push(i)),
                map(ServiceRef::parse, |i| services.push(i)),
            )),
            opt(Separator::parse),
        ))(input)?;
        Ok((remains, target))
    }
}

#[derive(PartialEq, Debug, Clone, Default)]
pub struct Document {
    pub includes: Vec<Include>,
    pub cpp_includes: Vec<CppInclude>,
    pub namespaces: Vec<Namespace>,
    pub typedefs: Vec<Typedef>,
    pub consts: Vec<Const>,
    pub enums: Vec<Enum>,
    pub structs: Vec<Struct>,
    pub unions: Vec<Union>,
    pub exceptions: Vec<Exception>,
    pub services: Vec<Service>,
}

impl<'a> From<DocumentRef<'a>> for Document {
    fn from(r: DocumentRef<'a>) -> Self {
        Self {
            includes: r.includes.into_iter().map(Into::into).collect(),
            cpp_includes: r.cpp_includes.into_iter().map(Into::into).collect(),
            namespaces: r.namespaces.into_iter().map(Into::into).collect(),
            typedefs: r.typedefs.into_iter().map(Into::into).collect(),
            consts: r.consts.into_iter().map(Into::into).collect(),
            enums: r.enums.into_iter().map(Into::into).collect(),
            structs: r.structs.into_iter().map(Into::into).collect(),
            unions: r.unions.into_iter().map(Into::into).collect(),
            exceptions: r.exceptions.into_iter().map(Into::into).collect(),
            services: r.services.into_iter().map(Into::into).collect(),
        }
    }
}

impl<'a> Parser<'a> for Document {
    fn parse(input: &'a str) -> IResult<&'a str, Self> {
        DocumentRef::parse(input).map(|(remains, parsed)| (remains, parsed.into()))
    }
}

#[cfg(test)]
mod tests {
    use crate::basic::LiteralRef;

    use super::*;

    #[test]
    fn test_document() {
        let expected = DocumentRef {
            includes: vec![IncludeRef::from(LiteralRef::from("another.thrift"))],
            ..Default::default()
        };
        assert_eq!(
            DocumentRef::parse("include 'another.thrift'").unwrap().1,
            expected
        );
    }
}