Struct prost_reflect::UnknownField

pub struct UnknownField { /* private fields */ }

An unknown field found when deserializing a protobuf message.

A field is unknown if the message descriptor does not contain a field with the given number. This is often the result of a new field being added to the message definition.

The Message implementation of DynamicMessage will preserve any unknown fields.

Implementations

impl UnknownField

pub fn number(&self) -> u32

The number of this field as found during decoding.

pub fn wire_type(&self) -> WireType

The wire type of this field as found during decoding.

pub fn encode<B>(&self, buf: &mut B)where B: BufMut,

Encodes this field into its byte representation.

pub fn decode<B>(buf: &mut B, ctx: DecodeContext) -> Result<Self, DecodeError>where B: Buf,

Decodes an unknown field from the given buffer.

This method will read the field number and wire type from the buffer. Normally, it is useful to know the field number before deciding whether to treat a field as unknown. See decode_value if you have already read the number.

Examples

let unknown_field = UnknownField::decode(&mut b"\x1a\x02\x10\x42".as_ref(), DecodeContext::default()).unwrap();
assert_eq!(unknown_field.number(), 3);
assert_eq!(unknown_field.wire_type(), WireType::LengthDelimited);

pub fn decode_value<B>( number: u32, wire_type: WireType, buf: &mut B, ctx: DecodeContext ) -> Result<Self, DecodeError>where B: Buf,

Given a field number and wire type, decodes the value of an unknown field.

This method assumes the field number and wire type have already been read from the buffer. See also decode.

Examples

let unknown_field = UnknownField::decode_value(3, WireType::LengthDelimited, &mut b"\x02\x10\x42".as_ref(), DecodeContext::default()).unwrap();
assert_eq!(unknown_field.number(), 3);
assert_eq!(unknown_field.wire_type(), WireType::LengthDelimited);

let mut buf = Vec::new();
unknown_field.encode(&mut buf);
assert_eq!(buf, b"\x1a\x02\x10\x42");

pub fn encoded_len(&self) -> usize

Gets the length of this field when encoded to its byte representation.

Trait Implementations

impl Clone for UnknownField

fn clone(&self) -> UnknownField

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UnknownField

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

Formats the value using the given formatter.

impl Display for UnknownField

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

Formats this unknown field using the protobuf text format.

The protobuf format does not include type information, so the formatter will attempt to infer types.

Examples

let unknown_field = UnknownField::decode(&mut b"\x1a\x02\x10\x42".as_ref(), DecodeContext::default()).unwrap();
assert_eq!(format!("{}", unknown_field), "3{2:66}");
// The alternate format specifier may be used to indent the output
assert_eq!(format!("{:#}", unknown_field), "3 {\n  2: 66\n}");

impl PartialEq<UnknownField> for UnknownField

fn eq(&self, other: &UnknownField) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for UnknownField