bincode 0.0.1

A binary serialization / deserialization strategy and implementation.
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

#![crate_name = "bincode"]
#![crate_type = "rlib"]
#![crate_type = "dylib"]

#![feature(struct_variant)]

extern crate serialize;

use std::io::Buffer;
use std::io::MemWriter;
use std::io::MemReader;
use std::io::IoError;
use std::io::IoResult;
use serialize::Encodable;
use serialize::Decodable;

pub use writer::EncoderWriter;
pub use reader::DecoderReader;

mod writer;
mod reader;

pub fn encode<'a, T: Encodable<EncoderWriter<'a, MemWriter>, IoError>>(t: &T) ->IoResult<Vec<u8>> {
    let mut w = MemWriter::new();
    match encode_into(t, &mut w) {
        Ok(()) => Ok(w.unwrap()),
        Err(e) => Err(e)
    }
}

pub fn decode<'a, T: Decodable<DecoderReader<'a, MemReader>, IoError>>(b: Vec<u8>) -> IoResult<T> {
    decode_from(&mut MemReader::new(b))
}

// In order to be able to pass MemReaders/MemWriters by reference, I borrowed the method used in
// the current json encoder in the stdlib

// TODO: Make code safe https://github.com/rust-lang/rust/issues/14302
pub fn encode_into<'a, W: 'a+Writer, T: Encodable<EncoderWriter<'a, W>, IoError>>(t: &T, w: &mut W) -> IoResult<()> {
    unsafe {
        t.encode(std::mem::transmute(&mut writer::EncoderWriter::new(w)))
    }
}

// TODO: Make code safe https://github.com/rust-lang/rust/issues/14302
pub fn decode_from<'a, R: 'a+Reader+Buffer, T: Decodable<DecoderReader<'a, R>, IoError>>(r: &mut R) -> IoResult<T> {
    unsafe {
        Decodable::decode(std::mem::transmute(&mut reader::DecoderReader::new(r)))
    }
}

#[cfg(test)]
mod test;