Enum prototk::Error

pub enum Error {
    Success,
    BufferTooShort {
        required: usize,
        had: usize,
    },
    InvalidFieldNumber {
        field_number: u32,
        what: String,
    },
    UnhandledWireType {
        wire_type: u32,
    },
    TagTooLarge {
        tag: u64,
    },
    VarintOverflow {
        bytes: usize,
    },
    UnsignedOverflow {
        value: u64,
    },
    SignedOverflow {
        value: i64,
    },
    WrongLength {
        required: usize,
        had: usize,
    },
    StringEncoding,
    UnknownDiscriminant {
        discriminant: u32,
    },
    NotAChar {
        value: u32,
    },
}

Error captures the possible error conditions for packing and unpacking.

Variants

Success

The default error is succes.

BufferTooShort

BufferTooShort indicates that there was a need to pack or unpack more bytes than were available in the underlying memory.

Fields

required: usize

The number of bytes required to unpack.

had: usize

The number of bytes available to unpack.

InvalidFieldNumber

InvalidFieldNumber indicates that the field is not a user-assignable field.

Fields

field_number: u32

The u32 field number that’s invalid.

what: String

A human-readable description of why the field number is invalid.

UnhandledWireType

UnhandledWireType indicates that the wire_type is not understood by this process and cannot be skipped.

Fields

wire_type: u32

The wire type that’s not handled.

TagTooLarge

TagTooLarge indicates the tag would overflow a 32-bit number.

Fields

tag: u64

The tag that’s too large.

VarintOverflow

VarintOverflow indicates that a varint field did not terminate with a number < 128.

Fields

bytes: usize

The number of bytes witnessed in the varint.

UnsignedOverflow

UnsignedOverflow indicates that a value will not fit its intended (unsigned) target.

Fields

value: u64

The u64 that doesn’t fit a u32.

SignedOverflow

SignedOverflow indicates that a value will not fit its intended (signed) target.

Fields

value: i64

The i64 that doesn’t fit an i32.

WrongLength

WrongLength indicates that a bytes32 did not have 32 bytes.

Fields

required: usize

The required number of bytes for the type.

had: usize

The number of bytes the type claims to be.

StringEncoding

StringEncoding indicates that a value is not UTF-8 friendly.

UnknownDiscriminant

UnknownDiscriminant indicates a variant that is not understood by this code.

Fields

discriminant: u32

The discriminant that’s not handled by this process.

NotAChar

NotAChar indicates that the prescribed value was tried to unpack as a char, but it’s not a char.

Fields

value: u32

Value that’s not a char.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Default for Error

fn default() -> Error

Returns the “default value” for a type.

impl Display for Error

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

Formats the value using the given formatter.

impl<'a> FieldPackHelper<'a, message<Error>> for Error

fn field_pack_sz(&self, tag: &Tag) -> usize

The size of encoding self with tag.

fn field_pack(&self, tag: &Tag, out: &mut [u8])

Pack the tag into the output buffer.

impl<'a> FieldUnpackHelper<'a, message<Error>> for Error

fn merge_field(&mut self, proto: message<Error>)

Merge the proto into self.

impl From<Error> for Error

fn from(x: Error) -> Self

Converts to this type from the input type.

impl From<message<Error>> for Error

fn from(proto: message<Error>) -> Self

Converts to this type from the input type.

impl Packable for Error

fn pack_sz(&self) -> usize

pack_sz returns the number of bytes required to serialize the Packable object.

fn pack(&self, buf: &mut [u8])

pack fills in the buffer out with the packed binary representation of the Packable object. The implementor is responsible to ensure that out is exactly pack_sz() bytes and implementations are encouraged to assert this.

fn stream<W>(&self, writer: &mut W) -> Result<usize, Error>

where W: Write, Self: Sized, &'a Self: for<'a> Packable,

stream writes the object to the provided writer using the same representation that would be used in a call to pack. The implementor is responsible for making sure that the number of bytes written is exactly equal to the number of required bytes.

impl PartialEq for Error

fn eq(&self, other: &Error) -> 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<'a> Unpackable<'a> for Error

type Error = Error

Type of error this unpackable returns.

fn unpack<'b>(buf: &'b [u8]) -> Result<(Self, &'b [u8]), Error>

where 'b: 'a,

unpack attempts to return an Unpackable object stored in a prefix of buf. The method returns the result and remaining unused buffer.

impl Eq for Error

impl<'a> Message<'a> for Error

impl StructuralPartialEq for Error