Struct Limit

pub struct Limit<T> { /* private fields */ }

Implementations

impl<T> Limit<T>

pub fn new(inner: T, limit: usize) -> Self

pub fn into_inner(self) -> T

pub fn get_ref(&self) -> &T

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

pub fn limit(&self) -> usize

pub fn set_limit(&mut self, limit: usize)

Trait Implementations

impl<T: BitBufMut> BitBufMut for Limit<T>

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<()>