xdrgen 0.1.5

XDR codec generator from specification and runtime library
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


// GENERATED CODE
//
// Generated from c.x.
//
// DO NOT EDIT


#[derive(Debug, Eq, PartialEq, Clone)]
pub enum Bar { A(i32), B(i32), C, default(Vec<u8>), }

#[derive(Debug, Eq, PartialEq, Copy, Clone)]
pub enum Foo { A = 0isize, B = 1isize, C = 2isize, }

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for Bar {
    #[inline]
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(match self {
               Bar::A(val) =>
               try!(Foo :: A . pack ( out )) + try!(val . pack ( out )),
               Bar::B(val) =>
               try!(Foo :: B . pack ( out )) + try!(val . pack ( out )),
               Bar::C => try!(Foo :: C . pack ( out )),
               Bar::default(..) =>
               return Err(xdr_codec::Error::invalidcase()),
           })
    }
}

impl <Out: xdr_codec::Write> xdr_codec::Pack<Out> for Foo {
    #[inline]
    fn pack(&self, out: &mut Out) -> xdr_codec::Result<usize> {
        Ok(try!(( * self as i32 ) . pack ( out )))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for Bar {
    #[inline]
    fn unpack(input: &mut In) -> xdr_codec::Result<(Bar, usize)> {
        let mut sz = 0;
        Ok((match {
                      let (v, dsz) =
                          try!(xdr_codec:: Unpack:: unpack ( input ));
                      sz += dsz;
                      v
                  } {
                Foo::A =>
                Bar::A({
                           let (v, csz) =
                               try!(xdr_codec:: Unpack:: unpack ( input ));
                           sz += csz;
                           v
                       }),
                Foo::B =>
                Bar::B({
                           let (v, csz) =
                               try!(xdr_codec:: Unpack:: unpack ( input ));
                           sz += csz;
                           v
                       }),
                Foo::C => Bar::C,
                _ =>
                Bar::default({
                                 let (v, csz) =
                                     try!(xdr_codec:: Unpack:: unpack ( input
                                          ));
                                 sz += csz;
                                 v
                             }),
            }, sz))
    }
}

impl <In: xdr_codec::Read> xdr_codec::Unpack<In> for Foo {
    #[inline]
    fn unpack(input: &mut In) -> xdr_codec::Result<(Foo, usize)> {
        let mut sz = 0;
        Ok(({
                let (e, esz) = try!(xdr_codec:: Unpack:: unpack ( input ));
                sz += esz;
                match e {
                    0i64 => Foo::A,
                    1i64 => Foo::B,
                    2i64 => Foo::C,
                    _ => return xdr_codec::Error::invalidenum(),
                }
            }, sz))
    }
}