Const debug

bool

Enum EbmlSerializerTag

Variants

Struct Deserializer

struct Deserializer {
    priv mut parent: Doc,
    priv mut pos: uint,
}

Struct Doc

struct Doc {
    data: @~[u8],
    start: uint,
    end: uint,
}

Struct EbmlState

struct EbmlState {
    ebml_tag: EbmlTag,
    tag_pos: uint,
    data_pos: uint,
}

Struct EbmlTag

struct EbmlTag {
    id: uint,
    size: uint,
}

Struct Serializer

struct Serializer {
    writer: io::Writer,
    priv mut size_positions: ~[uint],
}

Struct TaggedDoc

struct TaggedDoc {
    tag: uint,
    doc: Doc,
}

Implementation of ops::Index<uint, Doc> for Doc

Method index

fn index(tag: uint) -> Doc

Implementation for Serializer

Method start_tag

fn start_tag(tag_id: uint)

Method end_tag

fn end_tag()

Method wr_tag

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

Method wr_tagged_bytes

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

Method wr_tagged_u64

fn wr_tagged_u64(tag_id: uint, v: u64)

Method wr_tagged_u32

fn wr_tagged_u32(tag_id: uint, v: u32)

Method wr_tagged_u16

fn wr_tagged_u16(tag_id: uint, v: u16)

Method wr_tagged_u8

fn wr_tagged_u8(tag_id: uint, v: u8)

Method wr_tagged_i64

fn wr_tagged_i64(tag_id: uint, v: i64)

Method wr_tagged_i32

fn wr_tagged_i32(tag_id: uint, v: i32)

Method wr_tagged_i16

fn wr_tagged_i16(tag_id: uint, v: i16)

Method wr_tagged_i8

fn wr_tagged_i8(tag_id: uint, v: i8)

Method wr_tagged_str

fn wr_tagged_str(tag_id: uint, v: & str)

Method wr_bytes

fn wr_bytes(b: & [u8])

Method wr_str

fn wr_str(s: & str)

Implementation for Serializer

Method _emit_tagged_uint

fn _emit_tagged_uint(t: EbmlSerializerTag, v: uint)

Method _emit_label

fn _emit_label(label: & str)

Implementation for Serializer

Method emit_opaque

fn emit_opaque(f: fn&())

Implementation of serialization::Serializer for 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_f64

fn emit_f64(_v: f64)

Method emit_f32

fn emit_f32(_v: f32)

Method emit_float

fn emit_float(_v: float)

Method emit_char

fn emit_char(_v: char)

Method emit_borrowed_str

fn emit_borrowed_str(v: & str)

Method emit_owned_str

fn emit_owned_str(v: & str)

Method emit_managed_str

fn emit_managed_str(v: & str)

Method emit_borrowed

fn emit_borrowed(f: fn&())

Method emit_owned

fn emit_owned(f: fn&())

Method emit_managed

fn emit_managed(f: fn&())

Method emit_enum

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

Method emit_enum_variant

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

Method emit_enum_variant_arg

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

Method emit_borrowed_vec

fn emit_borrowed_vec(len: uint, f: fn&())

Method emit_owned_vec

fn emit_owned_vec(len: uint, f: fn&())

Method emit_managed_vec

fn emit_managed_vec(len: uint, f: fn&())

Method emit_vec_elt

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

Method emit_rec

fn emit_rec(f: fn&())

Method emit_struct

fn emit_struct(_name: & str, f: fn&())

Method emit_field

fn emit_field(name: & str, _idx: uint, f: fn&())

Method emit_tup

fn emit_tup(_len: uint, f: fn&())

Method emit_tup_elt

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

Implementation for Deserializer

Method _check_label

fn _check_label(lbl: & str)

Method next_doc

fn next_doc(exp_tag: EbmlSerializerTag) -> Doc

Method push_doc

fn push_doc<T>(d: Doc, f: fn&() -> T) -> T

Method _next_uint

fn _next_uint(exp_tag: EbmlSerializerTag) -> uint

Implementation for Deserializer

Method read_opaque

fn read_opaque<R>(op: fn&(Doc) -> R) -> R

Implementation of serialization::Deserializer for Deserializer

Method read_nil

fn read_nil()

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_uint

fn read_uint() -> uint

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_int

fn read_int() -> int

Method read_bool

fn read_bool() -> bool

Method read_f64

fn read_f64() -> f64

Method read_f32

fn read_f32() -> f32

Method read_float

fn read_float() -> float

Method read_char

fn read_char() -> char

Method read_owned_str

fn read_owned_str() -> ~str

Method read_managed_str

fn read_managed_str() -> @str

Method read_owned

fn read_owned<T>(f: fn&() -> T) -> T

Method read_managed

fn read_managed<T>(f: fn&() -> T) -> T

Method read_enum

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

Method read_enum_variant

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

Method read_enum_variant_arg

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

Method read_owned_vec

fn read_owned_vec<T>(f: fn&(uint) -> T) -> T

Method read_managed_vec

fn read_managed_vec<T>(f: fn&(uint) -> T) -> T

Method read_vec_elt

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

Method read_rec

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

Method read_struct

fn read_struct<T>(name: & str, f: fn&() -> T) -> T

Method read_field

fn read_field<T>(name: & str, idx: uint, f: fn&() -> T) -> T

Method read_tup

fn read_tup<T>(len: uint, f: fn&() -> T) -> T

Method read_tup_elt

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

Function Deserializer

fn Deserializer(d: Doc) -> Deserializer

Function Doc

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

Function Serializer

fn Serializer(w: io::Writer) -> Serializer

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) -> TaggedDoc

Function doc_data

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

Function docs

fn docs(d: Doc, it: fn&(uint, Doc) -> bool)

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) -> bool)

Function vuint_at

fn vuint_at(data: & [u8], start: uint) -> {val: uint, next: uint,}

Function with_doc_data

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

Function write_sized_vuint

fn write_sized_vuint(w: io::Writer, n: uint, size: uint)

Function write_vuint

fn write_vuint(w: io::Writer, n: uint)