binmarshal 1.1.7

Pack and unpack structs and enums into and out of binary data streams.
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

use binmarshal::*;

#[derive(Clone)]
struct Context1 {
  a: u8
}

#[derive(Clone)]
struct Context2 {
  flag: bool,
  a: u8
}

#[derive(Debug, Clone, PartialEq, Marshal, Demarshal, MarshalUpdate)]
struct RootStruct {
  a: u8,

  #[marshal(
    ctx = "construct",
    ctx_type = Context1,
    ctx_member(field="a", member="a")
  )]
  b: InnerStruct
}

impl From<Context1> for Context2 {
  fn from(ctx: Context1) -> Self {
    Context2 {
      flag: ctx.a & 0b10000 != 0,
      a: ctx.a & 0b01111,
    }
  }
}

impl From<Context2> for Context1 {
  fn from(ctx: Context2) -> Self {
    Context1 {
      a: ((ctx.flag as u8) << 4) | (ctx.a & 0b01111)
    }
  }
}

#[derive(Debug, Clone, PartialEq, Marshal, Demarshal, MarshalUpdate)]
#[marshal(ctx = Context1)]
struct InnerStruct {
  #[marshal(ctx = "coerce", ctx_type = Context2)]
  inner: Selector
}

#[derive(Debug, Clone, PartialEq, Marshal, Demarshal, MarshalUpdate)]
#[marshal(ctx = Context2, tag = "ctx.a")]
enum Selector {
  #[marshal(tag = "0x12")]
  Something(#[marshal(ctx = "forward")] Maybe<u8, u16>),
  #[marshal(tag = "0x13")]
  Idk,
}


#[derive(Debug, Clone, PartialEq, Marshal, Demarshal, MarshalUpdate)]
#[marshal(ctx = Context2, tag = "ctx.flag", tag_type = "bool")]
enum Maybe<T: Marshal<()> + DemarshalOwned, F: Marshal<()> + DemarshalOwned> {
  #[marshal(tag = "true")]
  True(T),
  #[marshal(tag = "false")]
  False(F)
}

fn main() {
  let mut v = RootStruct {
    a: 0x00,
    b: InnerStruct { inner: Selector::Something(Maybe::True(16)) }
  };

  v.update(&mut ());

  assert_eq!(v.a, 0x12 | (0b1 << 4));
}