fexbluffers 0.1.2

Allocation optimized FlexBuffer implementation (Rust).
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

# fexbluffers

Allocation optimized `FlexBuffer` implementation (Rust).

Slower for struct serialization/deserialization -- faster for some kinds of vector building.

```rs
// use flexbuffers;
use fexbluffers;

use stats_alloc::{INSTRUMENTED_SYSTEM, Region, StatsAlloc};
use std::alloc::System;

#[global_allocator]
static GLOBAL: &StatsAlloc<System> = &INSTRUMENTED_SYSTEM;

fn main() {
    let reg = Region::new(&GLOBAL);

    // let mut builder = flexbuffers::Builder::default();
    let mut builder = fexbluffers::Builder::default();
    let mut test_vec = builder.start_vector();

    test_vec.push("hello!");
    test_vec.push(123);
    test_vec.push(());
    test_vec.push("something else!");
    test_vec.push(10_000);

    test_vec.end_vector();

    builder.view();

    println!("stats: {:#?}", reg.change());
}

// This crate (OMM):

// stats: Stats {
//     allocations: 1,
//     deallocations: 0,
//     reallocations: 3,
//     bytes_allocated: 64,
//     bytes_deallocated: 0,
//     bytes_reallocated: 56,
// }
// time:   [195.81 ns 197.43 ns 199.05 ns]

// Official FlexBuffers crate (OMM):

// Stats {
//     allocations: 2,
//     deallocations: 0,
//     reallocations: 4,
//     bytes_allocated: 192,
//     bytes_deallocated: 0,
//     bytes_reallocated: 120,
// }
// time:   [266.06 ns 267.28 ns 268.46 ns]
```


*forked from google's implementation <https://github.com/google/flatbuffers/tree/c7b9dc83f58fe72162b076ba9c88d682f5d0eda6/rust/flexbuffers#readme>*

## Flexbuffers

[Flexbuffers](https://google.github.io/flatbuffers/flexbuffers.html) is a
schema-less binary format developed at Google. `FlexBuffers` can be accessed
without parsing, copying, or allocation. This is a huge win for efficiency,
memory friendly-ness, and allows for unique use cases such as mmap-ing large
amounts of free-form data.

`FlexBuffers`' design and implementation allows for a very compact encoding,
with automatic sizing of containers to their smallest possible representation
(8/16/32/64 bits). Many values and offsets can be encoded in just 8 bits.

`FlexBuffers` supports [Serde](https://serde.rs/) for automatically serializing
Rust data structures into its binary format.

## See Examples for Usage:
* [Example](https://github.com/google/flatbuffers/blob/master/samples/sample_flexbuffers.rs)
* [Serde Example](https://github.com/google/flatbuffers/blob/master/samples/sample_flexbuffers_serde.rs)
* [Documentation](https://docs.rs/flexbuffers)

Flexbuffers is the schema-less cousin of
[Flatbuffers](https://google.github.io/flatbuffers/).