Trait fire_protobuf::encode::EncodeMessage

pub trait EncodeMessage {
    const WIRE_TYPE: WireType;

    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;

    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>

Implementations on Foreign Types

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 for &mut [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 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<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,

impl EncodeMessage for &mut [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]

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 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 &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<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 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 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 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 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,

Implementors