Struct BitError 

#[non_exhaustive]
pub struct BitError {
    pub kind: ErrorKind,
    pub at: usize,
    pub field: Option<&'static str>,
}

A position-aware bit-codec error (it carries a span-like position). It records the bit offset where decoding/encoding failed and, when the derive can supply it, the field being processed.

Examples

use bnb::{bin, ErrorKind};

#[bin(big)]
#[derive(Debug)]
struct Pair { a: u16, b: u16 }

let err = Pair::decode_exact(&[0x00]).unwrap_err(); // only one byte of four
assert_eq!(err.at, 0);             // the bit offset where it failed
assert_eq!(err.field, Some("a"));  // the field being read (the span)
assert!(matches!(err.kind, ErrorKind::UnexpectedEof { .. }));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

kind: ErrorKind

The cause.

at: usize

Absolute bit offset where the error occurred.

field: Option<&'static str>

The field being decoded/encoded when it occurred, if recorded by the derive (the innermost field — the “span”). None for low-level reader errors with no field context.

Implementations

impl BitError

pub fn new(kind: ErrorKind, at: usize) -> Self

Builds an error at absolute bit offset at, with no field recorded yet.

pub fn bad_magic(expected: u128, found: u128, at: usize) -> Self

Builds a ErrorKind::BadMagic error (a magic constant mismatched) at absolute bit offset at. expected/found are the type-erased low-bit values (Bits::into_bits).

pub fn convert(message: String, at: usize) -> Self

Builds a ErrorKind::Convert error (a try_map conversion failed) at absolute bit offset at.

pub fn in_field(self, field: &'static str) -> Self

Records the field being processed, if one is not already set — so the innermost field (set first as the error propagates up) wins. The derive calls this per field.

pub fn is_incomplete(&self) -> bool

Whether this is the streaming “need more bytes” signal (ErrorKind::Incomplete) — the caller should read more and retry, as opposed to a definitive parse failure.

Trait Implementations

impl Clone for BitError

fn clone(&self) -> BitError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitError

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

Formats the value using the given formatter.

impl Display for BitError

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

Formats the value using the given formatter.

impl Eq for BitError

impl Error for BitError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for BitError

Available on crate feature std only.

fn from(e: Error) -> Self

Wraps a std::io::Error as ErrorKind::Io — so a parse_with/write_with using Source::as_read/Sink::as_write can ? std::io results straight into a BitError. The bit offset is unknown at this boundary (recorded as 0); build with BitError::new if you need the precise position.

impl From<WidthError> for BitError

fn from(e: WidthError) -> Self

Bridges a construction error (e.g. UInt::try_new) into a codec error, so it ?-propagates inside a custom parse_with/write_with fn or a converter that returns BitError. The offset is unknown (0) — the codec’s own reads/writes carry the real bit offset; this is only for borrowed construction failures with no cursor context.

impl PartialEq for BitError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BitError