Struct protobuf_native::io::CodedInputStream

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

Type which reads and decodes binary data which is composed of varint- encoded integers and fixed-width pieces.

Wraps a ZeroCopyInputStream. Most users will not need to deal with CodedInputStream.

Most methods of CodedInputStream that return a Result return an error if an underlying I/O error occurs or if the data is malformed. Once such a failure occurs, the CodedInputStream is broken and is no longer useful.

Implementations

impl<'a> CodedInputStream<'a>

pub fn new( input: Pin<&'a mut dyn ZeroCopyInputStream>, ) -> Pin<Box<CodedInputStream<'a>>>

Creates a CodedInputStream that reads from the given ZeroCopyInputStream.

pub fn is_flat(&self) -> bool

Reports whether this coded input stream reads from a flat array instead of a ZeroCopyInputStream.

pub fn read_varint32(self: Pin<&mut Self>) -> Result<u32, OperationFailedError>

Reads an unsigned integer with varint encoding, truncating to 32 bits.

Reading a 32-bit value is equivalent to reading a 64-bit one and casting it to u32, but may be more efficient.

pub fn read_varint64(self: Pin<&mut Self>) -> Result<u64, OperationFailedError>

Reads an unsigned 64-bit integer with varint encoding.

pub fn read_tag(self: Pin<&mut Self>) -> Result<u32, OperationFailedError>

Reads a tag.

This calls read_varint32 and returns the result. Also updates the last tag value, which can be checked with last_tag_was.

pub fn read_tag_no_last_tag( self: Pin<&mut Self>, ) -> Result<u32, OperationFailedError>

Like read_tag, but does not update the last tag value.

pub fn last_tag_was(self: Pin<&mut Self>, expected: u32) -> bool

Reports whether the last call to read_tag or read_tag_with_cutoff returned the given value.

read_tag_no_last_tag and read_tag_with_cutoff_no_last_tag do not preserve the last returned value.

This is needed because parsers for some types of embedded messages (with field type TYPE_GROUP) don’t actually know that they’ve reached the end of a message until they see an ENDGROUP tag, which was actually part of the enclosing message. The enclosing message would like to check that tag to make sure it had the right number, so it calls last_tag_was on return from the embedded parser to check.

pub fn consumed_entire_message(self: Pin<&mut Self>) -> bool

When parsing a message (but NOT a group), this method must be called immediately after MessageLite::merge_from_coded_stream returns (if it returns true) to further verify that the message ended in a legitimate way.

For example, this verifies that parsing did not end on an end-group tag. It also checks for some cases where, due to optimizations, merge_from_coded_stream can incorrectly return true.

pub fn current_position(&self) -> usize

Returns the stream’s current position relative to the beginning of the input.

Trait Implementations

impl<'a> Drop for CodedInputStream<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Read for Pin<&mut CodedInputStream<'a>>

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

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

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

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.