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

use binmarshal::{BinMarshal, Context, rw::{BufferBitWriter, BitView, BitWriter}};

#[derive(Context)]
struct MyContext {
  variant: u8,
  inner: u8
}

#[derive(Context)]
struct Var4Context {
  variant: u8
}

#[derive(Debug, Clone, PartialEq, BinMarshal)]
#[marshal(ctx = Var4Context, tag = "ctx.variant")]
enum Var4Inner {
  #[marshal(tag = "1")]
  Variant1,
  #[marshal(tag = "2")]
  Variant2(u8, u16),
  #[marshal(tag = "3")]
  Variant3,
}

#[derive(Debug, Clone, PartialEq, BinMarshal)]
#[marshal(ctx = MyContext, tag = "ctx.variant")]
enum MyEnum {
  #[marshal(tag = "1")]
  Variant1,
  #[marshal(tag = "2")]
  Variant2,
  #[marshal(tag = "3")]
  Variant3,
  #[marshal(tag = "4")]
  Variant4 {
    #[marshal(ctx = "{ variant: ctx.inner }")]
    inner: Var4Inner
  }
}

#[derive(Debug, Clone, PartialEq, BinMarshal)]
#[marshal(ctx = MyContext)]
struct InnerStruct {
  #[marshal(ctx = "{ variant: ctx.variant, inner: ctx.inner }")]
  en: MyEnum
}

#[derive(Debug, Clone, PartialEq, BinMarshal)]
struct MyStruct {
  which_variant: u8,
  which_inner_variant: u8,
  #[marshal(ctx = "{ variant: which_variant, inner: which_inner_variant }")]
  inner: InnerStruct
}

fn main() {
  let mut v = MyStruct {
    which_variant: 0,
    which_inner_variant: 0,
    inner: InnerStruct {
      en: MyEnum::Variant4 { inner: Var4Inner::Variant2(131, 4213) }
    }
  };

  v.update(());

  assert_eq!(v.which_variant, 4);
  assert_eq!(v.which_inner_variant, 2);

  let mut bytes = [0u8; 256];
  let mut writer = BufferBitWriter::new(&mut bytes);
  v.clone().write(&mut writer, ());

  let slice = writer.slice();
  assert_eq!(slice.len(), 5);

  let v2 = MyStruct::read(&mut BitView::new(slice), ());
  assert_eq!(v2, Some(v));
}