Struct protobuf::CodedOutputStream

pub struct CodedOutputStream<'a> { /* private fields */ }

Buffered write with handy utilities

Implementations

impl<'a> CodedOutputStream<'a>

pub fn new(writer: &'a mut dyn Write) -> CodedOutputStream<'a>

Construct from given Write.

CodedOutputStream is buffered even if Write is not

pub fn bytes(bytes: &'a mut [u8]) -> CodedOutputStream<'a>

CodedOutputStream which writes directly to bytes.

Attempt to write more than bytes capacity results in error.

pub fn vec(vec: &'a mut Vec<u8>) -> CodedOutputStream<'a>

CodedOutputStream which writes directly to Vec<u8>.

pub fn total_bytes_written(&self) -> u64

Total number of bytes written to this stream.

This number may be larger than the actual number of bytes written to the underlying stream, if the buffer was not flushed.

The number may be inaccurate if there was an error during the write.

pub fn check_eof(&self)

Check if EOF is reached.

Panics

If underlying write has no EOF

pub fn flush(&mut self) -> Result<()>

Flush to buffer to the underlying buffer. Note that CodedOutputStream does flush in the destructor, however, if flush in destructor fails, then destructor panics and program terminates. So it’s advisable to explicitly call flush before destructor.

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

Write a byte

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

Write bytes

pub fn write_tag(
    &mut self,
    field_number: u32,
    wire_type: WireType
) -> Result<()>

Write a tag

pub fn write_raw_varint32(&mut self, value: u32) -> Result<()>

Write varint

pub fn write_raw_varint64(&mut self, value: u64) -> Result<()>

Write varint

pub fn write_raw_little_endian32(&mut self, value: u32) -> Result<()>

Write 32-bit integer little endian

pub fn write_raw_little_endian64(&mut self, value: u64) -> Result<()>

Write 64-bit integer little endian

pub fn write_float_no_tag(&mut self, value: f32) -> Result<()>

Write float

pub fn write_double_no_tag(&mut self, value: f64) -> Result<()>

Write double

pub fn write_float(&mut self, field_number: u32, value: f32) -> Result<()>

Write float field

pub fn write_double(&mut self, field_number: u32, value: f64) -> Result<()>

Write double field

pub fn write_uint64_no_tag(&mut self, value: u64) -> Result<()>

Write varint

pub fn write_uint32_no_tag(&mut self, value: u32) -> Result<()>

Write varint

pub fn write_int64_no_tag(&mut self, value: i64) -> Result<()>

Write varint

pub fn write_int32_no_tag(&mut self, value: i32) -> Result<()>

Write varint

pub fn write_sint64_no_tag(&mut self, value: i64) -> Result<()>

Write zigzag varint

pub fn write_sint32_no_tag(&mut self, value: i32) -> Result<()>

Write zigzag varint

pub fn write_fixed64_no_tag(&mut self, value: u64) -> Result<()>

Write fixed64

pub fn write_fixed32_no_tag(&mut self, value: u32) -> Result<()>

Write fixed32

pub fn write_sfixed64_no_tag(&mut self, value: i64) -> Result<()>

Write sfixed64

pub fn write_sfixed32_no_tag(&mut self, value: i32) -> Result<()>

Write sfixed32

pub fn write_bool_no_tag(&mut self, value: bool) -> Result<()>

Write bool

pub fn write_enum_no_tag(&mut self, value: i32) -> Result<()>

Write enum

pub fn write_enum_obj_no_tag<E>(&mut self, value: E) -> Result<()> where
    E: Enum, 

Write enum

pub fn write_enum_or_unknown_no_tag<E>(
    &mut self,
    value: EnumOrUnknown<E>
) -> Result<()> where
    E: Enum, 

Write enum

pub fn write_unknown_no_tag(
    &mut self,
    unknown: UnknownValueRef<'_>
) -> Result<()>

Write unknown value

pub fn write_uint64(&mut self, field_number: u32, value: u64) -> Result<()>

Write uint64 field

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

Write uint32 field

pub fn write_int64(&mut self, field_number: u32, value: i64) -> Result<()>

Write int64 field

pub fn write_int32(&mut self, field_number: u32, value: i32) -> Result<()>

Write int32 field

pub fn write_sint64(&mut self, field_number: u32, value: i64) -> Result<()>

Write sint64 field

pub fn write_sint32(&mut self, field_number: u32, value: i32) -> Result<()>

Write sint32 field

pub fn write_fixed64(&mut self, field_number: u32, value: u64) -> Result<()>

Write fixed64 field

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

Write fixed32 field

pub fn write_sfixed64(&mut self, field_number: u32, value: i64) -> Result<()>

Write sfixed64 field

pub fn write_sfixed32(&mut self, field_number: u32, value: i32) -> Result<()>

Write sfixed32 field

pub fn write_bool(&mut self, field_number: u32, value: bool) -> Result<()>

Write bool field

pub fn write_enum(&mut self, field_number: u32, value: i32) -> Result<()>

Write enum field

pub fn write_enum_obj<E>(&mut self, field_number: u32, value: E) -> Result<()> where
    E: Enum, 

Write enum field

pub fn write_enum_or_unknown<E>(
    &mut self,
    field_number: u32,
    value: EnumOrUnknown<E>
) -> Result<()> where
    E: Enum, 

Write enum field

pub fn write_unknown(
    &mut self,
    field_number: u32,
    value: UnknownValueRef<'_>
) -> Result<()>

Write unknown field

pub fn write_unknown_fields(&mut self, fields: &UnknownFields) -> Result<()>

Write unknown fields

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

Write bytes

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

Write string

pub fn write_message_no_tag<M: Message>(&mut self, msg: &M) -> Result<()>

Write message

pub fn write_message_no_tag_dyn(&mut self, msg: &dyn MessageDyn) -> Result<()>

Write dynamic message

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

Write bytes field

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

Write string field

pub fn write_repeated_packed_float_no_tag(
    &mut self,
    values: &[f32]
) -> Result<()>

Write repeated packed float values.

pub fn write_repeated_packed_float(
    &mut self,
    field_number: u32,
    values: &[f32]
) -> Result<()>

Write field header and data for repeated packed float.

pub fn write_repeated_packed_double_no_tag(
    &mut self,
    values: &[f64]
) -> Result<()>

Write repeated packed double values.

pub fn write_repeated_packed_double(
    &mut self,
    field_number: u32,
    values: &[f64]
) -> Result<()>

Write field header and data for repeated packed double.

pub fn write_repeated_packed_fixed32_no_tag(
    &mut self,
    values: &[u32]
) -> Result<()>

Write repeated packed fixed32 values.

pub fn write_repeated_packed_fixed32(
    &mut self,
    field_number: u32,
    values: &[u32]
) -> Result<()>

Write field header and data for repeated packed fixed32.

pub fn write_repeated_packed_fixed64_no_tag(
    &mut self,
    values: &[u64]
) -> Result<()>

Write repeated packed fixed64 values.

pub fn write_repeated_packed_fixed64(
    &mut self,
    field_number: u32,
    values: &[u64]
) -> Result<()>

Write field header and data for repeated packed fixed64.

pub fn write_repeated_packed_sfixed32_no_tag(
    &mut self,
    values: &[i32]
) -> Result<()>

Write repeated packed sfixed32 values.

pub fn write_repeated_packed_sfixed32(
    &mut self,
    field_number: u32,
    values: &[i32]
) -> Result<()>

Write field header and data for repeated packed sfixed32.

pub fn write_repeated_packed_sfixed64_no_tag(
    &mut self,
    values: &[i64]
) -> Result<()>

Write repeated packed sfixed64 values.

pub fn write_repeated_packed_sfixed64(
    &mut self,
    field_number: u32,
    values: &[i64]
) -> Result<()>

Write field header and data for repeated packed sfixed64.

pub fn write_repeated_packed_int32_no_tag(
    &mut self,
    values: &[i32]
) -> Result<()>

Write repeated packed int32 values.

pub fn write_repeated_packed_int32(
    &mut self,
    field_number: u32,
    values: &[i32]
) -> Result<()>

Write field header and data for repeated packed int32.

pub fn write_repeated_packed_int64_no_tag(
    &mut self,
    values: &[i64]
) -> Result<()>

Write repeated packed int64 values.

pub fn write_repeated_packed_int64(
    &mut self,
    field_number: u32,
    values: &[i64]
) -> Result<()>

Write field header and data for repeated packed int64.

pub fn write_repeated_packed_uint32_no_tag(
    &mut self,
    values: &[u32]
) -> Result<()>

Write repeated packed uint32 values.

pub fn write_repeated_packed_uint32(
    &mut self,
    field_number: u32,
    values: &[u32]
) -> Result<()>

Write field header and data for repeated packed uint32.

pub fn write_repeated_packed_uint64_no_tag(
    &mut self,
    values: &[u64]
) -> Result<()>

Write repeated packed uint64 values.

pub fn write_repeated_packed_uint64(
    &mut self,
    field_number: u32,
    values: &[u64]
) -> Result<()>

Write field header and data for repeated packed uint64.

pub fn write_repeated_packed_sint32_no_tag(
    &mut self,
    values: &[i32]
) -> Result<()>

Write repeated packed sint32 values.

pub fn write_repeated_packed_sint32(
    &mut self,
    field_number: u32,
    values: &[i32]
) -> Result<()>

Write field header and data for repeated packed sint32.

pub fn write_repeated_packed_sint64_no_tag(
    &mut self,
    values: &[i64]
) -> Result<()>

Write repeated packed sint64 values.

pub fn write_repeated_packed_sint64(
    &mut self,
    field_number: u32,
    values: &[i64]
) -> Result<()>

Write field header and data for repeated packed sint64.

pub fn write_repeated_packed_bool_no_tag(
    &mut self,
    values: &[bool]
) -> Result<()>

Write repeated packed bool values.

pub fn write_repeated_packed_bool(
    &mut self,
    field_number: u32,
    values: &[bool]
) -> Result<()>

Write field header and data for repeated packed bool.

pub fn write_repeated_packed_enum_or_unknown_no_tag<E: Enum>(
    &mut self,
    values: &[EnumOrUnknown<E>]
) -> Result<()>

Write repeated packed enum values.

pub fn write_repeated_packed_enum_or_unknown<E: Enum>(
    &mut self,
    field_number: u32,
    values: &[EnumOrUnknown<E>]
) -> Result<()>

Write field header and data for repeated packed enum.

pub fn write_message<M: MessageFull>(
    &mut self,
    field_number: u32,
    msg: &M
) -> Result<()>

Write message field

pub fn write_message_dyn(
    &mut self,
    field_number: u32,
    msg: &dyn MessageDyn
) -> Result<()>

Write dynamic message field

Trait Implementations

impl<'a> Debug for CodedOutputStream<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Drop for CodedOutputStream<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Write for CodedOutputStream<'a>

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Write.