Struct CodedInputStream

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

Buffered read with handy utilities.

Implementations

impl<'a> CodedInputStream<'a>

pub fn new(read: &'a mut dyn Read) -> CodedInputStream<'a>

Wrap a Read.

Note resulting CodedInputStream is buffered.

If Read is buffered, the resulting stream will be double buffered, consider using from_buf_read instead.

pub fn from_buf_read(buf_read: &'a mut dyn BufRead) -> CodedInputStream<'a>

Create from BufRead.

CodedInputStream will utilize BufRead buffer.

pub fn from_bytes(bytes: &'a [u8]) -> CodedInputStream<'a>

Read from byte slice

pub fn set_recursion_limit(&mut self, limit: u32)

Set the recursion limit.

pub fn pos(&self) -> u64

How many bytes processed

pub fn bytes_until_limit(&self) -> u64

How many bytes until current limit

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

Read bytes into given buf.

pub fn read_raw_byte(&mut self) -> Result<u8, Error>

Read one byte

pub fn push_limit(&mut self, limit: u64) -> Result<u64, Error>

Push new limit, return previous limit.

pub fn pop_limit(&mut self, old_limit: u64)

Restore previous limit.

pub fn eof(&mut self) -> Result<bool, Error>

Are we at EOF?

pub fn check_eof(&mut self) -> Result<(), Error>

Check we are at EOF.

Return error if we are not at EOF.

pub fn read_raw_varint64(&mut self) -> Result<u64, Error>

Read varint

pub fn read_raw_varint32(&mut self) -> Result<u32, Error>

Read varint

pub fn read_raw_little_endian32(&mut self) -> Result<u32, Error>

Read little-endian 32-bit integer

pub fn read_raw_little_endian64(&mut self) -> Result<u64, Error>

Read little-endian 64-bit integer

pub fn read_raw_tag_or_eof(&mut self) -> Result<Option<u32>, Error>

Read tag number as u32 or None if EOF is reached.

pub fn read_double(&mut self) -> Result<f64, Error>

Read double

pub fn read_float(&mut self) -> Result<f32, Error>

Read float

pub fn read_int64(&mut self) -> Result<i64, Error>

Read int64

pub fn read_int32(&mut self) -> Result<i32, Error>

Read int32

pub fn read_uint64(&mut self) -> Result<u64, Error>

Read uint64

pub fn read_uint32(&mut self) -> Result<u32, Error>

Read uint32

pub fn read_sint64(&mut self) -> Result<i64, Error>

Read sint64

pub fn read_sint32(&mut self) -> Result<i32, Error>

Read sint32

pub fn read_fixed64(&mut self) -> Result<u64, Error>

Read fixed64

pub fn read_fixed32(&mut self) -> Result<u32, Error>

Read fixed32

pub fn read_sfixed64(&mut self) -> Result<i64, Error>

Read sfixed64

pub fn read_sfixed32(&mut self) -> Result<i32, Error>

Read sfixed32

pub fn read_bool(&mut self) -> Result<bool, Error>

Read bool

pub fn read_enum<E>(&mut self) -> Result<E, Error>

where E: Enum,

Read enum as ProtobufEnum

pub fn read_enum_or_unknown<E>(&mut self) -> Result<EnumOrUnknown<E>, Error>

where E: Enum,

Read enum as ProtobufEnumOrUnknown

pub fn read_repeated_packed_double_into( &mut self, target: &mut Vec<f64>, ) -> Result<(), Error>

Read repeated packed double

pub fn read_repeated_packed_float_into( &mut self, target: &mut Vec<f32>, ) -> Result<(), Error>

Read repeated packed float

pub fn read_repeated_packed_int64_into( &mut self, target: &mut Vec<i64>, ) -> Result<(), Error>

Read repeated packed int64

pub fn read_repeated_packed_int32_into( &mut self, target: &mut Vec<i32>, ) -> Result<(), Error>

Read repeated packed int32

pub fn read_repeated_packed_uint64_into( &mut self, target: &mut Vec<u64>, ) -> Result<(), Error>

Read repeated packed uint64

pub fn read_repeated_packed_uint32_into( &mut self, target: &mut Vec<u32>, ) -> Result<(), Error>

Read repeated packed uint32

pub fn read_repeated_packed_sint64_into( &mut self, target: &mut Vec<i64>, ) -> Result<(), Error>

Read repeated packed sint64

pub fn read_repeated_packed_sint32_into( &mut self, target: &mut Vec<i32>, ) -> Result<(), Error>

Read repeated packed sint32

pub fn read_repeated_packed_fixed64_into( &mut self, target: &mut Vec<u64>, ) -> Result<(), Error>

Read repeated packed fixed64

pub fn read_repeated_packed_fixed32_into( &mut self, target: &mut Vec<u32>, ) -> Result<(), Error>

Read repeated packed fixed32

pub fn read_repeated_packed_sfixed64_into( &mut self, target: &mut Vec<i64>, ) -> Result<(), Error>

Read repeated packed sfixed64

pub fn read_repeated_packed_sfixed32_into( &mut self, target: &mut Vec<i32>, ) -> Result<(), Error>

Read repeated packed sfixed32

pub fn read_repeated_packed_bool_into( &mut self, target: &mut Vec<bool>, ) -> Result<(), Error>

Read repeated packed bool

pub fn read_unknown( &mut self, wire_type: WireType, ) -> Result<UnknownValue, Error>

Read UnknownValue

pub fn skip_field(&mut self, wire_type: WireType) -> Result<(), Error>

Skip field.

pub fn read_raw_bytes_into( &mut self, count: u32, target: &mut Vec<u8>, ) -> Result<(), Error>

Read raw bytes into the supplied vector. The vector will be resized as needed and overwritten.

pub fn read_raw_bytes(&mut self, count: u32) -> Result<Vec<u8>, Error>

Read exact number of bytes

pub fn skip_raw_bytes(&mut self, count: u32) -> Result<(), Error>

Skip exact number of bytes

pub fn read_bytes(&mut self) -> Result<Vec<u8>, Error>

Read bytes field, length delimited

pub fn read_bytes_into(&mut self, target: &mut Vec<u8>) -> Result<(), Error>

Read bytes field, length delimited

pub fn read_string(&mut self) -> Result<String, Error>

Read string field, length delimited

pub fn read_string_into(&mut self, target: &mut String) -> Result<(), Error>

Read string field, length delimited

pub fn merge_message<M>(&mut self, message: &mut M) -> Result<(), Error>

where M: Message,

Read message, do not check if message is initialized

pub fn merge_message_dyn( &mut self, message: &mut (dyn MessageDyn + 'static), ) -> Result<(), Error>

Like merge_message, but for dynamic messages.

pub fn read_message<M>(&mut self) -> Result<M, Error>

where M: Message,

Read message

pub fn read_message_dyn( &mut self, descriptor: &MessageDescriptor, ) -> Result<Box<dyn MessageDyn>, Error>

Read message.

Trait Implementations

impl<'a> BufRead for CodedInputStream<'a>

fn fill_buf(&mut self) -> Result<&[u8], Error>

Returns the contents of the internal buffer, filling it with more data, via Read methods, if empty.

fn consume(&mut self, amt: usize)

Marks the given amount of additional bytes from the internal buffer as having been read. Subsequent calls to read only return bytes that have not been marked as read.

fn has_data_left(&mut self) -> Result<bool, Error>

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

Checks if there is any data left to be read.

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

Reads all bytes into buf until the delimiter byte or EOF is reached.

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached.

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

Reads all bytes until a newline (the 0xA byte) is reached, and append them to the provided String buffer.

fn split(self, byte: u8) -> Split<Self>

where Self: Sized,

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

where Self: Sized,

Returns an iterator over the lines of this reader.

impl<'a> Debug for CodedInputStream<'a>

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

Formats the value using the given formatter.

impl<'a> Read for 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.