field_block 0.1.0

A definition language for buffer parsing
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
79
80
81
82
83
84
85
86
87
88

# Field Block

A definition language for buffer parsing.

## Usage

A buffer field definition:

```rust
fn get_block() -> Block<Name> {
    let mut block = Block::new();
    block.add_field(
        Name::FixedVarInt, //
        Def::VarInt(U64::Fixed(0xdeadbeef)),
    );
    block.add_field(
        Name::VarInt, //
        Def::VarInt(U64::Var),
    );
    block.add_field(
        Name::BytesFixedLen, //
        Def::Bytes(Len::Fixed(1)),
    );
    block.add_field(
        Name::BytesVarLen, //
        Def::Bytes(Len::Var),
    );
    block.add_field(
        Name::FixedBytes, //
        Def::FixedBytes(vec![0xba, 0xad, 0xf0, 0x0d]),
    );
    block
}

#[derive(Debug, PartialEq, Eq, Hash, Clone)]
enum Name {
    FixedVarInt,
    VarInt,
    BytesFixedLen,
    BytesVarLen,
    FixedBytes,
}

impl FieldName for Name {}
```

Encoding a buffer:

```rust
let block = get_block();

let mut values = HashMap::new();
values.insert(
    Name::VarInt, //
    Val::VarInt(0x1234)
);
values.insert(
    Name::BytesFixedLen, //
    Val::Bytes(Cow::from(vec![1]))
);
values.insert(
    Name::BytesVarLen, //
    Val::Bytes(Cow::from(vec![1, 2, 3])),
);

let mut vec = vec![0; 1024];

let end = block.to_bytes(&values, &mut vec).unwrap();
```

Decoding a buffer:

```rust
let block = get_block();

let vec = vec![0 | 0xc0, 0, 0, 0, 0xde, 0xad, 0xbe, 0xef, 0x12 | 0x40, 0x34, 1, 3, 1, 2, 3, 0xba, 0xad, 0xf0, 0x0d];

let mut values = HashMap::new();

let end = block.to_values(&vec, &mut values).unwrap();

let ValInfo { value, pos } = values.get(&Name::VarInt).unwrap();
let value = value.varint().unwrap();

println!("Field VarInt has a value {} at pos {}", value, pos);
```

See unit tests for examples.