Struct BufSource 

pub struct BufSource<R> { /* private fields */ }

Available on crate feature std only.

A seekable Source over a forward Read (a socket): it retains the bytes it has read, so a seek-using message (restore_position) works over a non-seekable stream by seeking within the retained buffer, reading more on demand. It is bounded — a retention cap (default 64 KiB) past which it errors ErrorKind::BufferFull rather than buffering unboundedly. The “continuously-receiving peer that also needs to seek” case.

Examples

use bnb::{bin, BufSource};

#[bin(big)]
#[derive(Debug, PartialEq)]
struct Word { value: u32 }

let mut src = BufSource::new(&[0x12, 0x34, 0x56, 0x78][..]); // any `Read`
assert_eq!(Word::decode(&mut src).unwrap(), Word { value: 0x1234_5678 });

Implementations

impl<R: Read> BufSource<R>

pub fn new(inner: R) -> Self

Wraps inner with the default 64 KiB retention cap, MSB-first big-endian.

pub fn with_capacity(inner: R, cap: usize) -> Self

Wraps inner with a retention cap (bytes), MSB-first big-endian.

pub fn with_capacity_and_layout(inner: R, cap: usize, layout: Layout) -> Self

Wraps inner with a retention cap (bytes) and Layout.

Trait Implementations

impl<R: Clone> Clone for BufSource<R>

fn clone(&self) -> BufSource<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for BufSource<R>

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

Formats the value using the given formatter.

impl<R: Read> SeekSource for BufSource<R>

impl<R: Read> Source for BufSource<R>

fn read_bits(&mut self, n: u32) -> Result<u128, BitError>

Reads n (<= 128) bits into the low bits of a u128, in the source’s bit order (MSB-first by default).

fn bit_pos(&self) -> usize

The current absolute bit offset (for position-aware errors).

fn byte_order(&self) -> ByteOrder

The byte order applied to a byte-multiple value (default big-endian).

fn bit_order(&self) -> BitOrder

The bit order this source reads in (default MSB-first). Paired with byte_order to decide whether a byte-multiple value needs its bytes swapped — each bit order has a natural byte layout (big-endian under MSB, little-endian under LSB), and only the opposite declaration swaps.

fn seek_to_bit(&mut self, pos: usize) -> Result<(), BitError>

Moves the cursor to absolute bit pos. The default — for a forward-only source — fails with ErrorKind::NotSeekable; seekable sources (the slice BitReader) override it. A SeekSource guarantees this works.

fn read<T: Bits>(&mut self) -> Result<T, BitError>

Reads one Bits value of its declared width, applying the byte order.

fn read_bytes(&mut self, n: usize) -> Result<Vec<u8>, BitError>

Reads n bytes into a fresh Vec (at any bit offset — the bytes need not be aligned). The bulk form of the per-byte read::<u8>() loop, for blob/payload reads in custom codecs and container formats.

fn read_into(&mut self, buf: &mut [u8]) -> Result<(), BitError>

Fills buf with bytes from the source — the no-alloc dual of read_bytes, for fixed scratch buffers and tight no_std paths.

fn as_read(&mut self) -> SourceReader<'_, Self>

where Self: Sized,

Borrows this source as a std::io::Read over its bytes — for handing the cursor to std::io-based code from a #[br(parse_with = …)] (e.g. a decoder, or a Read-based parser). Reads 8 bits per byte; see SourceReader. Only with the std feature.