Trait pbcodec::traits::Message

pub trait Message: Sized + Default {
    type Base: Message;
    fn from_base(base: Self::Base) -> Result<Self>;
    fn into_base(self) -> Self::Base;

    fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self>
    where
        Self::Base: Encode<W>,
    { ... }
    fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self>
    where
        Self::Base: Decode<R>,
    { ... }
}

Associated Types

type Base: Message

Required Methods

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

Provided Methods

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

Implementations on Foreign Types

impl<A> Message for (A,) where
    A: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B> Message for (A, B) where
    A: Default,
    B: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C> Message for (A, B, C) where
    A: Default,
    B: Default,
    C: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C, D> Message for (A, B, C, D) where
    A: Default,
    B: Default,
    C: Default,
    D: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C, D, E> Message for (A, B, C, D, E) where
    A: Default,
    B: Default,
    C: Default,
    D: Default,
    E: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C, D, E, F> Message for (A, B, C, D, E, F) where
    A: Default,
    B: Default,
    C: Default,
    D: Default,
    E: Default,
    F: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C, D, E, F, G> Message for (A, B, C, D, E, F, G) where
    A: Default,
    B: Default,
    C: Default,
    D: Default,
    E: Default,
    F: Default,
    G: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

impl<A, B, C, D, E, F, G, H> Message for (A, B, C, D, E, F, G, H) where
    A: Default,
    B: Default,
    C: Default,
    D: Default,
    E: Default,
    F: Default,
    G: Default,
    H: Default, 

type Base = Self

fn from_base(base: Self::Base) -> Result<Self>

fn into_base(self) -> Self::Base

fn encode_message<W: Write>(self, writer: W) -> EncodeMessage<W, Self> where
    Self::Base: Encode<W>, 

fn decode_message<R: Read>(reader: R) -> DecodeMessage<R, Self> where
    Self::Base: Decode<R>, 

Implementors