Support code for serialization.

Interface deserializer

Method read_nil

fn read_nil()

Method read_uint

fn read_uint() -> uint

Method read_u64

fn read_u64() -> u64

Method read_u32

fn read_u32() -> u32

Method read_u16

fn read_u16() -> u16

Method read_u8

fn read_u8() -> u8

Method read_int

fn read_int() -> int

Method read_i64

fn read_i64() -> i64

Method read_i32

fn read_i32() -> i32

Method read_i16

fn read_i16() -> i16

Method read_i8

fn read_i8() -> i8

Method read_bool

fn read_bool() -> bool

Method read_str

fn read_str() -> str

Method read_f64

fn read_f64() -> f64

Method read_f32

fn read_f32() -> f32

Method read_float

fn read_float() -> float

Method read_enum

fn read_enum<T: copy>(name: str, f: fn() -> T) -> T

Method read_enum_variant

fn read_enum_variant<T: copy>(f: fn(uint) -> T) -> T

Method read_enum_variant_arg

fn read_enum_variant_arg<T: copy>(idx: uint, f: fn() -> T) -> T

Method read_vec

fn read_vec<T: copy>(f: fn(uint) -> T) -> T

Method read_vec_elt

fn read_vec_elt<T: copy>(idx: uint, f: fn() -> T) -> T

Method read_box

fn read_box<T: copy>(f: fn() -> T) -> T

Method read_uniq

fn read_uniq<T: copy>(f: fn() -> T) -> T

Method read_rec

fn read_rec<T: copy>(f: fn() -> T) -> T

Method read_rec_field

fn read_rec_field<T: copy>(f_name: str, f_idx: uint, f: fn() -> T) -> T

Method read_tup

fn read_tup<T: copy>(sz: uint, f: fn() -> T) -> T

Method read_tup_elt

fn read_tup_elt<T: copy>(idx: uint, f: fn() -> T) -> T

Interface serializer

Method emit_nil

fn emit_nil()

Method emit_uint

fn emit_uint(v: uint)

Method emit_u64

fn emit_u64(v: u64)

Method emit_u32

fn emit_u32(v: u32)

Method emit_u16

fn emit_u16(v: u16)

Method emit_u8

fn emit_u8(v: u8)

Method emit_int

fn emit_int(v: int)

Method emit_i64

fn emit_i64(v: i64)

Method emit_i32

fn emit_i32(v: i32)

Method emit_i16

fn emit_i16(v: i16)

Method emit_i8

fn emit_i8(v: i8)

Method emit_bool

fn emit_bool(v: bool)

Method emit_float

fn emit_float(v: float)

Method emit_f64

fn emit_f64(v: f64)

Method emit_f32

fn emit_f32(v: f32)

Method emit_str

fn emit_str(v: str)

Method emit_enum

fn emit_enum(name: str, f: fn())

Method emit_enum_variant

fn emit_enum_variant(v_name: str, v_id: uint, sz: uint, f: fn())

Method emit_enum_variant_arg

fn emit_enum_variant_arg(idx: uint, f: fn())

Method emit_vec

fn emit_vec(len: uint, f: fn())

Method emit_vec_elt

fn emit_vec_elt(idx: uint, f: fn())

Method emit_box

fn emit_box(f: fn())

Method emit_uniq

fn emit_uniq(f: fn())

Method emit_rec

fn emit_rec(f: fn())

Method emit_rec_field

fn emit_rec_field(f_name: str, f_idx: uint, f: fn())

Method emit_tup

fn emit_tup(sz: uint, f: fn())

Method emit_tup_elt

fn emit_tup_elt(idx: uint, f: fn())

Implementation deserializer_helpers for D

Method read_to_vec

fn read_to_vec<T: copy>(f: fn() -> T) -> ~[T]

Implementation serializer_helpers for S

Method emit_from_vec

fn emit_from_vec<T>(v: ~[T], f: fn(T))

Function deserialize_bool

fn deserialize_bool<D: deserializer>(d: D) -> bool

Function deserialize_f32

fn deserialize_f32<D: deserializer>(d: D) -> f32

Function deserialize_f64

fn deserialize_f64<D: deserializer>(d: D) -> f64

Function deserialize_float

fn deserialize_float<D: deserializer>(d: D) -> float

Function deserialize_i16

fn deserialize_i16<D: deserializer>(d: D) -> i16

Function deserialize_i32

fn deserialize_i32<D: deserializer>(d: D) -> i32

Function deserialize_i64

fn deserialize_i64<D: deserializer>(d: D) -> i64

Function deserialize_i8

fn deserialize_i8<D: deserializer>(d: D) -> i8

Function deserialize_int

fn deserialize_int<D: deserializer>(d: D) -> int

Function deserialize_option

fn deserialize_option<D: deserializer, T: copy>(d: D, st: fn() -> T) ->
   option<T>

Function deserialize_str

fn deserialize_str<D: deserializer>(d: D) -> str

Function deserialize_u16

fn deserialize_u16<D: deserializer>(d: D) -> u16

Function deserialize_u32

fn deserialize_u32<D: deserializer>(d: D) -> u32

Function deserialize_u64

fn deserialize_u64<D: deserializer>(d: D) -> u64

Function deserialize_u8

fn deserialize_u8<D: deserializer>(d: D) -> u8

Function deserialize_uint

fn deserialize_uint<D: deserializer>(d: D) -> uint

Function emit_from_vec

fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T))

Function read_to_vec

fn read_to_vec<D: deserializer, T: copy>(d: D, f: fn() -> T) -> ~[T]

Function serialize_bool

fn serialize_bool<S: serializer>(s: S, v: bool)

Function serialize_f32

fn serialize_f32<S: serializer>(s: S, v: f32)

Function serialize_f64

fn serialize_f64<S: serializer>(s: S, v: f64)

Function serialize_float

fn serialize_float<S: serializer>(s: S, v: float)

Function serialize_i16

fn serialize_i16<S: serializer>(s: S, v: i16)

Function serialize_i32

fn serialize_i32<S: serializer>(s: S, v: i32)

Function serialize_i64

fn serialize_i64<S: serializer>(s: S, v: i64)

Function serialize_i8

fn serialize_i8<S: serializer>(s: S, v: i8)

Function serialize_int

fn serialize_int<S: serializer>(s: S, v: int)

Function serialize_option

fn serialize_option<S: serializer, T>(s: S, v: option<T>, st: fn(T))

Function serialize_str

fn serialize_str<S: serializer>(s: S, v: str)

Function serialize_u16

fn serialize_u16<S: serializer>(s: S, v: u16)

Function serialize_u32

fn serialize_u32<S: serializer>(s: S, v: u32)

Function serialize_u64

fn serialize_u64<S: serializer>(s: S, v: u64)

Function serialize_u8

fn serialize_u8<S: serializer>(s: S, v: u8)

Function serialize_uint

fn serialize_uint<S: serializer>(s: S, v: uint)