Enum Variant 

pub enum Variant {
    Varint,
    SixtyFourBit,
    LengthDelimited,
    ThirtyTwoBit,
}

Represents the wire type variant of a field in a protocol buffer message.

The Variant enum provides a set of predefined wire types that can be used when creating the header for a field. Each variant corresponds to a specific wire type value.

Variants

• Varint - Represents the varint wire type (value 0).
• SixtyFourBit - Represents the 64-bit wire type (value 1).
• LengthDelimited - Represents the length-delimited wire type (value 2).
• ThirtyTwoBit - Represents the 32-bit wire type (value 5).

Conversions

The Variant enum implements the Into<u64> trait, allowing conversion from a Variant to its corresponding wire type value as a u64.

Examples

use rustwire::Variant;

let variant = Variant::LengthDelimited;
let wire_type_value: u64 = variant.into();
assert_eq!(wire_type_value, 2);

In this example, the LengthDelimited variant is created and then converted into its corresponding wire type value using the into() method. The resulting wire_type_value is of type u64 and has a value of 2.

Variants

Varint

SixtyFourBit

LengthDelimited

ThirtyTwoBit

Trait Implementations

impl Debug for Variant

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

Formats the value using the given formatter.

impl From<Variant> for u64

fn from(variant: Variant) -> u64

Converts to this type from the input type.

impl PartialEq for Variant

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Variant

impl StructuralPartialEq for Variant