type-protocol 0.1.0

A crate provding a simple syntax representing types.
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

use std::str::FromStr;

use crate::{Typing, RustIdent, AsciiIdent, nz, UniversalType, ExtensionType, Error};

type AsciiTy = Typing<AsciiIdent>;
type RustTy = Typing<RustIdent>;

fn test_parsing() {
    let s = "";
    assert!(RustTy::from_str(s) == Err(Error::Empty));

    let s = "foöbár";
    assert!(RustTy::from_str(s) == Ok(RustTy::Named(s.to_owned())));
    assert!(AsciiTy::from_str(s) == Err(Error::ValidationFailed));

    let s = "int";
    assert!(RustTy::from_str(s) == Ok(RustTy::Common(UniversalType::ISize)));

    let s = "uint32";
    assert!(RustTy::from_str(s) == Ok(RustTy::Common(UniversalType::UInt(nz!(4)))));

    let s = "+decimal";
    assert!(RustTy::from_str(s) == Ok(RustTy::Extension(ExtensionType::Decimal)));

    let s = "[]vec2";
    assert!(RustTy::from_str(s) == Ok(RustTy::Vec(RustTy::Named("vec2".to_owned()).boxed())));

    let s = "[42]?string";
    assert!(RustTy::from_str(s) == Ok(RustTy::Array(
        42,
        RustTy::Option(
            RustTy::Common(UniversalType::String).boxed()
        ).boxed()
    )));

    let s = "[[[+datetime]]]";
    assert!(RustTy::from_str(s) == Ok(RustTy::Set(
        RustTy::Set(
            RustTy::Set(
                RustTy::Extension(ExtensionType::DateTime).boxed()
            ).boxed()
        ).boxed()
    )));

    let s = "[42e]?(uint8,@smartstring)";
    assert!(RustTy::from_str(s) ==
        Ok(RustTy::Map(
            RustTy::Named("42e".to_owned()).boxed(),
            RustTy::Option(
                RustTy::Tuple(vec![
                    RustTy::Common(UniversalType::UInt(nz!(1))),
                    RustTy::Foreign(RustTy::Named("smartstring".to_owned()).boxed())
                ]).boxed())
            .boxed())
        )
    );

}