Trait EncodeMessage

pub trait EncodeMessage {
    const WIRE_TYPE: WireType;

    // Required methods
    fn is_default(&self) -> bool;
    fn encoded_size(
        &mut self,
        field: Option<FieldOpt>,
        builder: &mut SizeBuilder,
    ) -> Result<(), EncodeError>;
    fn encode<B>(
        &mut self,
        field: Option<FieldOpt>,
        encoder: &mut MessageEncoder<B>,
    ) -> Result<(), EncodeError>
       where B: BytesWrite;

    // Provided method
    fn write_to_bytes(&mut self) -> Result<Vec<u8>, EncodeError> { ... }
}

Ignoring fields

if your call tells you a field number you need to write it even if you have the default value

You can only ignore writing fields if you wan’t

Required Associated Constants

const WIRE_TYPE: WireType

at the moment only used to check if this message can be packed

Required Methods

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after encoding

The that get’s returned here needs to be the same as called in write

if fieldnum is set this means you need to write the tag

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

In most cases before this is called encoded_size get’s called

The size that get’s computed in encoded_size must be the same as we get here

if fieldnum is set this means you need to write the tag to

Provided Methods

fn write_to_bytes(&mut self) -> Result<Vec<u8>, EncodeError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl EncodeMessage for &bool

const WIRE_TYPE: WireType = WireType::Varint

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &f32

const WIRE_TYPE: WireType = WireType::I32

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &f64

const WIRE_TYPE: WireType = WireType::I64

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &i32

const WIRE_TYPE: WireType = WireType::Varint

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &i64

const WIRE_TYPE: WireType = WireType::Varint

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &str

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &u32

const WIRE_TYPE: WireType = WireType::Varint

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &u64

const WIRE_TYPE: WireType = WireType::Varint

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &String

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for &[u8]

fn encoded_size( &mut self, field: Option<FieldOpt>, writer: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, writer: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for bool

const WIRE_TYPE: WireType = <&bool>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for f32

const WIRE_TYPE: WireType = <&f32>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for f64

const WIRE_TYPE: WireType = <&f64>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for i32

const WIRE_TYPE: WireType = <&i32>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for i64

const WIRE_TYPE: WireType = <&i64>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for u32

const WIRE_TYPE: WireType = <&u32>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for u64

const WIRE_TYPE: WireType = <&u64>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for String

const WIRE_TYPE: WireType = <&String>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for Vec<u8>

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl EncodeMessage for [u8]

const WIRE_TYPE: WireType = <&[u8]>::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<A, B> EncodeMessage for (A, B)

where A: EncodeMessage, B: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<Bytes>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<Bytes>, ) -> Result<(), EncodeError>

where Bytes: BytesWrite,

impl<A, B, C> EncodeMessage for (A, B, C)

where A: EncodeMessage, B: EncodeMessage, C: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<Bytes>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<Bytes>, ) -> Result<(), EncodeError>

where Bytes: BytesWrite,

impl<A, B, C, D> EncodeMessage for (A, B, C, D)

where A: EncodeMessage, B: EncodeMessage, C: EncodeMessage, D: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<Bytes>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<Bytes>, ) -> Result<(), EncodeError>

where Bytes: BytesWrite,

impl<A, B, C, D, E> EncodeMessage for (A, B, C, D, E)

where A: EncodeMessage, B: EncodeMessage, C: EncodeMessage, D: EncodeMessage, E: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<Bytes>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<Bytes>, ) -> Result<(), EncodeError>

where Bytes: BytesWrite,

impl<A, B, C, D, E, F> EncodeMessage for (A, B, C, D, E, F)

where A: EncodeMessage, B: EncodeMessage, C: EncodeMessage, D: EncodeMessage, E: EncodeMessage, F: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<Bytes>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<Bytes>, ) -> Result<(), EncodeError>

where Bytes: BytesWrite,

impl<K, V> EncodeMessage for HashMap<K, V>

where for<'a> &'a K: EncodeMessage, V: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<T> EncodeMessage for Option<T>

where T: EncodeMessage,

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<V> EncodeMessage for [V]

where V: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<V> EncodeMessage for Vec<V>

where V: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<V, const S: usize> EncodeMessage for [V; S]

where V: EncodeMessage,

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<V: EncodeMessage> EncodeMessage for &mut V

const WIRE_TYPE: WireType = V::WIRE_TYPE

fn is_default(&self) -> bool

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

impl<const S: usize> EncodeMessage for [u8; S]

fn encoded_size( &mut self, field: Option<FieldOpt>, builder: &mut SizeBuilder, ) -> Result<(), EncodeError>

how big will the size be after writing

const WIRE_TYPE: WireType = WireType::Len

fn is_default(&self) -> bool

fn encode<B>( &mut self, field: Option<FieldOpt>, encoder: &mut MessageEncoder<B>, ) -> Result<(), EncodeError>

where B: BytesWrite,

Implementors