berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

update readme

This commit is contained in:
Ty Overby 2015-02-07 19:03:17 -08:00
parent 2f3860ddab
commit 793588edae
2 changed files with 22 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -6,7 +6,7 @@ A compact encoder / decoder pair that uses an binary zero-fluff encoding scheme.
The size of the encoded object will be the same or smaller than the size that The size of the encoded object will be the same or smaller than the size that
the object takes up in memory in a running Rust program. the object takes up in memory in a running Rust program.
In addition to exposing two simple functions that encode to Vec<u8> and decode In addition to exposing two simple funcitons that encode to Vec<u8> and decode
from Vec<u8>, binary-encode exposes a Reader/Writer API that makes it work from Vec<u8>, binary-encode exposes a Reader/Writer API that makes it work
perfectly with other stream-based apis such as rust files, network streams, perfectly with other stream-based apis such as rust files, network streams,
and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression and the [flate2-rs](https://github.com/alexcrichton/flate2-rs) compression
@ -17,8 +17,6 @@ library.
## Example ## Example
```rust ```rust
#![feature(old_orphan_check)]
extern crate bincode; extern crate bincode;
extern crate "rustc-serialize" as rustc_serialize; extern crate "rustc-serialize" as rustc_serialize;
@ -41,9 +39,11 @@ fn main() {
}; };
let encoded: Vec<u8> = bincode::encode(&world, SizeLimit::Infinite).unwrap(); let encoded: Vec<u8> = bincode::encode(&world, SizeLimit::Infinite).unwrap();
// 8 bytes for the length of the vector, 4 bytes per float. // 8 bytes for the length of the vector, 4 bytes per float.
assert_eq!(encoded.len(), 8 + 4 * 4); assert_eq!(encoded.len(), 8 + 4 * 4);
let decoded: World = bincode::decode(encoded, SizeLimit::Infinite).unwrap();
let decoded: World = bincode::decode(&encoded[]).unwrap();
assert!(world == decoded); assert!(world == decoded);
} }
@ -61,7 +61,7 @@ then the contents.
However, there are some implementation details to be aware of: However, there are some implementation details to be aware of:
* `int`/`uint` are encoded as `i64`/`u64`, for portability. * `isize`/`usize` are encoded as `i64`/`u64`, for portability.
* enums variants are encoded as a `u32` instead that as a `uint`. * enums variants are encoded as a `u32` instead that as a `uint`.
`u32` is enough for all practical uses. `u32` is enough for all practical uses.
* `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of * `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of

17
readme.dev.md
View File

@ -17,3 +17,20 @@ library.
## Example ## Example
^code(./examples/basic.rs) ^code(./examples/basic.rs)
## Details
The encoding (and thus decoding) proceeds unsurprisingly -- primitive
types are encoded according to the underlying `Writer`, tuples and
structs are encoded by encoding their fields one-by-one, and enums are
encoded by first writing out the tag representing the variant and
then the contents.
However, there are some implementation details to be aware of:
* `isize`/`usize` are encoded as `i64`/`u64`, for portability.
* enums variants are encoded as a `u32` instead that as a `uint`.
`u32` is enough for all practical uses.
* `str` is encoded as `(u64, &[u8])`, where the `u64` is the number of
bytes contained in the encoded string.