Module ebml

Type doc

type doc = {data: @~[u8], start: uint, end: uint,}

Type ebml_deserializer

type ebml_deserializer = {mut parent: ebml::doc, mut pos: uint,}

Type writer

type writer = {writer: io::writer, mut size_positions: ~[uint],}

Implementation deserializer of serialization::deserializer for ebml_deserializer

fn _check_label(lbl: str)

fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc

fn push_doc<T: copy>(d: ebml::doc, f: fn() -> T) -> T

fn _next_uint(exp_tag: ebml_serializer_tag) -> uint

fn read_nil()

fn read_u64() -> u64

fn read_u32() -> u32

fn read_u16() -> u16

fn read_u8() -> u8

fn read_uint() -> uint

fn read_i64() -> i64

fn read_i32() -> i32

fn read_i16() -> i16

fn read_i8() -> i8

fn read_int() -> int

fn read_bool() -> bool

fn read_f64() -> f64

fn read_f32() -> f32

fn read_float() -> float

fn read_str() -> str

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

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

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

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

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

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

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

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

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

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

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

Implementation serializer of serialization::serializer for ebml::writer

fn emit_nil()

fn _emit_tagged_uint(t: ebml_serializer_tag, v: uint)

fn _emit_label(label: str)

fn emit_uint(v: uint)

fn emit_u64(v: u64)

fn emit_u32(v: u32)

fn emit_u16(v: u16)

fn emit_u8(v: u8)

fn emit_int(v: int)

fn emit_i64(v: i64)

fn emit_i32(v: i32)

fn emit_i16(v: i16)

fn emit_i8(v: i8)

fn emit_bool(v: bool)

fn emit_f64(_v: f64)

fn emit_f32(_v: f32)

fn emit_float(_v: float)

fn emit_str(v: str)

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

fn emit_enum_variant(_v_name: str, v_id: uint, _cnt: uint, f: fn())

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

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

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

fn emit_box(f: fn())

fn emit_uniq(f: fn())

fn emit_rec(f: fn())

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

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

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

Implementation writer for writer

fn start_tag(tag_id: uint)

fn end_tag()

fn wr_tag(tag_id: uint, blk: fn())

fn wr_tagged_bytes(tag_id: uint, b: & [u8])

fn wr_tagged_u64(tag_id: uint, v: u64)

fn wr_tagged_u32(tag_id: uint, v: u32)

fn wr_tagged_u16(tag_id: uint, v: u16)

fn wr_tagged_u8(tag_id: uint, v: u8)

fn wr_tagged_i64(tag_id: uint, v: i64)

fn wr_tagged_i32(tag_id: uint, v: i32)

fn wr_tagged_i16(tag_id: uint, v: i16)

fn wr_tagged_i8(tag_id: uint, v: i8)

fn wr_tagged_str(tag_id: uint, v: str)

fn wr_bytes(b: & [u8])

fn wr_str(s: str)

Function doc

fn doc(data: @~[u8]) -> doc

Function doc_as_i16

fn doc_as_i16(d: doc) -> i16

Function doc_as_i32

fn doc_as_i32(d: doc) -> i32

Function doc_as_i64

fn doc_as_i64(d: doc) -> i64

Function doc_as_i8

fn doc_as_i8(d: doc) -> i8

Function doc_as_str

fn doc_as_str(d: doc) -> str

Function doc_as_u16

fn doc_as_u16(d: doc) -> u16

Function doc_as_u32

fn doc_as_u32(d: doc) -> u32

Function doc_as_u64

fn doc_as_u64(d: doc) -> u64

Function doc_as_u8

fn doc_as_u8(d: doc) -> u8

Function doc_at

fn doc_at(data: @~[u8], start: uint) -> tagged_doc

Function doc_data

fn doc_data(d: doc) -> ~[u8]

Function docs

fn docs(d: doc, it: fn(uint, doc))

Function ebml_deserializer

fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer

Function get_doc

fn get_doc(d: doc, tg: uint) -> doc

Function maybe_get_doc

fn maybe_get_doc(d: doc, tg: uint) -> option<doc>

Function tagged_docs

fn tagged_docs(d: doc, tg: uint, it: fn(doc))

Function with_doc_data

fn with_doc_data<T>(d: doc, f: fn(x: & [u8]) -> T) -> T

Function writer

fn writer(w: io::writer) -> writer