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

pub fn write_message<M: MessageWrite>(&mut self, m: &M) -> Result<()>

Writes a message which implements MessageWrite

source

pub fn write_with_tag<F>(&mut self, tag: u32, write: F) -> Result<()>
where F: FnMut(&mut Self) -> Result<()>,

Writes another item prefixed with tag

source

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

Writes tag then repeated field

If array is empty, then do nothing (do not even write the tag)

source

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

Writes tag then repeated field

If array is empty, then do nothing (do not even write the tag)

source

pub fn write_packed_fixed_size_with_tag<M>( &mut self, tag: u32, v: &[M], item_size: usize ) -> Result<()>

Writes tag then repeated field with fixed length item size

If array is empty, then do nothing (do not even write the tag)

source

pub fn write_map<FK, FV>( &mut self, size: usize, tag_key: u32, write_key: FK, tag_val: u32, write_val: FV ) -> Result<()>
where FK: FnMut(&mut Self) -> Result<()>, FV: FnMut(&mut Self) -> Result<()>,

Write entire map

Auto Trait Implementations§

§

impl<W> RefUnwindSafe for Writer<W>
where W: RefUnwindSafe,

§

impl<W> Send for Writer<W>
where W: Send,

§

impl<W> Sync for Writer<W>
where W: Sync,

§

impl<W> Unpin for Writer<W>
where W: Unpin,

§

impl<W> UnwindSafe for Writer<W>
where W: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.