encoding-asn1 0.1.0

asn1 crate based on pkg.go.dev/encoding/asn1
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

use encoding_asn1::unmarshal::Error;
use encoding_asn1::{
    common, parse_tag_and_length, unmarshal_with_params, Encoder, Marshal, Marshaler, RawValue,
    Unmarshal, Unmarshaler,
};

#[derive(Debug, Marshal, Unmarshal)]
struct Message {
    id: i32,
    body: Body,
}

#[derive(Debug, Marshal, Unmarshal)]
#[allow(dead_code)]
enum Body {
    #[asn1(tag = 3000)]
    Request(Request),

    #[asn1(tag = 3001)]
    Response(Response),
}

/*
impl Unmarshaler<Body> for Body {
    fn unmarshal_with_params<'a>(
        bytes: &'a [u8],
        params: &common::FieldParameters,
    ) -> Result<(Body, &'a [u8]), Error> {
        println!("bytes: {:02X?}", bytes);

        let (rv, bytes) = unmarshal_with_params::<RawValue>(bytes, params)?;
        println!("222 bytes: {:02X?}", bytes);

        println!("rv: {:?}", rv);

        match rv.tag {
            3000 => {
                println!("aaaa");
                let (r, _) = unmarshal_with_params::<Request>(
                    &rv.bytes,
                    &common::FieldParameters {
                        ..common::FieldParameters::default()
                    },
                )?;
                Ok((Body::Request(r), bytes))
            }
            _ => {
                panic!()
            }
        }
    }
}
*/

#[derive(Debug, Marshal, Unmarshal)]
struct Request {
    num: i32,
}

#[derive(Debug, Marshal, Unmarshal)]
struct Response {
    ret: i32,
}

fn main() {
    let m = Message {
        id: 10,
        body: Body::Request(Request { num: 20 }),
    };
    let bytes = encoding_asn1::marshal(&m);
    println!("{:02X?}", bytes);

    let n = encoding_asn1::unmarshal::<Message>(&bytes);
    println!("{:?}", n);
}