Struct BitBuf 

pub struct BitBuf<S> { /* private fields */ }

The main structure

Keeps track of the data storage and a cursor for automatic operations

Implementations

impl<S> BitBuf<S>

pub const fn from(data: S) -> Self

Construct from provided data storage

pub fn bytes(&self) -> &[u8]

where S: Storage,

Get the underlying bytes from the storage

pub fn bytes_mut(&mut self) -> &mut [u8]

where S: StorageMut,

Get the underlying bytes from the storage

pub fn pos(&self) -> usize

Get the internal cursor for automatic operations

The cursor may not be within storage bounds

pub fn byte_pos(&self) -> usize

Get the byte-aligned position of the internal cursor for automatic operations

The cursor may not be within storage bounds

pub fn advance(&mut self, bits: usize) -> &mut Self

Advance the internal cursor for automatic operations

This does not enforce that the cursor stay within storage bounds

pub fn advance_bytes(&mut self, bytes: usize) -> &mut Self

Advance the internal cursor for automatic operations by a number of bytes

This does not enforce that the cursor stay within storage bounds

pub fn seek(&mut self, offset: usize) -> &mut Self

Set the internal cursor for automatic operations

This does not enforce that the cursor stay within storage bounds

pub fn seek_byte(&mut self, byte: usize) -> &mut Self

Set the internal cursor for automatic operations to a byte position

This sets the cursor to offset * 8 bits.

This does not enforce that the cursor stay within storage bounds

pub fn is_aligned(&self) -> bool

Checks if the internal cursor for automatic operations is aligned on the start of a byte

This does not care whether the cursor is outside storage bounds

impl<S: Storage> BitBuf<S>

pub unsafe fn read_u8_be_aligned_at_unchecked(&self, byte_offset: usize) -> u8

Read a u8 in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 0 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 0 >= self.bytes().len()

pub unsafe fn read_u8_be_aligned_unchecked(&mut self) -> u8

Read the next u8 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 0 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 0 >= self.bytes().len()

pub unsafe fn read_u8_be_at_unchecked(&self, offset: usize) -> u8

Read a u8 in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

• This is UB if (offset / 8) + 0 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 0 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub unsafe fn read_u8_be_unchecked(&mut self) -> u8

Read the next u8 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 0 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 0 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

pub fn try_read_u8_be_aligned_at(&self, byte_offset: usize) -> Result<u8>

Read a u8 in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 0 >= self.bytes().len()

pub fn try_read_u8_be_aligned(&mut self) -> Result<u8>

Read the next u8 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 0 >= self.bytes().len()

pub fn try_read_u8_be_at(&self, offset: usize) -> Result<u8>

Read a u8 in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 0 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub fn try_read_u8_be(&mut self) -> Result<u8>

Read the next u8 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 0 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

pub fn read_u8_be_aligned_at(&self, byte_offset: usize) -> u8

Read a u8 in [BE-bit, BE-byte] order from byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 0 >= self.bytes().len()

pub fn read_u8_be_aligned(&mut self) -> u8

Read the next u8 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 0 >= self.bytes().len()

pub fn read_u8_be_at(&self, offset: usize) -> u8

Read a u8 in [BE-bit, BE-byte] order from offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 0 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub fn read_u8_be(&mut self) -> u8

Read the next u8 in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

• Panics if (self.pos() / 8) + 0 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

impl<S: Storage> BitBuf<S>

pub unsafe fn read_u16_be_aligned_at_unchecked(&self, byte_offset: usize) -> u16

Read a u16 in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 1 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 1 >= self.bytes().len()

pub unsafe fn read_u16_be_aligned_unchecked(&mut self) -> u16

Read the next u16 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 1 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 1 >= self.bytes().len()

pub unsafe fn read_u16_be_at_unchecked(&self, offset: usize) -> u16

Read a u16 in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

• This is UB if (offset / 8) + 1 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 1 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub unsafe fn read_u16_be_unchecked(&mut self) -> u16

Read the next u16 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 1 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 1 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

pub fn try_read_u16_be_aligned_at(&self, byte_offset: usize) -> Result<u16>

Read a u16 in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 1 >= self.bytes().len()

pub fn try_read_u16_be_aligned(&mut self) -> Result<u16>

Read the next u16 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 1 >= self.bytes().len()

pub fn try_read_u16_be_at(&self, offset: usize) -> Result<u16>

Read a u16 in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 1 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub fn try_read_u16_be(&mut self) -> Result<u16>

Read the next u16 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 1 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

pub fn read_u16_be_aligned_at(&self, byte_offset: usize) -> u16

Read a u16 in [BE-bit, BE-byte] order from byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 1 >= self.bytes().len()

pub fn read_u16_be_aligned(&mut self) -> u16

Read the next u16 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 1 >= self.bytes().len()

pub fn read_u16_be_at(&self, offset: usize) -> u16

Read a u16 in [BE-bit, BE-byte] order from offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 1 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub fn read_u16_be(&mut self) -> u16

Read the next u16 in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

• Panics if (self.pos() / 8) + 1 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

impl<S: Storage> BitBuf<S>

pub unsafe fn read_u32_be_aligned_at_unchecked(&self, byte_offset: usize) -> u32

Read a u32 in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 3 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 3 >= self.bytes().len()

pub unsafe fn read_u32_be_aligned_unchecked(&mut self) -> u32

Read the next u32 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 3 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 3 >= self.bytes().len()

pub unsafe fn read_u32_be_at_unchecked(&self, offset: usize) -> u32

Read a u32 in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

• This is UB if (offset / 8) + 3 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 3 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub unsafe fn read_u32_be_unchecked(&mut self) -> u32

Read the next u32 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 3 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 3 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

pub fn try_read_u32_be_aligned_at(&self, byte_offset: usize) -> Result<u32>

Read a u32 in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 3 >= self.bytes().len()

pub fn try_read_u32_be_aligned(&mut self) -> Result<u32>

Read the next u32 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 3 >= self.bytes().len()

pub fn try_read_u32_be_at(&self, offset: usize) -> Result<u32>

Read a u32 in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 3 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub fn try_read_u32_be(&mut self) -> Result<u32>

Read the next u32 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 3 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

pub fn read_u32_be_aligned_at(&self, byte_offset: usize) -> u32

Read a u32 in [BE-bit, BE-byte] order from byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 3 >= self.bytes().len()

pub fn read_u32_be_aligned(&mut self) -> u32

Read the next u32 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 3 >= self.bytes().len()

pub fn read_u32_be_at(&self, offset: usize) -> u32

Read a u32 in [BE-bit, BE-byte] order from offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 3 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub fn read_u32_be(&mut self) -> u32

Read the next u32 in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

• Panics if (self.pos() / 8) + 3 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

impl<S: Storage> BitBuf<S>

pub unsafe fn read_u64_be_aligned_at_unchecked(&self, byte_offset: usize) -> u64

Read a u64 in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 7 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 7 >= self.bytes().len()

pub unsafe fn read_u64_be_aligned_unchecked(&mut self) -> u64

Read the next u64 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 7 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 7 >= self.bytes().len()

pub unsafe fn read_u64_be_at_unchecked(&self, offset: usize) -> u64

Read a u64 in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

• This is UB if (offset / 8) + 7 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 7 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub unsafe fn read_u64_be_unchecked(&mut self) -> u64

Read the next u64 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 7 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 7 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

pub fn try_read_u64_be_aligned_at(&self, byte_offset: usize) -> Result<u64>

Read a u64 in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 7 >= self.bytes().len()

pub fn try_read_u64_be_aligned(&mut self) -> Result<u64>

Read the next u64 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 7 >= self.bytes().len()

pub fn try_read_u64_be_at(&self, offset: usize) -> Result<u64>

Read a u64 in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 7 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub fn try_read_u64_be(&mut self) -> Result<u64>

Read the next u64 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 7 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

pub fn read_u64_be_aligned_at(&self, byte_offset: usize) -> u64

Read a u64 in [BE-bit, BE-byte] order from byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 7 >= self.bytes().len()

pub fn read_u64_be_aligned(&mut self) -> u64

Read the next u64 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 7 >= self.bytes().len()

pub fn read_u64_be_at(&self, offset: usize) -> u64

Read a u64 in [BE-bit, BE-byte] order from offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 7 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub fn read_u64_be(&mut self) -> u64

Read the next u64 in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

• Panics if (self.pos() / 8) + 7 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

impl<S: Storage> BitBuf<S>

pub unsafe fn read_u128_be_aligned_at_unchecked( &self, byte_offset: usize, ) -> u128

Read a u128 in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 15 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 15 >= self.bytes().len()

pub unsafe fn read_u128_be_aligned_unchecked(&mut self) -> u128

Read the next u128 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 15 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 15 >= self.bytes().len()

pub unsafe fn read_u128_be_at_unchecked(&self, offset: usize) -> u128

Read a u128 in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

• This is UB if (offset / 8) + 15 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 15 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub unsafe fn read_u128_be_unchecked(&mut self) -> u128

Read the next u128 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 15 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 15 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

pub fn try_read_u128_be_aligned_at(&self, byte_offset: usize) -> Result<u128>

Read a u128 in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 15 >= self.bytes().len()

pub fn try_read_u128_be_aligned(&mut self) -> Result<u128>

Read the next u128 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 15 >= self.bytes().len()

pub fn try_read_u128_be_at(&self, offset: usize) -> Result<u128>

Read a u128 in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 15 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub fn try_read_u128_be(&mut self) -> Result<u128>

Read the next u128 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 15 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

pub fn read_u128_be_aligned_at(&self, byte_offset: usize) -> u128

Read a u128 in [BE-bit, BE-byte] order from byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 15 >= self.bytes().len()

pub fn read_u128_be_aligned(&mut self) -> u128

Read the next u128 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 15 >= self.bytes().len()

pub fn read_u128_be_at(&self, offset: usize) -> u128

Read a u128 in [BE-bit, BE-byte] order from offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 15 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub fn read_u128_be(&mut self) -> u128

Read the next u128 in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

• Panics if (self.pos() / 8) + 15 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

impl<S: Storage> BitBuf<S>

pub unsafe fn read_be_aligned_at_unchecked<T: Read>( &self, byte_offset: usize, ) -> T

Read a T in [BE-bit, BE-byte] order from byte_offset without performing bound checks

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn read_be_aligned_unchecked<T: Read>(&mut self) -> T

Read the next T in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn read_be_at_unchecked<T: Read>(&self, offset: usize) -> T

Read a T in [BE-bit, BE-byte] order from offset without performing bound checks

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn read_be_unchecked<T: Read>(&mut self) -> T

Read the next T in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub fn try_read_be_aligned_at<T: Read>(&self, byte_offset: usize) -> Result<T>

Read a T in [BE-bit, BE-byte] order from byte_offset while performing bound checks

Errors

All semantics of the corresponding function for the type apply

pub fn try_read_be_aligned<T: Read>(&mut self) -> Result<T>

Read the next T in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

All semantics of the corresponding function for the type apply

pub fn try_read_be_at<T: Read>(&self, offset: usize) -> Result<T>

Read a T in [BE-bit, BE-byte] order from offset while performing bound checks

Errors

All semantics of the corresponding function for the type apply

pub fn try_read_be<T: Read>(&mut self) -> Result<T>

Read the next T in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

All semantics of the corresponding function for the type apply

pub fn read_be_aligned_at<T: Read>(&self, byte_offset: usize) -> T

Read a T in [BE-bit, BE-byte] order from byte_offset, panicking on out of bounds

Panics

All semantics of the corresponding function for the type apply

pub fn read_be_aligned<T: Read>(&mut self) -> T

Read the next T in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

All semantics of the corresponding function for the type apply

pub fn read_be_at<T: Read>(&self, offset: usize) -> T

Read a T in [BE-bit, BE-byte] order from offset, panicking on out of bounds

Panics

All semantics of the corresponding function for the type apply

pub fn read_be<T: Read>(&mut self) -> T

Read the next T in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

All semantics of the corresponding function for the type apply

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_u8_be_aligned_at_unchecked( &mut self, byte_offset: usize, v: u8, ) -> &mut Self

Write a u8 in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 0 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 0 >= self.bytes().len()

pub unsafe fn write_u8_be_aligned_unchecked(&mut self, v: u8) -> &mut Self

Write the next u8 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 0 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 0 >= self.bytes().len()

pub unsafe fn write_u8_be_at_unchecked( &mut self, offset: usize, v: u8, ) -> &mut Self

Write a u8 in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

• This is UB if (offset / 8) + 0 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 0 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub unsafe fn write_u8_be_unchecked(&mut self, v: u8) -> &mut Self

Write the next u8 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 0 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 0 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

pub fn try_write_u8_be_aligned_at( &mut self, byte_offset: usize, v: u8, ) -> Result<&mut Self>

Write a u8 in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 0 >= self.bytes().len()

pub fn try_write_u8_be_aligned(&mut self, v: u8) -> Result<&mut Self>

Write the next u8 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 0 >= self.bytes().len()

pub fn try_write_u8_be_at(&mut self, offset: usize, v: u8) -> Result<&mut Self>

Write a u8 in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 0 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub fn try_write_u8_be(&mut self, v: u8) -> Result<&mut Self>

Write the next u8 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 0 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

pub fn write_u8_be_aligned_at(&mut self, byte_offset: usize, v: u8) -> &mut Self

Write a u8 in [BE-bit, BE-byte] order at byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 0 >= self.bytes().len()

pub fn write_u8_be_aligned(&mut self, v: u8) -> &mut Self

Write the next u8 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 0 >= self.bytes().len()

pub fn write_u8_be_at(&mut self, offset: usize, v: u8) -> &mut Self

Write a u8 in [BE-bit, BE-byte] order at offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 0 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 1 >= self.bytes().len()

pub fn write_u8_be(&mut self, v: u8) -> &mut Self

Write the next u8 in [BE-bit, BE-byte] order panicking on out of bounds

Panics

• Panics if (self.pos() / 8) + 0 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 1 >= self.bytes().len()

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_u16_be_aligned_at_unchecked( &mut self, byte_offset: usize, v: u16, ) -> &mut Self

Write a u16 in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 1 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 1 >= self.bytes().len()

pub unsafe fn write_u16_be_aligned_unchecked(&mut self, v: u16) -> &mut Self

Write the next u16 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 1 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 1 >= self.bytes().len()

pub unsafe fn write_u16_be_at_unchecked( &mut self, offset: usize, v: u16, ) -> &mut Self

Write a u16 in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

• This is UB if (offset / 8) + 1 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 1 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub unsafe fn write_u16_be_unchecked(&mut self, v: u16) -> &mut Self

Write the next u16 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 1 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 1 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

pub fn try_write_u16_be_aligned_at( &mut self, byte_offset: usize, v: u16, ) -> Result<&mut Self>

Write a u16 in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 1 >= self.bytes().len()

pub fn try_write_u16_be_aligned(&mut self, v: u16) -> Result<&mut Self>

Write the next u16 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 1 >= self.bytes().len()

pub fn try_write_u16_be_at( &mut self, offset: usize, v: u16, ) -> Result<&mut Self>

Write a u16 in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 1 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub fn try_write_u16_be(&mut self, v: u16) -> Result<&mut Self>

Write the next u16 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 1 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

pub fn write_u16_be_aligned_at( &mut self, byte_offset: usize, v: u16, ) -> &mut Self

Write a u16 in [BE-bit, BE-byte] order at byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 1 >= self.bytes().len()

pub fn write_u16_be_aligned(&mut self, v: u16) -> &mut Self

Write the next u16 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 1 >= self.bytes().len()

pub fn write_u16_be_at(&mut self, offset: usize, v: u16) -> &mut Self

Write a u16 in [BE-bit, BE-byte] order at offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 1 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 2 >= self.bytes().len()

pub fn write_u16_be(&mut self, v: u16) -> &mut Self

Write the next u16 in [BE-bit, BE-byte] order panicking on out of bounds

Panics

• Panics if (self.pos() / 8) + 1 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 2 >= self.bytes().len()

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_u32_be_aligned_at_unchecked( &mut self, byte_offset: usize, v: u32, ) -> &mut Self

Write a u32 in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 3 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 3 >= self.bytes().len()

pub unsafe fn write_u32_be_aligned_unchecked(&mut self, v: u32) -> &mut Self

Write the next u32 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 3 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 3 >= self.bytes().len()

pub unsafe fn write_u32_be_at_unchecked( &mut self, offset: usize, v: u32, ) -> &mut Self

Write a u32 in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

• This is UB if (offset / 8) + 3 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 3 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub unsafe fn write_u32_be_unchecked(&mut self, v: u32) -> &mut Self

Write the next u32 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 3 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 3 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

pub fn try_write_u32_be_aligned_at( &mut self, byte_offset: usize, v: u32, ) -> Result<&mut Self>

Write a u32 in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 3 >= self.bytes().len()

pub fn try_write_u32_be_aligned(&mut self, v: u32) -> Result<&mut Self>

Write the next u32 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 3 >= self.bytes().len()

pub fn try_write_u32_be_at( &mut self, offset: usize, v: u32, ) -> Result<&mut Self>

Write a u32 in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 3 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub fn try_write_u32_be(&mut self, v: u32) -> Result<&mut Self>

Write the next u32 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 3 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

pub fn write_u32_be_aligned_at( &mut self, byte_offset: usize, v: u32, ) -> &mut Self

Write a u32 in [BE-bit, BE-byte] order at byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 3 >= self.bytes().len()

pub fn write_u32_be_aligned(&mut self, v: u32) -> &mut Self

Write the next u32 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 3 >= self.bytes().len()

pub fn write_u32_be_at(&mut self, offset: usize, v: u32) -> &mut Self

Write a u32 in [BE-bit, BE-byte] order at offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 3 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 4 >= self.bytes().len()

pub fn write_u32_be(&mut self, v: u32) -> &mut Self

Write the next u32 in [BE-bit, BE-byte] order panicking on out of bounds

Panics

• Panics if (self.pos() / 8) + 3 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 4 >= self.bytes().len()

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_u64_be_aligned_at_unchecked( &mut self, byte_offset: usize, v: u64, ) -> &mut Self

Write a u64 in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 7 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 7 >= self.bytes().len()

pub unsafe fn write_u64_be_aligned_unchecked(&mut self, v: u64) -> &mut Self

Write the next u64 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 7 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 7 >= self.bytes().len()

pub unsafe fn write_u64_be_at_unchecked( &mut self, offset: usize, v: u64, ) -> &mut Self

Write a u64 in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

• This is UB if (offset / 8) + 7 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 7 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub unsafe fn write_u64_be_unchecked(&mut self, v: u64) -> &mut Self

Write the next u64 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 7 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 7 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

pub fn try_write_u64_be_aligned_at( &mut self, byte_offset: usize, v: u64, ) -> Result<&mut Self>

Write a u64 in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 7 >= self.bytes().len()

pub fn try_write_u64_be_aligned(&mut self, v: u64) -> Result<&mut Self>

Write the next u64 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 7 >= self.bytes().len()

pub fn try_write_u64_be_at( &mut self, offset: usize, v: u64, ) -> Result<&mut Self>

Write a u64 in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 7 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub fn try_write_u64_be(&mut self, v: u64) -> Result<&mut Self>

Write the next u64 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 7 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

pub fn write_u64_be_aligned_at( &mut self, byte_offset: usize, v: u64, ) -> &mut Self

Write a u64 in [BE-bit, BE-byte] order at byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 7 >= self.bytes().len()

pub fn write_u64_be_aligned(&mut self, v: u64) -> &mut Self

Write the next u64 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 7 >= self.bytes().len()

pub fn write_u64_be_at(&mut self, offset: usize, v: u64) -> &mut Self

Write a u64 in [BE-bit, BE-byte] order at offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 7 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 8 >= self.bytes().len()

pub fn write_u64_be(&mut self, v: u64) -> &mut Self

Write the next u64 in [BE-bit, BE-byte] order panicking on out of bounds

Panics

• Panics if (self.pos() / 8) + 7 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 8 >= self.bytes().len()

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_u128_be_aligned_at_unchecked( &mut self, byte_offset: usize, v: u128, ) -> &mut Self

Write a u128 in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

• This is UB if byte_offset + 15 >= self.bytes().len()

Panics

• Panics in debug mode if byte_offset + 15 >= self.bytes().len()

pub unsafe fn write_u128_be_aligned_unchecked(&mut self, v: u128) -> &mut Self

Write the next u128 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• The internal cursor must be byte-aligned (self.is_aligned())
• This is UB if self.byte_pos() + 15 >= self.bytes().len()

Panics

• Panics in debug mode if the internal cursor is not byte-aligned (!self.is_aligned())
• Panics in debug mode if self.byte_pos() + 15 >= self.bytes().len()

pub unsafe fn write_u128_be_at_unchecked( &mut self, offset: usize, v: u128, ) -> &mut Self

Write a u128 in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

• This is UB if (offset / 8) + 15 >= self.bytes().len()
• This is UB if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

Panics

• Panics in debug mode if (offset / 8) + 15 >= self.bytes().len()
• Panics in debug mode if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub unsafe fn write_u128_be_unchecked(&mut self, v: u128) -> &mut Self

Write the next u128 in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

• This is UB if (self.pos() / 8) + 15 >= self.bytes().len()
• This is UB if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

Panics

• Panics in debug mode if (self.pos() / 8) + 15 >= self.bytes().len()
• Panics in debug mode if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

pub fn try_write_u128_be_aligned_at( &mut self, byte_offset: usize, v: u128, ) -> Result<&mut Self>

Write a u128 in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if byte_offset + 15 >= self.bytes().len()

pub fn try_write_u128_be_aligned(&mut self, v: u128) -> Result<&mut Self>

Write the next u128 in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

• Returns Error::Unaligned
  • if the internal cursor is not byte-aligned (!self.is_aligned())
• Returns Error::OutOfBounds
  • if self.byte_pos() + 15 >= self.bytes().len()

pub fn try_write_u128_be_at( &mut self, offset: usize, v: u128, ) -> Result<&mut Self>

Write a u128 in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

• Returns Error::OutOfBounds
  • if (offset / 8) + 15 >= self.bytes().len()
  • if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub fn try_write_u128_be(&mut self, v: u128) -> Result<&mut Self>

Write the next u128 in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

• Returns Error::OutOfBounds
  • if (self.pos() / 8) + 15 >= self.bytes().len()
  • if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

pub fn write_u128_be_aligned_at( &mut self, byte_offset: usize, v: u128, ) -> &mut Self

Write a u128 in [BE-bit, BE-byte] order at byte_offset panicking on out of bounds

Panics

• Panics if byte_offset + 15 >= self.bytes().len()

pub fn write_u128_be_aligned(&mut self, v: u128) -> &mut Self

Write the next u128 in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

• if the internal cursor is not byte-aligned (!self.is_aligned())
• if self.byte_pos() + 15 >= self.bytes().len()

pub fn write_u128_be_at(&mut self, offset: usize, v: u128) -> &mut Self

Write a u128 in [BE-bit, BE-byte] order at offset panicking on out of bounds

Panics

• Panics if (offset / 8) + 15 >= self.bytes().len()
• Panics if (offset % 8 != 0) && (offset / 8) + 16 >= self.bytes().len()

pub fn write_u128_be(&mut self, v: u128) -> &mut Self

Write the next u128 in [BE-bit, BE-byte] order panicking on out of bounds

Panics

• Panics if (self.pos() / 8) + 15 >= self.bytes().len()
• Panics if (self.pos() % 8 != 0) && (self.pos() / 8) + 16 >= self.bytes().len()

impl<S: StorageMut> BitBuf<S>

pub unsafe fn write_be_aligned_at_unchecked<T: Write>( &mut self, byte_offset: usize, v: T, ) -> &mut Self

Write a T in [BE-bit, BE-byte] order at byte_offset without performing bound checks

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn write_be_aligned_unchecked<T: Write>(&mut self, v: T) -> &mut Self

Write the next T in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn write_be_at_unchecked<T: Write>( &mut self, offset: usize, v: T, ) -> &mut Self

Write a T in [BE-bit, BE-byte] order at offset without performing bound checks

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub unsafe fn write_be_unchecked<T: Write>(&mut self, v: T) -> &mut Self

Write the next T in [BE-bit, BE-byte] order without performing bound checks, advancing the internal cursor

Safety

All semantics of the corresponding function for the type apply

Panics

All semantics of the corresponding function for the type apply

pub fn try_write_be_aligned_at<T: Write>( &mut self, byte_offset: usize, v: T, ) -> Result<&mut Self>

Write a T in [BE-bit, BE-byte] order at byte_offset while performing bound checks

Errors

All semantics of the corresponding function for the type apply

pub fn try_write_be_aligned<T: Write>(&mut self, v: T) -> Result<&mut Self>

Write the next T in [BE-bit, BE-byte] order while performing alignment and bound checks, advancing the internal cursor

Errors

All semantics of the corresponding function for the type apply

pub fn try_write_be_at<T: Write>( &mut self, offset: usize, v: T, ) -> Result<&mut Self>

Write a T in [BE-bit, BE-byte] order at offset while performing bound checks

Errors

All semantics of the corresponding function for the type apply

pub fn try_write_be<T: Write>(&mut self, v: T) -> Result<&mut Self>

Write the next T in [BE-bit, BE-byte] order while performing bound checks, advancing the internal cursor

Errors

All semantics of the corresponding function for the type apply

pub fn write_be_aligned_at<T: Write>( &mut self, byte_offset: usize, v: T, ) -> &mut Self

Write a T in [BE-bit, BE-byte] order at byte_offset, panicking on out of bounds

Panics

All semantics of the corresponding function for the type apply

pub fn write_be_aligned<T: Write>(&mut self, v: T) -> &mut Self

Write the next T in [BE-bit, BE-byte] order panicking on an unaligned cursor or out of bounds, advancing the internal cursor

Panics

All semantics of the corresponding function for the type apply

pub fn write_be_at<T: Write>(&mut self, offset: usize, v: T) -> &mut Self

Write a T in [BE-bit, BE-byte] order at offset, panicking on out of bounds

Panics

All semantics of the corresponding function for the type apply

pub fn write_be<T: Write>(&mut self, v: T) -> &mut Self

Write the next T in [BE-bit, BE-byte] order panicking on out of bounds, advancing the internal cursor

Panics

All semantics of the corresponding function for the type apply

Trait Implementations

impl<S: Debug> Debug for BitBuf<S>

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

Formats the value using the given formatter.