Struct quick_protobuf::writer::Writer

source ·

pub struct Writer<W: WriterBackend> { /* private fields */ }

Expand description

A struct to write protobuf messages

Examples

// an automatically generated module which is in a separate file in general
mod foo_bar {
    pub struct Foo<'a> { pub name: Option<Cow<'a, str>>, }
    pub struct Bar { pub id: Option<u32> }
    pub struct FooBar<'a> { pub foos: Vec<Foo<'a>>, pub bars: Vec<Bar>, }
    impl<'a> MessageWrite for FooBar<'a> {
        // implements
        // fn get_size(&self) -> usize { ... }
        // fn write_message<W: WriterBackend>(&self, r: &mut Writer<W>) -> Result<()> { ... }
    }
}

// FooBar is a message generated from a proto file
// in parcicular it contains a `write_message` function
use foo_bar::{FooBar, Foo, Bar};
use std::borrow::Cow;
use quick_protobuf::Writer;

fn main() {
    // let mut r = File::create("...").expect("Cannot create file");
    // for the sake of example, we'll use a simpler struct which impl `Write`
    let mut r = Vec::new();
    let mut writer = Writer::new(&mut r);

    // manually generates a FooBar for the example
    let foobar = FooBar {
        foos: vec![Foo { name: Some(Cow::Borrowed("test!")) }, Foo { name: None }],
        bars: vec![Bar { id: Some(43) }, Bar { id: None }],
    };

    // now using the generated module
    writer.write_message(&foobar).expect("Cannot write FooBar");
}

Implementations

source

impl<W: WriterBackend> Writer<W>

source

pub fn new(w: W) -> Writer<W>

Creates a new ProtobufWriter

source

pub fn write_u8(&mut self, byte: u8) -> Result<()>

Writes a byte which is NOT internally coded as a varint

source

pub fn write_varint(&mut self, v: u64) -> Result<()>

Writes a varint (compacted u64)

source

pub fn write_tag(&mut self, tag: u32) -> Result<()>

Writes a tag, which represents both the field number and the wire type

source

pub fn write_int32(&mut self, v: i32) -> Result<()>

Writes a int32 which is internally coded as a varint

source

pub fn write_int64(&mut self, v: i64) -> Result<()>

Writes a int64 which is internally coded as a varint

source

pub fn write_uint32(&mut self, v: u32) -> Result<()>

Writes a uint32 which is internally coded as a varint

source

pub fn write_uint64(&mut self, v: u64) -> Result<()>

Writes a uint64 which is internally coded as a varint

source

pub fn write_sint32(&mut self, v: i32) -> Result<()>

Writes a sint32 which is internally coded as a varint

source

pub fn write_sint64(&mut self, v: i64) -> Result<()>

Writes a sint64 which is internally coded as a varint

source

pub fn write_fixed64(&mut self, v: u64) -> Result<()>

Writes a fixed64 which is little endian coded u64

source

pub fn write_fixed32(&mut self, v: u32) -> Result<()>

Writes a fixed32 which is little endian coded u32

source

pub fn write_sfixed64(&mut self, v: i64) -> Result<()>

Writes a sfixed64 which is little endian coded i64

source

pub fn write_sfixed32(&mut self, v: i32) -> Result<()>

Writes a sfixed32 which is little endian coded i32

source

pub fn write_float(&mut self, v: f32) -> Result<()>

Writes a float

source

pub fn write_double(&mut self, v: f64) -> Result<()>

Writes a double

source

pub fn write_bool(&mut self, v: bool) -> Result<()>

Writes a bool 1 = true, 0 = false

source

pub fn write_enum(&mut self, v: i32) -> Result<()>

Writes an enum converting it to a i32 first

source

pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<()>

Writes bytes: length first then the chunk of data

source

pub fn write_string(&mut self, s: &str) -> Result<()>

Writes string: length first then the chunk of data

source

pub fn write_packed<M, F, S>(&mut self, v: &[M], write: F, size: &S) -> Result<()>where
F: FnMut(&mut Self, &M) -> Result<()>,
S: Fn(&M) -> usize,

Writes packed repeated field: length first then the chunk of data

source

pub fn write_packed_fixed<M>(&mut self, v: &[M]) -> Result<()>

Writes packed repeated field when we know the size of items

item_size is internally used to compute the total length As the length is fixed (and the same as rust internal representation, we can directly dump all data at once

source