carta-schema 1.0.1

Parse a schema file. Apply the schema to binary data for exploration and visualisation
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use failure_derive::Fail;

#[derive(Fail, Debug, PartialEq)]
#[fail(display = "Line {}: {}", _0, _1)]
pub struct CartaError {
    pub line_no: usize,
    pub code: CartaErrorCode
}

#[derive(Fail, Debug, PartialEq)]
pub enum CartaErrorCode {
    #[fail(display = "Unrecognized type: {}", _0)]
    UnknownType(String),

    #[fail(display = "Duplicate definition for type: {}", _0)]
    DuplicateType(String),

    #[fail(display = "Recursive types: {:?}", _0)]
    RecursiveTypes(Vec<String>),

    #[fail(display = "Unrecognized symbol: {}", _0)]
    UnknownSymbol(char),

    #[fail(display = "Unexpected symbol.  Expected {}, found: {}", _0, _1)]
    UnexpectedSymbol(&'static str, char),

    #[fail(display = "Unclosed block comment at end of file")]
    UnclosedBlockComment(),

    #[fail(display = "Parse error!  Expected '{}', found '{}'", _0, _1)]
    ParseError(&'static str, String),

    #[fail(display = "Missing struct \"root\"")]
    MissingRootElement(),

    #[fail(display = "Bad array length: {}", _0)]
    BadArrayLen(String),

    #[fail(display = "Array length must be builtin integer type: {}", _0)]
    BadArrayLenType(String),

    #[fail(display = "Cannot start number with leading zero")]
    LeadingZero(),

    #[fail(display = "Integer too large: Must be 9 digits or less")]
    IntegerTooLarge(),

    #[fail(display = "Incomplete input")]
    IncompleteInput(),
}

// Make errors slightly easier to construct
impl CartaError {
    pub fn new_unknown_type(line_no: usize, kind: String) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::UnknownType(kind),
        }
    }

    pub fn new_duplicate_type(line_no: usize, kind: String) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::DuplicateType(kind),
        }
    }

    pub fn new_recursive_types(line_no: usize, kinds: Vec<String>) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::RecursiveTypes(kinds),
        }
    }

    pub fn new_unknown_symbol(line_no: usize, sym: char) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::UnknownSymbol(sym),
        }
    }

    pub fn new_unexpected_symbol(line_no: usize, expected: &'static str, got: char) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::UnexpectedSymbol(expected, got),
        }
    }

    pub fn new_unclosed_block_comment(line_no: usize) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::UnclosedBlockComment(),
        }
    }

    pub fn new_parse_error(line_no: usize, expected: &'static str, got: String) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::ParseError(expected, got),
        }
    }

    pub fn new_missing_root_element(line_no: usize) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::MissingRootElement(),
        }
    }

    pub fn new_bad_array_len(line_no: usize, len_desc: &str) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::BadArrayLen(len_desc.to_string()),
        }
    }

    pub fn new_bad_array_len_type(line_no: usize, kind: &str) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::BadArrayLenType(kind.to_string()),
        }
    }

    pub fn new_leading_zero(line_no: usize) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::LeadingZero(),
        }
    }

    pub fn new_integer_too_large(line_no: usize) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::IntegerTooLarge(),
        }
    }

    pub fn new_incomplete_input(line_no: usize) -> CartaError {
        CartaError {
            line_no,
            code: CartaErrorCode::IncompleteInput(),
        }
    }
}