Struct pbcodec::fields::Oneof8

pub struct Oneof8<A, B, C, D, E, F, G, H> {
    pub field: Option<Variant8<A, B, C, D, E, F, G, H>>,
}

Fields

field: Option<Variant8<A, B, C, D, E, F, G, H>>

Trait Implementations

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug> Debug for Oneof8<A, B, C, D, E, F, G, H>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<A, B, C, D, E, F, G, H> Field for Oneof8<A, B, C, D, E, F, G, H> where
    A: SingularField,
    B: SingularField,
    C: SingularField,
    D: SingularField,
    E: SingularField,
    F: SingularField,
    G: SingularField,
    H: SingularField, 

impl<A, B, C, D, E, F, G, H> From<Variant8<A, B, C, D, E, F, G, H>> for Oneof8<A, B, C, D, E, F, G, H>

fn from(f: Variant8<A, B, C, D, E, F, G, H>) -> Self

Performs the conversion.

impl<A, B, C, D, E, F, G, H> From<Option<Variant8<A, B, C, D, E, F, G, H>>> for Oneof8<A, B, C, D, E, F, G, H>

fn from(f: Option<Variant8<A, B, C, D, E, F, G, H>>) -> Self

Performs the conversion.

impl<A, B, C, D, E, F, G, H> Default for Oneof8<A, B, C, D, E, F, G, H>

fn default() -> Self

Returns the "default value" for a type.

impl<R, A, B, C, D, E, F, G, H> DecodeField<R> for Oneof8<A, B, C, D, E, F, G, H> where
    R: Read,
    A: DecodeField<R> + SingularField,
    B: DecodeField<R> + SingularField,
    C: DecodeField<R> + SingularField,
    D: DecodeField<R> + SingularField,
    E: DecodeField<R> + SingularField,
    F: DecodeField<R> + SingularField,
    G: DecodeField<R> + SingularField,
    H: DecodeField<R> + SingularField, 

type Future = DecodeOneof8<R, A, B, C, D, E, F, G, H>

fn is_target(tag: u32) -> bool

fn decode_field(
    self,
    reader: R,
    tag: u32,
    wire_type: WireType
) -> Result<Self::Future, Error<R>>

impl<W, A, B, C, D, E, F, G, H> Encode<W> for Oneof8<A, B, C, D, E, F, G, H> where
    W: Write,
    A: Encode<W> + SingularField,
    B: Encode<W> + SingularField,
    C: Encode<W> + SingularField,
    D: Encode<W> + SingularField,
    E: Encode<W> + SingularField,
    F: Encode<W> + SingularField,
    G: Encode<W> + SingularField,
    H: Encode<W> + SingularField, 

type Future = EncodeOneof8<W, A, B, C, D, E, F, G, H>

fn encode(self, writer: W) -> Self::Future

fn encoded_size(&self) -> u64