Struct Chain

pub struct Chain<T, U> { /* private fields */ }

A Chain sequences to BitBufs.

Chain is an adaptor that links to underlying buffers and provides a continuous view across both.

Implementations

impl<T, U> Chain<T, U>

pub fn new(a: T, b: U) -> Self

pub fn first_ref(&self) -> &T

pub fn last_ref(&self) -> &U

pub fn first_mut(&mut self) -> &mut T

pub fn last_mut(&mut self) -> &mut U

pub fn into_inner(self) -> (T, U)

Trait Implementations

impl<T, U> BitBuf for Chain<T, U>

where T: BitBuf, U: BitBuf,

fn advance_bits(&mut self, count: usize)

Advance the internal cursor of the BitBuf by count bits.

fn remaining_bits(&self) -> usize

Returns the number of bits between the current position and the end of the buffer.

fn chunk_bits(&self) -> &BitSlice

Returns a BitSlice starting at the current position and of length between 0 and BitBuf::remaining. Note that this can return a shorter slice.

fn chunk_bytes(&self) -> &[u8]

Returns a slice of bytes starting at the current position and of length between 0 and BitBuf::remaining_bytes. Note that this can return a shorter slice.

fn byte_aligned(&self) -> bool

Returns whether or not this BitBuf is fully byte-aligned (beginning and end) with the underlying storage.

fn advance_bytes(&mut self, count: usize)

Advance the internal cursor of the BitBuf by count bytes.

fn remaining_bytes(&self) -> usize

Return the number of full bytes between the current position and the end of the buffer.

fn has_remaining_bits(&self) -> bool

Returns true if there are any more bits to consume.

fn has_remaining_bytes(&self) -> bool

Returns true if there are any more cmplete bytes to consume.

fn chain<U: BitBuf>(self, next: U) -> Chain<Self, U>

where Self: Sized,

Creates an adaptor which will chain this buffer to another.

fn copy_to_bit_slice(&mut self, dest: &mut BitSlice)

Copy bits from self into dest.

fn try_copy_to_bit_slice(&mut self, dest: &mut BitSlice) -> Result<()>

fn copy_to_slice_bytes(&mut self, dest: &mut [u8])

Copy bytes from self into dest. Call should call byte_aligned() beforehand to ensure buffer is fully byte-aligned before calling, call may panic if buffer isn’t byte-aligned.

fn try_copy_to_slice_bytes(&mut self, dest: &mut [u8]) -> Result<()>

Try to copy bytes from self into dest. Returns error if self is not big enough to fill dest or if self is not fully byte-aligned (start and end points both falling on byte boundaries).

fn take_bits(self, limit: usize) -> Take<Self>

where Self: Sized,

Create an adaptor which can read at most limit bits from self.

fn take_bytes(self, limit: usize) -> Take<Self>

where Self: Sized,

Create an adaptor which can read at most limit bytes from self.

impl<T, U> BitBufMut for Chain<T, U>

where T: BitBufMut, U: BitBufMut,

fn advance_mut_bits(&mut self, count: usize)

Advance the internal cursor of the BitBufMut by count bits.

fn chunk_mut_bits(&mut self) -> &mut BitSlice

Returns a mutable BitSlice starting at the current BitBufMut position and of length between 0 and BitBufMut::remaining_mut(). Note that this can be shorter than the whole remainder of the buffer (this allows non-continuous implementation).

fn chunk_mut_bytes(&mut self) -> &mut UninitSlice

Returns a mutable UninitSlice starting at the current BitBufMut position and of length between 0 and BitBufMut::remaining_mut(). Note that this can be shorter than the whole remainder of the buffer (this allows non-continuous implementation). This BitBufMut must be fully byte-aligned for this to work: caller should check byte_aligned before calling.

fn remaining_mut_bits(&self) -> usize

Returns the number of bits that can be written from the current position until the end of the buffer is reached. Note that the returned value may under-represent the remainin amount: we are returning the value in bits but if the underlying storage is in bytes then the result here will be under-represented by a factor of 8. remaining_mut_bytes will give a more accurate view of how much space (in bytes) is remaining.

fn byte_aligned_mut(&self) -> bool

Returns whether or not this BitBufMut is fully byte-aligned (beginning and end) with the underlying storage.

fn advance_mut_bytes(&mut self, count: usize)

Advance the internal cursor of the BitBufMut by count bytes.

fn limit_bits(self, limit: usize) -> Limit<Self>

where Self: Sized,

Creates an adaptor which can write at most limit bits to self

fn limit_bytes(self, limit: usize) -> Limit<Self>

where Self: Sized,

Creates an adaptor which can write at most limit bytes to self

fn has_remaining_mut_bits(&self) -> bool

Returns true if there is space in self for more bits.

fn remaining_mut_bytes(&self) -> usize

Returns the number of full bytes that can be written from the current position until the end of the buffer is reached.

fn has_reminaing_mut_bytes(&self) -> bool

Returns true if there is space in self for more bytes.

fn chain_mut<U: BitBufMut>(self, next: U) -> Chain<Self, U>

where Self: Sized,

Creates an adaptor which will chain this buffer to another.

fn put_bit_slice(&mut self, src: &BitSlice)

Transfer bits into self from src and advance the cursor by the number of bits written.

fn try_put_bit_slice(&mut self, src: &BitSlice) -> Result<()>

Try to transfer bits info self from src and advance the cursor by the number of bits written.

fn try_put_slice_bytes(&mut self, src: &[u8]) -> Result<()>