Struct bitvec::boxed::BitBox

pub struct BitBox<T = usize, O = Lsb0>
where
    T: BitStore,
    O: BitOrder,
{ /* private fields */ }

Fixed-Size, Heap-Allocated, Bit Slice

BitBox is a heap-allocated BitSlice region. It is a distinct type because the implementation of bit-slice pointers means that Box<BitSlice> cannot exist. It can be created by cloning a bit-slice into the heap, or by freezing the allocation of a BitVec

Original

Box<[T]>

API Differences

As with BitSlice, this takes a pair of BitOrder and BitStore type parameters to govern the buffer’s memory representation. Because BitSlice is unsized, BitBox has almost none of the Box API, and is difficult to use directly.

Behavior

BitBox, like &BitSlice, is an opaque pointer to a bit-addressed slice region. Unlike &BitSlice, it uses the allocator to guarantee that it is the sole accessor to the referent buffer, and is able to use that uniqueness guarantee to specialize some BitSlice behavior to be faster or more efficient.

Safety

BitBox is, essentially, a NonNull<BitSlice<T, O>> pointer. The internal value is opaque and cannot be inspected or modified by user code.

If you attempt to do so, your program becomes inconsistent. You will likely break the allocator’s internal state and cause a crash. No guarantees of crash or recovery are provided. Do not inspect or modify the BitBox handle value.

Construction

The simplest way to construct a BitBox is by using the bitbox! macro. You can also explicitly clone a BitSlice with BitBox::from_bitslice, or freeze a BitVec with BitVec::into_boxed_bitslice.

Examples

use bitvec::prelude::*;

let a = BitBox::from_bitslice(bits![1, 0, 1, 1, 0]);
let b = bitbox![0, 1, 0, 0, 1];

let b_raw: *mut BitSlice = BitBox::into_raw(b);
let b_reformed = unsafe { BitBox::from_raw(b_raw) };

Implementations

impl<T, O> BitBox<T, O>

where T: BitStore, O: BitOrder,

pub unsafe fn from_raw(raw: *mut BitSlice<T, O>) -> Self

Constructs a bit-box from a raw bit-slice pointer.

This converts a *mut BitSlice pointer that had previously been produced by either ::into_raw() or ::leak() and restores the bit-box containing it.

Original

Box::from_raw

Safety

You must only call this function on pointers produced by leaking a prior BitBox; you may not modify the value of a pointer returned by ::into_raw(), nor may you conjure pointer values of your own. Doing so will corrupt the allocator state.

You must only call this function on any given leaked pointer at most once. Not calling it at all will merely render the allocated memory unreachable for the duration of the program runtime, a normal (and safe) memory leak. Calling it once restores ordinary functionality, and ensures ordinary destruction at or before program termination. However, calling it more than once on the same pointer will introduce data races, use-after-free, and/or double-free errors.

Examples

use bitvec::prelude::*;

let bb = bitbox![0; 80];
let ptr: *mut BitSlice = BitBox::into_raw(bb);
let bb = unsafe { BitBox::from_raw(ptr) };
// unsafe { BitBox::from_raw(ptr) }; // UAF crash!

pub fn into_raw(this: Self) -> *mut BitSlice<T, O>

Consumes the bit-box, returning a raw bit-slice pointer.

Bit-slice pointers are always correctly encoded and non-null. The referent region is dereferenceäble *as a BitSlice for the remainder of the program, or until it is first passed to ::from_raw(), whichever comes first. Once the pointer is first passed to ::from_raw(), all copies of that pointer become invalid to dereference.

Original

Box::into_raw

Examples

use bitvec::prelude::*;

let bb = bitbox![0; 80];
let ptr = BitBox::into_raw(bb);
let bb = unsafe { BitBox::from_raw(ptr) };

You may not deällocate pointers produced by this function through any other means.

pub fn leak<'a>(this: Self) -> &'a mut BitSlice<T, O>

where T: 'a,

Deliberately leaks the allocated memory, returning an &'static mut BitSlice reference.

This differs from ::into_raw() in that the reference is safe to use and can be tracked by the Rust borrow-checking system. Like the bit-slice pointer produced by ::into_raw(), this reference can be un-leaked by passing it into ::from_raw() to reclaim the memory.

Original

Box::leak

Examples

use bitvec::prelude::*;

let bb = bitbox![0; 80];
let static_ref: &'static mut BitSlice = BitBox::leak(bb);

static_ref.set(0, true);
assert!(static_ref[0]);
let _ = unsafe {
  BitBox::from_raw(static_ref)
};

impl<T, O> BitBox<T, O>

where T: BitStore, O: BitOrder,

pub fn from_bitslice(slice: &BitSlice<T, O>) -> Self

Copies a bit-slice region into a new bit-box allocation.

The referent memory is memcpyd into the heap, exactly preserving the original bit-slice’s memory layout and contents. This allows the function to run as fast as possible, but misaligned source bit-slices may result in decreased performance or unexpected layout behavior during use. You can use .force_align() to ensure that the referent bit-slice is aligned in memory.

Notes

Bits in the allocation of the source bit-slice, but outside its own description of that memory, have an unspecified, but initialized, value. You may not rely on their contents in any way, and you should call .force_align() and/or .fill_uninitialized() if you are going to inspect the underlying memory of the new allocation.

Examples

use bitvec::prelude::*;

let data = 0b0101_1011u8;
let bits = data.view_bits::<Msb0>();
let bb = BitBox::from_bitslice(&bits[2 ..]);
assert_eq!(bb, bits[2 ..]);

pub fn from_boxed_slice(boxed: Box<[T]>) -> Self

Converts a Box<[T]> into a BitBox<T, O>, in place.

This does not affect the referent buffer, and only transforms the handle.

Panics

This panics if the provided boxed slice is too long to view as a bit-slice region.

Examples

use bitvec::prelude::*;

let boxed: Box<[u8]> = Box::new([0; 40]);
let addr = boxed.as_ptr();
let bb = BitBox::<u8>::from_boxed_slice(boxed);
assert_eq!(bb, bits![0; 320]);
assert_eq!(addr, bb.as_raw_slice().as_ptr());

pub fn try_from_boxed_slice(boxed: Box<[T]>) -> Result<Self, Box<[T]>>

Attempts to convert an ordinary boxed slice into a boxed bit-slice.

This does not perform a copy or reällocation; it only attempts to transform the handle. Because Box<[T]> can be longer than BitBoxes, it may fail, and will return the original handle if it does.

It is unlikely that you have a single Box<[_]> that is too large to convert into a bit-box. You can find the length restrictions as the bit-slice associated constants MAX_BITS and MAX_ELTS.

Examples

use bitvec::prelude::*;

let boxed: Box<[u8]> = Box::new([0u8; 40]);
let addr = boxed.as_ptr();
let bb = BitBox::<u8>::try_from_boxed_slice(boxed).unwrap();
assert_eq!(bb, bits![0; 320]);
assert_eq!(addr, bb.as_raw_slice().as_ptr());

pub fn into_boxed_slice(self) -> Box<[T]>

Converts the bit-box back into an ordinary boxed element slice.

This does not touch the allocator or the buffer contents; it is purely a handle transform.

Examples

use bitvec::prelude::*;

let bb = bitbox![0; 5];
let addr = bb.as_raw_slice().as_ptr();
let boxed = bb.into_boxed_slice();
assert_eq!(boxed[..], [0][..]);
assert_eq!(addr, boxed.as_ptr());

pub fn into_bitvec(self) -> BitVec<T, O>

Converts the bit-box into a bit-vector.

This uses the Rust allocator API, and does not guarantee whether or not a reällocation occurs internally.

The resulting bit-vector can be converted back into a bit-box via BitBox::into_boxed_bitslice.

Original

slice::into_vec

API Differences

The original function is implemented in an impl<T> [T] block, despite taking a Box<[T]> receiver. Since BitBox cannot be used as an explicit receiver outside its own impl blocks, the method is relocated here.

Examples

use bitvec::prelude::*;

let bb = bitbox![0, 1, 0, 0, 1];
let bv = bb.into_bitvec();

assert_eq!(bv, bitvec![0, 1, 0, 0, 1]);

pub fn as_bitslice(&self) -> &BitSlice<T, O>

Explicitly views the bit-box as a bit-slice.

pub fn as_mut_bitslice(&mut self) -> &mut BitSlice<T, O>

Explicitly views the bit-box as a mutable bit-slice.

pub fn as_raw_slice(&self) -> &[T]

Views the bit-box as a slice of its underlying memory elements.

Because bit-boxes uniquely own their buffer, they can safely view the underlying buffer without dealing with contending neighbors.

pub fn as_raw_mut_slice(&mut self) -> &mut [T]

Views the bit-box as a mutable slice of its underlying memory elements.

Because bit-boxes uniquely own their buffer, they can safely view the underlying buffer without dealing with contending neighbors.

pub fn fill_uninitialized(&mut self, value: bool)

Sets the unused bits outside the BitBox buffer to a fixed value.

This method modifies all bits that the allocated buffer owns but which are outside the self.as_bitslice() view. bitvec guarantees that all owned bits are initialized to some value, but does not guarantee which value. This method can be used to make all such unused bits have a known value after the call, so that viewing the underlying memory directly has consistent results.

Note that the crate implementation guarantees that all bits owned by its handles are stably initialized according to the language and compiler rules! bitvec will never cause UB by using uninitialized memory.

Examples

use bitvec::prelude::*;

let bits = 0b1011_0101u8.view_bits::<Msb0>();
let mut bb = BitBox::from_bitslice(&bits[2 .. 6]);
assert_eq!(bb.count_ones(), 3);
// Remember, the two bits on each edge are unspecified, and cannot be
// observed! They must be masked away for the test to be meaningful.
assert_eq!(bb.as_raw_slice()[0] & 0x3C, 0b00_1101_00u8);

bb.fill_uninitialized(false);
assert_eq!(bb.as_raw_slice(), &[0b00_1101_00u8]);

bb.fill_uninitialized(true);
assert_eq!(bb.as_raw_slice(), &[0b11_1101_11u8]);

pub fn force_align(&mut self)

Ensures that the allocated buffer has no dead bits between the start of the buffer and the start of the live bit-slice.

This is useful for ensuring a consistent memory layout in bit-boxes created by cloning an arbitrary bit-slice into the heap. As bit-slices can begin and end anywhere in memory, the ::from_bitslice() function does not attempt to normalize them and only does a fast element-wise copy when creating the bit-box.

The value of dead bits that are in the allocation but not in the live region are initialized, but do not have a specified value. After calling this method, you should use .fill_uninitialized() to set the excess bits in the buffer to a fixed value.

Examples

use bitvec::prelude::*;

let bits = &0b10_1101_01u8.view_bits::<Msb0>()[2 .. 6];
let mut bb = BitBox::from_bitslice(bits);
// Remember, the two bits on each edge are unspecified, and cannot be
// observed! They must be masked away for the test to be meaningful.
assert_eq!(bb.as_raw_slice()[0] & 0x3C, 0b00_1101_00u8);

bb.force_align();
bb.fill_uninitialized(false);
assert_eq!(bb.as_raw_slice(), &[0b1101_0000u8]);

Methods from Deref<Target = BitSlice<T, O>>

pub fn len(&self) -> usize

Gets the number of bits in the bit-slice.

Original

slice::len

Examples

use bitvec::prelude::*;

assert_eq!(bits![].len(), 0);
assert_eq!(bits![0; 10].len(), 10);

pub fn is_empty(&self) -> bool

Tests if the bit-slice is empty (length zero).

Original

slice::is_empty

Examples

use bitvec::prelude::*;

assert!(bits![].is_empty());
assert!(!bits![0; 10].is_empty());

pub fn first(&self) -> Option<BitRef<'_, Const, T, O>>

Gets a reference to the first bit of the bit-slice, or None if it is empty.

Original

slice::first

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool.

Examples

use bitvec::prelude::*;

let bits = bits![1, 0, 0];
assert_eq!(bits.first().as_deref(), Some(&true));

assert!(bits![].first().is_none());

pub fn first_mut(&mut self) -> Option<BitRef<'_, Mut, T, O>>

Gets a mutable reference to the first bit of the bit-slice, or None if it is empty.

Original

slice::first_mut

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool. This must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 3];
if let Some(mut first) = bits.first_mut() {
  *first = true;
}
assert_eq!(bits, bits![1, 0, 0]);

assert!(bits![mut].first_mut().is_none());

pub fn split_first(&self) -> Option<(BitRef<'_, Const, T, O>, &Self)>

Splits the bit-slice into a reference to its first bit, and the rest of the bit-slice. Returns None when empty.

Original

slice::split_first

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool.

Examples

use bitvec::prelude::*;

let bits = bits![1, 0, 0];
let (first, rest) = bits.split_first().unwrap();
assert_eq!(first, &true);
assert_eq!(rest, bits![0; 2]);

pub fn split_first_mut( &mut self ) -> Option<(BitRef<'_, Mut, T::Alias, O>, &mut BitSlice<T::Alias, O>)>

Splits the bit-slice into mutable references of its first bit, and the rest of the bit-slice. Returns None when empty.

Original

slice::split_first_mut

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool. This must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 3];
if let Some((mut first, rest)) = bits.split_first_mut() {
  *first = true;
  assert_eq!(rest, bits![0; 2]);
}
assert_eq!(bits, bits![1, 0, 0]);

pub fn split_last(&self) -> Option<(BitRef<'_, Const, T, O>, &Self)>

Splits the bit-slice into a reference to its last bit, and the rest of the bit-slice. Returns None when empty.

Original

slice::split_last

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1];
let (last, rest) = bits.split_last().unwrap();
assert_eq!(last, &true);
assert_eq!(rest, bits![0; 2]);

pub fn split_last_mut( &mut self ) -> Option<(BitRef<'_, Mut, T::Alias, O>, &mut BitSlice<T::Alias, O>)>

Splits the bit-slice into mutable references to its last bit, and the rest of the bit-slice. Returns None when empty.

Original

slice::split_last_mut

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool. This must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 3];
if let Some((mut last, rest)) = bits.split_last_mut() {
  *last = true;
  assert_eq!(rest, bits![0; 2]);
}
assert_eq!(bits, bits![0, 0, 1]);

pub fn last(&self) -> Option<BitRef<'_, Const, T, O>>

Gets a reference to the last bit of the bit-slice, or None if it is empty.

Original

slice::last

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1];
assert_eq!(bits.last().as_deref(), Some(&true));

assert!(bits![].last().is_none());

pub fn last_mut(&mut self) -> Option<BitRef<'_, Mut, T, O>>

Gets a mutable reference to the last bit of the bit-slice, or None if it is empty.

Original

slice::last_mut

API Differences

bitvec uses a custom structure for both read-only and mutable references to bool. This must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 3];
if let Some(mut last) = bits.last_mut() {
  *last = true;
}
assert_eq!(bits, bits![0, 0, 1]);

assert!(bits![mut].last_mut().is_none());

pub fn get<'a, I>(&'a self, index: I) -> Option<I::Immut>

where I: BitSliceIndex<'a, T, O>,

Gets a reference to a single bit or a subsection of the bit-slice, depending on the type of index.

• If given a usize, this produces a reference structure to the bool at the position.
• If given any form of range, this produces a smaller bit-slice.

This returns None if the index departs the bounds of self.

Original

slice::get

API Differences

BitSliceIndex uses discrete types for immutable and mutable references, rather than a single referent type.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0];
assert_eq!(bits.get(1).as_deref(), Some(&true));
assert_eq!(bits.get(0 .. 2), Some(bits![0, 1]));
assert!(bits.get(3).is_none());
assert!(bits.get(0 .. 4).is_none());

pub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::Mut>

where I: BitSliceIndex<'a, T, O>,

Gets a mutable reference to a single bit or a subsection of the bit-slice, depending on the type of index.

• If given a usize, this produces a reference structure to the bool at the position.
• If given any form of range, this produces a smaller bit-slice.

This returns None if the index departs the bounds of self.

Original

slice::get_mut

API Differences

BitSliceIndex uses discrete types for immutable and mutable references, rather than a single referent type.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 3];

*bits.get_mut(0).unwrap() = true;
bits.get_mut(1 ..).unwrap().fill(true);
assert_eq!(bits, bits![1; 3]);

pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Immut

where I: BitSliceIndex<'a, T, O>,

Gets a reference to a single bit or to a subsection of the bit-slice, without bounds checking.

This has the same arguments and behavior as .get(), except that it does not check that index is in bounds.

Original

slice::get_unchecked

Safety

You must ensure that index is within bounds (within the range 0 .. self.len()), or this method will introduce memory safety and/or undefined behavior.

It is library-level undefined behavior to index beyond the length of any bit-slice, even if you know that the offset remains within an allocation as measured by Rust or LLVM.

Examples

use bitvec::prelude::*;

let data = 0b0001_0010u8;
let bits = &data.view_bits::<Lsb0>()[.. 3];

unsafe {
  assert!(bits.get_unchecked(1));
  assert!(bits.get_unchecked(4));
}

pub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::Mut

where I: BitSliceIndex<'a, T, O>,

Gets a mutable reference to a single bit or a subsection of the bit-slice, depending on the type of index.

This has the same arguments and behavior as .get_mut(), except that it does not check that index is in bounds.

Original

slice::get_unchecked_mut

Safety

You must ensure that index is within bounds (within the range 0 .. self.len()), or this method will introduce memory safety and/or undefined behavior.

It is library-level undefined behavior to index beyond the length of any bit-slice, even if you know that the offset remains within an allocation as measured by Rust or LLVM.

Examples

use bitvec::prelude::*;

let mut data = 0u8;
let bits = &mut data.view_bits_mut::<Lsb0>()[.. 3];

unsafe {
  bits.get_unchecked_mut(1).commit(true);
  bits.get_unchecked_mut(4 .. 6).fill(true);
}
assert_eq!(data, 0b0011_0010);

pub fn as_ptr(&self) -> BitPtr<Const, T, O>

👎Deprecated: use .as_bitptr() instead

pub fn as_mut_ptr(&mut self) -> BitPtr<Mut, T, O>

👎Deprecated: use .as_mut_bitptr() instead

pub fn as_ptr_range(&self) -> Range<BitPtr<Const, T, O>>

Produces a range of bit-pointers to each bit in the bit-slice.

This is a standard-library range, which has no real functionality for pointer types. You should prefer .as_bitptr_range() instead, as it produces a custom structure that provides expected ranging functionality.

Original

slice::as_ptr_range

pub fn as_mut_ptr_range(&mut self) -> Range<BitPtr<Mut, T, O>>

Produces a range of mutable bit-pointers to each bit in the bit-slice.

This is a standard-library range, which has no real functionality for pointer types. You should prefer .as_mut_bitptr_range() instead, as it produces a custom structure that provides expected ranging functionality.

Original

slice::as_mut_ptr_range

pub fn swap(&mut self, a: usize, b: usize)

Exchanges the bit values at two indices.

Original

slice::swap

Panics

This panics if either a or b are out of bounds.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 1];
bits.swap(0, 1);
assert_eq!(bits, bits![1, 0]);

pub fn reverse(&mut self)

Reverses the order of bits in a bit-slice.

Original

slice::reverse

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 1, 1, 0, 0, 1];
bits.reverse();
assert_eq!(bits, bits![1, 0, 0, 1, 1, 0, 1, 0, 0]);

pub fn iter(&self) -> Iter<'_, T, O>

Produces an iterator over each bit in the bit-slice.

Original

slice::iter

API Differences

This iterator yields proxy-reference structures, not &bool. It can be adapted to yield &bool with the .by_refs() method, or bool with .by_vals().

This iterator, and its adapters, are fast. Do not try to be more clever than them by abusing .as_bitptr_range().

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 1];
let mut iter = bits.iter();

assert!(!iter.next().unwrap());
assert!( iter.next().unwrap());
assert!( iter.next_back().unwrap());
assert!(!iter.next_back().unwrap());
assert!( iter.next().is_none());

pub fn iter_mut(&mut self) -> IterMut<'_, T, O>

Produces a mutable iterator over each bit in the bit-slice.

Original

slice::iter_mut

API Differences

This iterator yields proxy-reference structures, not &mut bool. In addition, it marks each proxy as alias-tainted.

If you are using this in an ordinary loop and not keeping multiple yielded proxy-references alive at the same scope, you may use the .remove_alias() adapter to undo the alias marking.

This iterator is fast. Do not try to be more clever than it by abusing .as_mut_bitptr_range().

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 4];
let mut iter = bits.iter_mut();

iter.nth(1).unwrap().commit(true); // index 1
iter.next_back().unwrap().commit(true); // index 3

assert!(iter.next().is_some()); // index 2
assert!(iter.next().is_none()); // complete
assert_eq!(bits, bits![0, 1, 0, 1]);

pub fn windows(&self, size: usize) -> Windows<'_, T, O>

Iterates over consecutive windowing subslices in a bit-slice.

Windows are overlapping views of the bit-slice. Each window advances one bit from the previous, so in a bit-slice [A, B, C, D, E], calling .windows(3) will yield [A, B, C], [B, C, D], and [C, D, E].

Original

slice::windows

Panics

This panics if size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1];
let mut iter = bits.windows(3);

assert_eq!(iter.next(), Some(bits![0, 1, 0]));
assert_eq!(iter.next(), Some(bits![1, 0, 0]));
assert_eq!(iter.next(), Some(bits![0, 0, 1]));
assert!(iter.next().is_none());

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T, O>

Iterates over non-overlapping subslices of a bit-slice.

Unlike .windows(), the subslices this yields do not overlap with each other. If self.len() is not an even multiple of chunk_size, then the last chunk yielded will be shorter.

Original

slice::chunks

Sibling Methods

• .chunks_mut() has the same division logic, but each yielded bit-slice is mutable.
• .chunks_exact() does not yield the final chunk if it is shorter than chunk_size.
• .rchunks() iterates from the back of the bit-slice to the front, with the final, possibly-shorter, segment at the front edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1];
let mut iter = bits.chunks(2);

assert_eq!(iter.next(), Some(bits![0, 1]));
assert_eq!(iter.next(), Some(bits![0, 0]));
assert_eq!(iter.next(), Some(bits![1]));
assert!(iter.next().is_none());

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T, O>

Iterates over non-overlapping mutable subslices of a bit-slice.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::chunks_mut

Sibling Methods

• .chunks() has the same division logic, but each yielded bit-slice is immutable.
• .chunks_exact_mut() does not yield the final chunk if it is shorter than chunk_size.
• .rchunks_mut() iterates from the back of the bit-slice to the front, with the final, possibly-shorter, segment at the front edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut u8, Msb0; 0; 5];

for (idx, chunk) in unsafe {
  bits.chunks_mut(2).remove_alias()
}.enumerate() {
  chunk.store(idx + 1);
}
assert_eq!(bits, bits![0, 1, 1, 0, 1]);
//                     ^^^^  ^^^^  ^

pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T, O>

Iterates over non-overlapping subslices of a bit-slice.

If self.len() is not an even multiple of chunk_size, then the last few bits are not yielded by the iterator at all. They can be accessed with the .remainder() method if the iterator is bound to a name.

Original

slice::chunks_exact

Sibling Methods

• .chunks() yields any leftover bits at the end as a shorter chunk during iteration.
• .chunks_exact_mut() has the same division logic, but each yielded bit-slice is mutable.
• .rchunks_exact() iterates from the back of the bit-slice to the front, with the unyielded remainder segment at the front edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1];
let mut iter = bits.chunks_exact(2);

assert_eq!(iter.next(), Some(bits![0, 1]));
assert_eq!(iter.next(), Some(bits![0, 0]));
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), bits![1]);

pub fn chunks_exact_mut( &mut self, chunk_size: usize ) -> ChunksExactMut<'_, T, O>

Iterates over non-overlapping mutable subslices of a bit-slice.

If self.len() is not an even multiple of chunk_size, then the last few bits are not yielded by the iterator at all. They can be accessed with the .into_remainder() method if the iterator is bound to a name.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::chunks_exact_mut

Sibling Methods

• .chunks_mut() yields any leftover bits at the end as a shorter chunk during iteration.
• .chunks_exact() has the same division logic, but each yielded bit-slice is immutable.
• .rchunks_exact_mut() iterates from the back of the bit-slice forwards, with the unyielded remainder segment at the front edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut u8, Msb0; 0; 5];
let mut iter = bits.chunks_exact_mut(2);

for (idx, chunk) in iter.by_ref().enumerate() {
  chunk.store(idx + 1);
}
iter.into_remainder().store(1u8);

assert_eq!(bits, bits![0, 1, 1, 0, 1]);
//                       remainder ^

pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T, O>

Iterates over non-overlapping subslices of a bit-slice, from the back edge.

Unlike .chunks(), this aligns its chunks to the back edge of self. If self.len() is not an even multiple of chunk_size, then the leftover partial chunk is self[0 .. len % chunk_size].

Original

slice::rchunks

Sibling Methods

• .rchunks_mut() has the same division logic, but each yielded bit-slice is mutable.
• .rchunks_exact() does not yield the final chunk if it is shorter than chunk_size.
• .chunks() iterates from the front of the bit-slice to the back, with the final, possibly-shorter, segment at the back edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1];
let mut iter = bits.rchunks(2);

assert_eq!(iter.next(), Some(bits![0, 1]));
assert_eq!(iter.next(), Some(bits![1, 0]));
assert_eq!(iter.next(), Some(bits![0]));
assert!(iter.next().is_none());

pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T, O>

Iterates over non-overlapping mutable subslices of a bit-slice, from the back edge.

Unlike .chunks_mut(), this aligns its chunks to the back edge of self. If self.len() is not an even multiple of chunk_size, then the leftover partial chunk is self[0 .. len % chunk_size].

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded values for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::rchunks_mut

Sibling Methods

• .rchunks() has the same division logic, but each yielded bit-slice is immutable.
• .rchunks_exact_mut() does not yield the final chunk if it is shorter than chunk_size.
• .chunks_mut() iterates from the front of the bit-slice to the back, with the final, possibly-shorter, segment at the back edge.

Examples

use bitvec::prelude::*;

let bits = bits![mut u8, Msb0; 0; 5];
for (idx, chunk) in unsafe {
  bits.rchunks_mut(2).remove_alias()
}.enumerate() {
  chunk.store(idx + 1);
}
assert_eq!(bits, bits![1, 1, 0, 0, 1]);
//           remainder ^  ^^^^  ^^^^

pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T, O>

Iterates over non-overlapping subslices of a bit-slice, from the back edge.

If self.len() is not an even multiple of chunk_size, then the first few bits are not yielded by the iterator at all. They can be accessed with the .remainder() method if the iterator is bound to a name.

Original

slice::rchunks_exact

Sibling Methods

• .rchunks() yields any leftover bits at the front as a shorter chunk during iteration.
• .rchunks_exact_mut() has the same division logic, but each yielded bit-slice is mutable.
• .chunks_exact() iterates from the front of the bit-slice to the back, with the unyielded remainder segment at the back edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1];
let mut iter = bits.rchunks_exact(2);

assert_eq!(iter.next(), Some(bits![0, 1]));
assert_eq!(iter.next(), Some(bits![1, 0]));
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), bits![0]);

pub fn rchunks_exact_mut( &mut self, chunk_size: usize ) -> RChunksExactMut<'_, T, O>

Iterates over non-overlapping mutable subslices of a bit-slice, from the back edge.

If self.len() is not an even multiple of chunk_size, then the first few bits are not yielded by the iterator at all. They can be accessed with the .into_remainder() method if the iterator is bound to a name.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Sibling Methods

• .rchunks_mut() yields any leftover bits at the front as a shorter chunk during iteration.
• .rchunks_exact() has the same division logic, but each yielded bit-slice is immutable.
• .chunks_exact_mut() iterates from the front of the bit-slice backwards, with the unyielded remainder segment at the back edge.

Panics

This panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut u8, Msb0; 0; 5];
let mut iter = bits.rchunks_exact_mut(2);

for (idx, chunk) in iter.by_ref().enumerate() {
  chunk.store(idx + 1);
}
iter.into_remainder().store(1u8);

assert_eq!(bits, bits![1, 1, 0, 0, 1]);
//           remainder ^

pub fn split_at(&self, mid: usize) -> (&Self, &Self)

Splits a bit-slice in two parts at an index.

The returned bit-slices are self[.. mid] and self[mid ..]. mid is included in the right bit-slice, not the left.

If mid is 0 then the left bit-slice is empty; if it is self.len() then the right bit-slice is empty.

This method guarantees that even when either partition is empty, the encoded bit-pointer values of the bit-slice references is &self[0] and &self[mid].

Original

slice::split_at

Panics

This panics if mid is greater than self.len(). It is allowed to be equal to the length, in which case the right bit-slice is simply empty.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 0, 1, 1, 1];
let base = bits.as_bitptr();

let (a, b) = bits.split_at(0);
assert_eq!(unsafe { a.as_bitptr().offset_from(base) }, 0);
assert_eq!(unsafe { b.as_bitptr().offset_from(base) }, 0);

let (a, b) = bits.split_at(6);
assert_eq!(unsafe { b.as_bitptr().offset_from(base) }, 6);

let (a, b) = bits.split_at(3);
assert_eq!(a, bits![0; 3]);
assert_eq!(b, bits![1; 3]);

pub fn split_at_mut( &mut self, mid: usize ) -> (&mut BitSlice<T::Alias, O>, &mut BitSlice<T::Alias, O>)

Splits a mutable bit-slice in two parts at an index.

The returned bit-slices are self[.. mid] and self[mid ..]. mid is included in the right bit-slice, not the left.

If mid is 0 then the left bit-slice is empty; if it is self.len() then the right bit-slice is empty.

This method guarantees that even when either partition is empty, the encoded bit-pointer values of the bit-slice references is &self[0] and &self[mid].

Original

slice::split_at_mut

API Differences

The end bits of the left half and the start bits of the right half might be stored in the same memory element. In order to avoid breaking bitvec’s memory-safety guarantees, both bit-slices are marked as T::Alias. This marking allows them to be used without interfering with each other when they interact with memory.

Panics

This panics if mid is greater than self.len(). It is allowed to be equal to the length, in which case the right bit-slice is simply empty.

Examples

use bitvec::prelude::*;

let bits = bits![mut u8, Msb0; 0; 6];
let base = bits.as_mut_bitptr();

let (a, b) = bits.split_at_mut(0);
assert_eq!(unsafe { a.as_mut_bitptr().offset_from(base) }, 0);
assert_eq!(unsafe { b.as_mut_bitptr().offset_from(base) }, 0);

let (a, b) = bits.split_at_mut(6);
assert_eq!(unsafe { b.as_mut_bitptr().offset_from(base) }, 6);

let (a, b) = bits.split_at_mut(3);
a.store(3);
b.store(5);

assert_eq!(bits, bits![0, 1, 1, 1, 0, 1]);

pub fn split<F>(&self, pred: F) -> Split<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over subslices separated by bits that match a predicate. The matched bit is not contained in the yielded bit-slices.

Original

slice::split

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .split_mut() has the same splitting logic, but each yielded bit-slice is mutable.
• .split_inclusive() includes the matched bit in the yielded bit-slice.
• .rsplit() iterates from the back of the bit-slice instead of the front.
• .splitn() times out after n yields.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 1, 0];
//                     ^
let mut iter = bits.split(|pos, _bit| pos % 3 == 2);

assert_eq!(iter.next().unwrap(), bits![0, 1]);
assert_eq!(iter.next().unwrap(), bits![0]);
assert!(iter.next().is_none());

If the first bit is matched, then an empty bit-slice will be the first item yielded by the iterator. Similarly, if the last bit in the bit-slice matches, then an empty bit-slice will be the last item yielded.

use bitvec::prelude::*;

let bits = bits![0, 0, 1];
//                     ^
let mut iter = bits.split(|_pos, bit| *bit);

assert_eq!(iter.next().unwrap(), bits![0; 2]);
assert!(iter.next().unwrap().is_empty());
assert!(iter.next().is_none());

If two matched bits are directly adjacent, then an empty bit-slice will be yielded between them:

use bitvec::prelude::*;

let bits = bits![1, 0, 0, 1];
//                  ^  ^
let mut iter = bits.split(|_pos, bit| !*bit);

assert_eq!(iter.next().unwrap(), bits![1]);
assert!(iter.next().unwrap().is_empty());
assert_eq!(iter.next().unwrap(), bits![1]);
assert!(iter.next().is_none());

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate. The matched bit is not contained in the yielded bit-slices.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::split_mut

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .split() has the same splitting logic, but each yielded bit-slice is immutable.
• .split_inclusive_mut() includes the matched bit in the yielded bit-slice.
• .rsplit_mut() iterates from the back of the bit-slice instead of the front.
• .splitn_mut() times out after n yields.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 1, 0];
//                         ^     ^
for group in bits.split_mut(|_pos, bit| *bit) {
  group.set(0, true);
}
assert_eq!(bits, bits![1, 0, 1, 1, 1, 1]);

pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over subslices separated by bits that match a predicate. Unlike .split(), this does include the matching bit as the last bit in the yielded bit-slice.

Original

slice::split_inclusive

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .split_inclusive_mut() has the same splitting logic, but each yielded bit-slice is mutable.
• .split() does not include the matched bit in the yielded bit-slice.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1, 0, 1];
//                     ^     ^
let mut iter = bits.split_inclusive(|_pos, bit| *bit);

assert_eq!(iter.next().unwrap(), bits![0, 0, 1]);
assert_eq!(iter.next().unwrap(), bits![0, 1]);
assert!(iter.next().is_none());

pub fn split_inclusive_mut<F>( &mut self, pred: F ) -> SplitInclusiveMut<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate. Unlike .split_mut(), this does include the matching bit as the last bit in the bit-slice.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::split_inclusive_mut

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .split_inclusive() has the same splitting logic, but each yielded bit-slice is immutable.
• .split_mut() does not include the matched bit in the yielded bit-slice.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 0, 0, 0];
//                         ^
for group in bits.split_inclusive_mut(|pos, _bit| pos % 3 == 2) {
  group.set(0, true);
}
assert_eq!(bits, bits![1, 0, 0, 1, 0]);

pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over subslices separated by bits that match a predicate, from the back edge. The matched bit is not contained in the yielded bit-slices.

Original

slice::rsplit

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .rsplit_mut() has the same splitting logic, but each yielded bit-slice is mutable.
• .split() iterates from the front of the bit-slice instead of the back.
• .rsplitn() times out after n yields.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 1, 0];
//                     ^
let mut iter = bits.rsplit(|pos, _bit| pos % 3 == 2);

assert_eq!(iter.next().unwrap(), bits![0]);
assert_eq!(iter.next().unwrap(), bits![0, 1]);
assert!(iter.next().is_none());

If the last bit is matched, then an empty bit-slice will be the first item yielded by the iterator. Similarly, if the first bit in the bit-slice matches, then an empty bit-slice will be the last item yielded.

use bitvec::prelude::*;

let bits = bits![0, 0, 1];
//                     ^
let mut iter = bits.rsplit(|_pos, bit| *bit);

assert!(iter.next().unwrap().is_empty());
assert_eq!(iter.next().unwrap(), bits![0; 2]);
assert!(iter.next().is_none());

If two yielded bits are directly adjacent, then an empty bit-slice will be yielded between them:

use bitvec::prelude::*;

let bits = bits![1, 0, 0, 1];
//                  ^  ^
let mut iter = bits.split(|_pos, bit| !*bit);

assert_eq!(iter.next().unwrap(), bits![1]);
assert!(iter.next().unwrap().is_empty());
assert_eq!(iter.next().unwrap(), bits![1]);
assert!(iter.next().is_none());

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate, from the back. The matched bit is not contained in the yielded bit-slices.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::rsplit_mut

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .rsplit() has the same splitting logic, but each yielded bit-slice is immutable.
• .split_mut() iterates from the front of the bit-slice to the back.
• .rsplitn_mut() iterates from the front of the bit-slice to the back.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 1, 0];
//                         ^     ^
for group in bits.rsplit_mut(|_pos, bit| *bit) {
  group.set(0, true);
}
assert_eq!(bits, bits![1, 0, 1, 1, 1, 1]);

pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over subslices separated by bits that match a predicate, giving up after yielding n times. The nth yield contains the rest of the bit-slice. As with .split(), the yielded bit-slices do not contain the matched bit.

Original

slice::splitn

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .splitn_mut() has the same splitting logic, but each yielded bit-slice is mutable.
• .rsplitn() iterates from the back of the bit-slice instead of the front.
• .split() has the same splitting logic, but never times out.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1, 0, 1, 0];
let mut iter = bits.splitn(2, |_pos, bit| *bit);

assert_eq!(iter.next().unwrap(), bits![0, 0]);
assert_eq!(iter.next().unwrap(), bits![0, 1, 0]);
assert!(iter.next().is_none());

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate, giving up after yielding n times. The nth yield contains the rest of the bit-slice. As with .split_mut(), the yielded bit-slices do not contain the matched bit.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::splitn_mut

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .splitn() has the same splitting logic, but each yielded bit-slice is immutable.
• .rsplitn_mut() iterates from the back of the bit-slice instead of the front.
• .split_mut() has the same splitting logic, but never times out.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 1, 0];
for group in bits.splitn_mut(2, |_pos, bit| *bit) {
  group.set(0, true);
}
assert_eq!(bits, bits![1, 0, 1, 1, 1, 0]);

pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate from the back edge, giving up after yielding n times. The nth yield contains the rest of the bit-slice. As with .split_mut(), the yielded bit-slices do not contain the matched bit.

Original

slice::rsplitn

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .rsplitn_mut() has the same splitting logic, but each yielded bit-slice is mutable.
• .splitn(): iterates from the front of the bit-slice instead of the back.
• .rsplit() has the same splitting logic, but never times out.

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1, 1, 0];
//                        ^
let mut iter = bits.rsplitn(2, |_pos, bit| *bit);

assert_eq!(iter.next().unwrap(), bits![0]);
assert_eq!(iter.next().unwrap(), bits![0, 0, 1]);
assert!(iter.next().is_none());

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, O, F>

where F: FnMut(usize, &bool) -> bool,

Iterates over mutable subslices separated by bits that match a predicate from the back edge, giving up after yielding n times. The nth yield contains the rest of the bit-slice. As with .split_mut(), the yielded bit-slices do not contain the matched bit.

Iterators do not require that each yielded item is destroyed before the next is produced. This means that each bit-slice yielded must be marked as aliased. If you are using this in a loop that does not collect multiple yielded subslices for the same scope, then you can remove the alias marking by calling the (unsafe) method .remove_alias() on the iterator.

Original

slice::rsplitn_mut

API Differences

The predicate function receives the index being tested as well as the bit value at that index. This allows the predicate to have more than one bit of information about the bit-slice being traversed.

Sibling Methods

• .rsplitn() has the same splitting logic, but each yielded bit-slice is immutable.
• .splitn_mut() iterates from the front of the bit-slice instead of the back.
• .rsplit_mut() has the same splitting logic, but never times out.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 0, 1, 0, 0, 0];
for group in bits.rsplitn_mut(2, |_idx, bit| *bit) {
  group.set(0, true);
}
assert_eq!(bits, bits![1, 0, 1, 0, 0, 1, 1, 0, 0]);
//                     ^ group 2         ^ group 1

pub fn contains<T2, O2>(&self, other: &BitSlice<T2, O2>) -> bool

where T2: BitStore, O2: BitOrder,

Tests if the bit-slice contains the given sequence anywhere within it.

This scans over self.windows(other.len()) until one of the windows matches. The search key does not need to share type parameters with the bit-slice being tested, as the comparison is bit-wise. However, sharing type parameters will accelerate the comparison.

Original

slice::contains

Examples

use bitvec::prelude::*;

let bits = bits![0, 0, 1, 0, 1, 1, 0, 0];
assert!( bits.contains(bits![0, 1, 1, 0]));
assert!(!bits.contains(bits![1, 0, 0, 1]));

pub fn starts_with<T2, O2>(&self, needle: &BitSlice<T2, O2>) -> bool

where T2: BitStore, O2: BitOrder,

Tests if the bit-slice begins with the given sequence.

The search key does not need to share type parameters with the bit-slice being tested, as the comparison is bit-wise. However, sharing type parameters will accelerate the comparison.

Original

slice::starts_with

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 1, 0];
assert!( bits.starts_with(bits![0, 1]));
assert!(!bits.starts_with(bits![1, 0]));

This always returns true if the needle is empty:

use bitvec::prelude::*;

let bits = bits![0, 1, 0];
let empty = bits![];
assert!(bits.starts_with(empty));
assert!(empty.starts_with(empty));

pub fn ends_with<T2, O2>(&self, needle: &BitSlice<T2, O2>) -> bool

where T2: BitStore, O2: BitOrder,

Tests if the bit-slice ends with the given sequence.

The search key does not need to share type parameters with the bit-slice being tested, as the comparison is bit-wise. However, sharing type parameters will accelerate the comparison.

Original

slice::ends_with

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 1, 0];
assert!( bits.ends_with(bits![1, 0]));
assert!(!bits.ends_with(bits![0, 1]));

This always returns true if the needle is empty:

use bitvec::prelude::*;

let bits = bits![0, 1, 0];
let empty = bits![];
assert!(bits.ends_with(empty));
assert!(empty.ends_with(empty));

pub fn strip_prefix<T2, O2>(&self, prefix: &BitSlice<T2, O2>) -> Option<&Self>

where T2: BitStore, O2: BitOrder,

Removes a prefix bit-slice, if present.

Like .starts_with(), the search key does not need to share type parameters with the bit-slice being stripped. If self.starts_with(suffix), then this returns Some(&self[prefix.len() ..]), otherwise it returns None.

Original

slice::strip_prefix

API Differences

BitSlice does not support pattern searches; instead, it permits self and prefix to differ in type parameters.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1, 0, 1, 1, 0];
assert_eq!(bits.strip_prefix(bits![0, 1]).unwrap(), bits[2 ..]);
assert_eq!(bits.strip_prefix(bits![0, 1, 0, 0,]).unwrap(), bits[4 ..]);
assert!(bits.strip_prefix(bits![1, 0]).is_none());

pub fn strip_suffix<T2, O2>(&self, suffix: &BitSlice<T2, O2>) -> Option<&Self>

where T2: BitStore, O2: BitOrder,

Removes a suffix bit-slice, if present.

Like .ends_with(), the search key does not need to share type parameters with the bit-slice being stripped. If self.ends_with(suffix), then this returns Some(&self[.. self.len() - suffix.len()]), otherwise it returns None.

Original

slice::strip_suffix

API Differences

BitSlice does not support pattern searches; instead, it permits self and suffix to differ in type parameters.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1, 0, 1, 1, 0];
assert_eq!(bits.strip_suffix(bits![1, 0]).unwrap(), bits[.. 7]);
assert_eq!(bits.strip_suffix(bits![0, 1, 1, 0]).unwrap(), bits[.. 5]);
assert!(bits.strip_suffix(bits![0, 1]).is_none());

pub fn rotate_left(&mut self, by: usize)

Rotates the contents of a bit-slice to the left (towards the zero index).

This essentially splits the bit-slice at by, then exchanges the two pieces. self[.. by] becomes the first section, and is then followed by self[.. by].

The implementation is batch-accelerated where possible. It should have a runtime complexity much lower than O(by).

Original

slice::rotate_left

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 0, 1, 0];
//      split occurs here ^
bits.rotate_left(2);
assert_eq!(bits, bits![1, 0, 1, 0, 0, 0]);

pub fn rotate_right(&mut self, by: usize)

Rotates the contents of a bit-slice to the right (away from the zero index).

This essentially splits the bit-slice at self.len() - by, then exchanges the two pieces. self[len - by ..] becomes the first section, and is then followed by self[.. len - by].

The implementation is batch-accelerated where possible. It should have a runtime complexity much lower than O(by).

Original

slice::rotate_right

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0, 1, 1, 1, 0];
//            split occurs here ^
bits.rotate_right(2);
assert_eq!(bits, bits![1, 0, 0, 0, 1, 1]);

pub fn fill(&mut self, value: bool)

Fills the bit-slice with a given bit.

This is a recent stabilization in the standard library. bitvec previously offered this behavior as the novel API .set_all(). That method name is now removed in favor of this standard-library analogue.

Original

slice::fill

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 5];
bits.fill(true);
assert_eq!(bits, bits![1; 5]);

pub fn fill_with<F>(&mut self, func: F)

where F: FnMut(usize) -> bool,

Fills the bit-slice with bits produced by a generator function.

Original

slice::fill_with

API Differences

The generator function receives the index of the bit being initialized as an argument.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 5];
bits.fill_with(|idx| idx % 2 == 0);
assert_eq!(bits, bits![1, 0, 1, 0, 1]);

pub fn clone_from_slice<T2, O2>(&mut self, src: &BitSlice<T2, O2>)

where T2: BitStore, O2: BitOrder,

👎Deprecated: use .clone_from_bitslice() instead

pub fn copy_from_slice(&mut self, src: &Self)

👎Deprecated: use .copy_from_bitslice() instead

pub fn copy_within<R>(&mut self, src: R, dest: usize)

where R: RangeExt<usize>,

Copies a span of bits to another location in the bit-slice.

src is the range of bit-indices in the bit-slice to copy, and dest is the starting index of the destination range. srcanddest .. dest + src.len()are permitted to overlap; the copy will automatically detect and manage this. However, bothsrcanddest .. dest + src.len()**must** fall within the bounds ofself`.

Original

slice::copy_within

Panics

This panics if either the source or destination range exceed self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0];
bits.copy_within(1 .. 5, 8);
//                        v  v  v  v
assert_eq!(bits, bits![1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0]);
//                                             ^  ^  ^  ^

pub fn swap_with_slice<T2, O2>(&mut self, other: &mut BitSlice<T2, O2>)

where T2: BitStore, O2: BitOrder,

👎Deprecated: use .swap_with_bitslice() instead

pub unsafe fn align_to<U>(&self) -> (&Self, &BitSlice<U, O>, &Self)

where U: BitStore,

Produces bit-slice view(s) with different underlying storage types.

This may have unexpected effects, and you cannot assume that before[idx] == after[idx]! Consult the tables in the manual for information about memory layouts.

Original

slice::align_to

Notes

Unlike the standard library documentation, this explicitly guarantees that the middle bit-slice will have maximal size. You may rely on this property.

Safety

You may not use this to cast away alias protections. Rust does not have support for higher-kinded types, so this cannot express the relation Outer<T> -> Outer<U> where Outer: BitStoreContainer, but memory safety does require that you respect this rule. Reälign integers to integers, Cells to Cells, and atomics to atomics, but do not cross these boundaries.

Examples

use bitvec::prelude::*;

let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
let bits = bytes.view_bits::<Lsb0>();
let (pfx, mid, sfx) = unsafe {
  bits.align_to::<u16>()
};
assert!(pfx.len() <= 8);
assert_eq!(mid.len(), 48);
assert!(sfx.len() <= 8);

pub unsafe fn align_to_mut<U>( &mut self ) -> (&mut Self, &mut BitSlice<U, O>, &mut Self)

where U: BitStore,

Produces bit-slice view(s) with different underlying storage types.

This may have unexpected effects, and you cannot assume that before[idx] == after[idx]! Consult the tables in the manual for information about memory layouts.

Original

slice::align_to_mut

Notes

Unlike the standard library documentation, this explicitly guarantees that the middle bit-slice will have maximal size. You may rely on this property.

Safety

You may not use this to cast away alias protections. Rust does not have support for higher-kinded types, so this cannot express the relation Outer<T> -> Outer<U> where Outer: BitStoreContainer, but memory safety does require that you respect this rule. Reälign integers to integers, Cells to Cells, and atomics to atomics, but do not cross these boundaries.

Examples

use bitvec::prelude::*;

let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
let bits = bytes.view_bits_mut::<Lsb0>();
let (pfx, mid, sfx) = unsafe {
  bits.align_to_mut::<u16>()
};
assert!(pfx.len() <= 8);
assert_eq!(mid.len(), 48);
assert!(sfx.len() <= 8);

pub fn to_vec(&self) -> BitVec<T::Unalias, O>

👎Deprecated: use .to_bitvec() instead

pub fn repeat(&self, n: usize) -> BitVec<T::Unalias, O>

Creates a bit-vector by repeating a bit-slice n times.

Original

slice::repeat

Panics

This method panics if self.len() * n exceeds the BitVec capacity.

Examples

use bitvec::prelude::*;

assert_eq!(bits![0, 1].repeat(3), bitvec![0, 1, 0, 1, 0, 1]);

This panics by exceeding bit-vector maximum capacity:

use bitvec::prelude::*;

bits![0, 1].repeat(BitSlice::<usize, Lsb0>::MAX_BITS);

pub fn as_bitptr(&self) -> BitPtr<Const, T, O>

Gets a raw pointer to the zeroth bit of the bit-slice.

Original

slice::as_ptr

API Differences

This is renamed in order to indicate that it is returning a bitvec structure, not a raw pointer.

pub fn as_mut_bitptr(&mut self) -> BitPtr<Mut, T, O>

Gets a raw, write-capable pointer to the zeroth bit of the bit-slice.

Original

slice::as_mut_ptr

API Differences

This is renamed in order to indicate that it is returning a bitvec structure, not a raw pointer.

pub fn as_bitptr_range(&self) -> BitPtrRange<Const, T, O>

Views the bit-slice as a half-open range of bit-pointers, to its first bit in the bit-slice and first bit beyond it.

Original

slice::as_ptr_range

API Differences

This is renamed to indicate that it returns a bitvec structure, rather than an ordinary Range.

Notes

BitSlice does define a .as_ptr_range(), which returns a Range<BitPtr>. BitPtrRange has additional capabilities that Range<*const T> and Range<BitPtr> do not.

pub fn as_mut_bitptr_range(&mut self) -> BitPtrRange<Mut, T, O>

Views the bit-slice as a half-open range of write-capable bit-pointers, to its first bit in the bit-slice and the first bit beyond it.

Original

slice::as_mut_ptr_range

API Differences

This is renamed to indicate that it returns a bitvec structure, rather than an ordinary Range.

Notes

BitSlice does define a [.as_mut_ptr_range()], which returns a Range<BitPtr>. BitPtrRange has additional capabilities that Range<*mut T> and Range<BitPtr> do not.

pub fn clone_from_bitslice<T2, O2>(&mut self, src: &BitSlice<T2, O2>)

where T2: BitStore, O2: BitOrder,

Copies the bits from src into self.

self and src must have the same length.

Performance

If src has the same type arguments as self, it will use the same implementation as .copy_from_bitslice(); if you know that this will always be the case, you should prefer to use that method directly.

Only .copy_from_bitslice() is able to perform acceleration; this method is always required to perform a bit-by-bit crawl over both bit-slices.

Original

slice::clone_from_slice

API Differences

This is renamed to reflect that it copies from another bit-slice, not from an element slice.

In order to support general usage, it allows src to have different type parameters than self, at the cost of performance optimizations.

Panics

This panics if the two bit-slices have different lengths.

Examples

use bitvec::prelude::*;

pub fn copy_from_bitslice(&mut self, src: &Self)

Copies all bits from src into self, using batched acceleration when possible.

self and src must have the same length.

Original

slice::copy_from_slice

Panics

This panics if the two bit-slices have different lengths.

Examples

use bitvec::prelude::*;

pub fn swap_with_bitslice<T2, O2>(&mut self, other: &mut BitSlice<T2, O2>)

where T2: BitStore, O2: BitOrder,

Swaps the contents of two bit-slices.

self and other must have the same length.

Original

slice::swap_with_slice

API Differences

This method is renamed, as it takes a bit-slice rather than an element slice.

Panics

This panics if the two bit-slices have different lengths.

Examples

use bitvec::prelude::*;

let mut one = [0xA5u8, 0x69];
let mut two = 0x1234u16;
let one_bits = one.view_bits_mut::<Msb0>();
let two_bits = two.view_bits_mut::<Lsb0>();

one_bits.swap_with_bitslice(two_bits);

assert_eq!(one, [0x2C, 0x48]);
assert_eq!(two, 0x96A5);

pub fn set(&mut self, index: usize, value: bool)

Writes a new value into a single bit.

This is the replacement for *slice[index] = value;, as bitvec is not able to express that under the current IndexMut API signature.

Parameters

• &mut self
• index: The bit-index to set. It must be in 0 .. self.len().
• value: The new bit-value to write into the bit at index.

Panics

This panics if index is out of bounds.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 1];
bits.set(0, true);
bits.set(1, false);

assert_eq!(bits, bits![1, 0]);

pub unsafe fn set_unchecked(&mut self, index: usize, value: bool)

Writes a new value into a single bit, without bounds checking.

Parameters

• &mut self
• index: The bit-index to set. It must be in 0 .. self.len().
• value: The new bit-value to write into the bit at index.

Safety

You must ensure that index is in the range 0 .. self.len().

This performs bit-pointer offset arithmetic without doing any bounds checks. If index is out of bounds, then this will issue an out-of-bounds access and will trigger memory unsafety.

Examples

use bitvec::prelude::*;

let mut data = 0u8;
let bits = &mut data.view_bits_mut::<Lsb0>()[.. 2];
assert_eq!(bits.len(), 2);
unsafe {
  bits.set_unchecked(3, true);
}
assert_eq!(data, 8);

pub fn replace(&mut self, index: usize, value: bool) -> bool

Writes a new value into a bit, and returns its previous value.

Panics

This panics if index is not less than self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut 0];
assert!(!bits.replace(0, true));
assert!(bits[0]);

pub unsafe fn replace_unchecked(&mut self, index: usize, value: bool) -> bool

Writes a new value into a bit, returning the previous value, without bounds checking.

Safety

index must be less than self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut 0, 0];
let old = unsafe {
  let a = &mut bits[.. 1];
  a.replace_unchecked(1, true)
};
assert!(!old);
assert!(bits[1]);

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

Swaps two bits in a bit-slice, without bounds checking.

See .swap() for documentation.

Safety

You must ensure that a and b are both in the range 0 .. self.len().

This method performs bit-pointer offset arithmetic without doing any bounds checks. If a or b are out of bounds, then this will issue an out-of-bounds access and will trigger memory unsafety.

pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&Self, &Self)

Splits a bit-slice at an index, without bounds checking.

See .split_at() for documentation.

Safety

You must ensure that mid is in the range 0 ..= self.len().

This method produces new bit-slice references. If mid is out of bounds, its behavior is library-level undefined. You must conservatively assume that an out-of-bounds split point produces compiler-level UB.

pub unsafe fn split_at_unchecked_mut( &mut self, mid: usize ) -> (&mut BitSlice<T::Alias, O>, &mut BitSlice<T::Alias, O>)

Splits a mutable bit-slice at an index, without bounds checking.

See .split_at_mut() for documentation.

Safety

You must ensure that mid is in the range 0 ..= self.len().

This method produces new bit-slice references. If mid is out of bounds, its behavior is library-level undefined. You must conservatively assume that an out-of-bounds split point produces compiler-level UB.

pub unsafe fn copy_within_unchecked<R>(&mut self, src: R, dest: usize)

where R: RangeExt<usize>,

Copies bits from one region of the bit-slice to another region of itself, without doing bounds checks.

The regions are allowed to overlap.

Parameters

• &mut self
• src: The range within self from which to copy.
• dst: The starting index within self at which to paste.

Effects

self[src] is copied to self[dest .. dest + src.len()]. The bits of self[src] are in an unspecified, but initialized, state.

Safety

src.end() and dest + src.len() must be entirely within bounds.

Examples

use bitvec::prelude::*;

let mut data = 0b1011_0000u8;
let bits = data.view_bits_mut::<Msb0>();

unsafe {
  bits.copy_within_unchecked(.. 4, 2);
}
assert_eq!(data, 0b1010_1100);

pub fn bit_domain(&self) -> BitDomain<'_, Const, T, O>

Partitions a bit-slice into maybe-contended and known-uncontended parts.

The documentation of BitDomain goes into this in more detail. In short, this produces a &BitSlice that is as large as possible without requiring alias protection, as well as any bits that were not able to be included in the unaliased bit-slice.

pub fn bit_domain_mut(&mut self) -> BitDomain<'_, Mut, T, O>

Partitions a mutable bit-slice into maybe-contended and known-uncontended parts.

The documentation of BitDomain goes into this in more detail. In short, this produces a &mut BitSlice that is as large as possible without requiring alias protection, as well as any bits that were not able to be included in the unaliased bit-slice.

pub fn domain(&self) -> Domain<'_, Const, T, O>

Views the underlying memory of a bit-slice, removing alias protections where possible.

The documentation of Domain goes into this in more detail. In short, this produces a &[T] slice with alias protections removed, covering all elements that self completely fills. Partially-used elements on either the front or back edge of the slice are returned separately.

pub fn domain_mut(&mut self) -> Domain<'_, Mut, T, O>

Views the underlying memory of a bit-slice, removing alias protections where possible.

The documentation of Domain goes into this in more detail. In short, this produces a &mut [T] slice with alias protections removed, covering all elements that self completely fills. Partially-used elements on the front or back edge of the slice are returned separately.

pub fn count_ones(&self) -> usize

Counts the number of bits set to 1 in the bit-slice contents.

Examples

use bitvec::prelude::*;

let bits = bits![1, 1, 0, 0];
assert_eq!(bits[.. 2].count_ones(), 2);
assert_eq!(bits[2 ..].count_ones(), 0);
assert_eq!(bits![].count_ones(), 0);

pub fn count_zeros(&self) -> usize

Counts the number of bits cleared to 0 in the bit-slice contents.

Examples

use bitvec::prelude::*;

let bits = bits![1, 1, 0, 0];
assert_eq!(bits[.. 2].count_zeros(), 0);
assert_eq!(bits[2 ..].count_zeros(), 2);
assert_eq!(bits![].count_zeros(), 0);

pub fn iter_ones(&self) -> IterOnes<'_, T, O>

Enumerates the index of each bit in a bit-slice set to 1.

This is a shorthand for a .enumerate().filter_map() iterator that selects the index of each true bit; however, its implementation is eligible for optimizations that the individual-bit iterator is not.

Specializations for the Lsb0 and Msb0 orderings allow processors with instructions that seek particular bits within an element to operate on whole elements, rather than on each bit individually.

Examples

This example uses .iter_ones(), a .filter_map() that finds the index of each set bit, and the known indices, in order to show that they have equivalent behavior.

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 0, 1, 0, 0, 0, 1];

let iter_ones = bits.iter_ones();
let known_indices = [1, 4, 8].iter().copied();
let filter = bits.iter()
  .by_vals()
  .enumerate()
  .filter_map(|(idx, bit)| if bit { Some(idx) } else { None });
let all = iter_ones.zip(known_indices).zip(filter);

for ((iter_one, known), filtered) in all {
  assert_eq!(iter_one, known);
  assert_eq!(known, filtered);
}

pub fn iter_zeros(&self) -> IterZeros<'_, T, O>

Enumerates the index of each bit in a bit-slice cleared to 0.

This is a shorthand for a .enumerate().filter_map() iterator that selects the index of each false bit; however, its implementation is eligible for optimizations that the individual-bit iterator is not.

Specializations for the Lsb0 and Msb0 orderings allow processors with instructions that seek particular bits within an element to operate on whole elements, rather than on each bit individually.

Examples

This example uses .iter_zeros(), a .filter_map() that finds the index of each cleared bit, and the known indices, in order to show that they have equivalent behavior.

use bitvec::prelude::*;

let bits = bits![1, 0, 1, 1, 0, 1, 1, 1, 0];

let iter_zeros = bits.iter_zeros();
let known_indices = [1, 4, 8].iter().copied();
let filter = bits.iter()
  .by_vals()
  .enumerate()
  .filter_map(|(idx, bit)| if !bit { Some(idx) } else { None });
let all = iter_zeros.zip(known_indices).zip(filter);

for ((iter_zero, known), filtered) in all {
  assert_eq!(iter_zero, known);
  assert_eq!(known, filtered);
}

pub fn first_one(&self) -> Option<usize>

Finds the index of the first bit in the bit-slice set to 1.

Returns None if there is no true bit in the bit-slice.

Examples

use bitvec::prelude::*;

assert!(bits![].first_one().is_none());
assert!(bits![0].first_one().is_none());
assert_eq!(bits![0, 1].first_one(), Some(1));

pub fn first_zero(&self) -> Option<usize>

Finds the index of the first bit in the bit-slice cleared to 0.

Returns None if there is no false bit in the bit-slice.

Examples

use bitvec::prelude::*;

assert!(bits![].first_zero().is_none());
assert!(bits![1].first_zero().is_none());
assert_eq!(bits![1, 0].first_zero(), Some(1));

pub fn last_one(&self) -> Option<usize>

Finds the index of the last bit in the bit-slice set to 1.

Returns None if there is no true bit in the bit-slice.

Examples

use bitvec::prelude::*;

assert!(bits![].last_one().is_none());
assert!(bits![0].last_one().is_none());
assert_eq!(bits![1, 0].last_one(), Some(0));

pub fn last_zero(&self) -> Option<usize>

Finds the index of the last bit in the bit-slice cleared to 0.

Returns None if there is no false bit in the bit-slice.

Examples

use bitvec::prelude::*;

assert!(bits![].last_zero().is_none());
assert!(bits![1].last_zero().is_none());
assert_eq!(bits![0, 1].last_zero(), Some(0));

pub fn leading_ones(&self) -> usize

Counts the number of bits from the start of the bit-slice to the first bit set to 0.

This returns 0 if the bit-slice is empty.

Examples

use bitvec::prelude::*;

assert_eq!(bits![].leading_ones(), 0);
assert_eq!(bits![0].leading_ones(), 0);
assert_eq!(bits![1, 0].leading_ones(), 1);

pub fn leading_zeros(&self) -> usize

Counts the number of bits from the start of the bit-slice to the first bit set to 1.

This returns 0 if the bit-slice is empty.

Examples

use bitvec::prelude::*;

assert_eq!(bits![].leading_zeros(), 0);
assert_eq!(bits![1].leading_zeros(), 0);
assert_eq!(bits![0, 1].leading_zeros(), 1);

pub fn trailing_ones(&self) -> usize

Counts the number of bits from the end of the bit-slice to the last bit set to 0.

This returns 0 if the bit-slice is empty.

Examples

use bitvec::prelude::*;

assert_eq!(bits![].trailing_ones(), 0);
assert_eq!(bits![0].trailing_ones(), 0);
assert_eq!(bits![0, 1].trailing_ones(), 1);

pub fn trailing_zeros(&self) -> usize

Counts the number of bits from the end of the bit-slice to the last bit set to 1.

This returns 0 if the bit-slice is empty.

Examples

use bitvec::prelude::*;

assert_eq!(bits![].trailing_zeros(), 0);
assert_eq!(bits![1].trailing_zeros(), 0);
assert_eq!(bits![1, 0].trailing_zeros(), 1);

pub fn any(&self) -> bool

Tests if there is at least one bit set to 1 in the bit-slice.

Returns false when self is empty.

Examples

use bitvec::prelude::*;

assert!(!bits![].any());
assert!(!bits![0].any());
assert!(bits![0, 1].any());

pub fn all(&self) -> bool

Tests if every bit is set to 1 in the bit-slice.

Returns true when self is empty.

Examples

use bitvec::prelude::*;

assert!( bits![].all());
assert!(!bits![0].all());
assert!( bits![1].all());

pub fn not_any(&self) -> bool

Tests if every bit is cleared to 0 in the bit-slice.

Returns true when self is empty.

Examples

use bitvec::prelude::*;

assert!( bits![].not_any());
assert!(!bits![1].not_any());
assert!( bits![0].not_any());

pub fn not_all(&self) -> bool

Tests if at least one bit is cleared to 0 in the bit-slice.

Returns false when self is empty.

Examples

use bitvec::prelude::*;

assert!(!bits![].not_all());
assert!(!bits![1].not_all());
assert!( bits![0].not_all());

pub fn some(&self) -> bool

Tests if at least one bit is set to 1, and at least one bit is cleared to 0, in the bit-slice.

Returns false when self is empty.

Examples

use bitvec::prelude::*;

assert!(!bits![].some());
assert!(!bits![0].some());
assert!(!bits![1].some());
assert!( bits![0, 1].some());

pub fn shift_left(&mut self, by: usize)

Shifts the contents of a bit-slice “left” (towards the zero-index), clearing the “right” bits to 0.

This is a strictly-worse analogue to taking bits = &bits[by ..]: it has to modify the entire memory region that bits governs, and destroys contained information. Unless the actual memory layout and contents of your bit-slice matters to your program, you should probably prefer to munch your way forward through a bit-slice handle.

Note also that the “left” here is semantic only, and does not necessarily correspond to a left-shift instruction applied to the underlying integer storage.

This has no effect when by is 0. When by is self.len(), the bit-slice is entirely cleared to 0.

Panics

This panics if by is not less than self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1];
// these bits are retained ^--------------------------^
bits.shift_left(2);
assert_eq!(bits, bits![1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0]);
// and move here       ^--------------------------^

let bits = bits![mut 1; 2];
bits.shift_left(2);
assert_eq!(bits, bits![0; 2]);

pub fn shift_right(&mut self, by: usize)

Shifts the contents of a bit-slice “right” (away from the zero-index), clearing the “left” bits to 0.

This is a strictly-worse analogue to taking `bits = &bits[.. bits.len()

• by]: it must modify the entire memory region that bits` governs, and destroys contained information. Unless the actual memory layout and contents of your bit-slice matters to your program, you should probably prefer to munch your way backward through a bit-slice handle.

Note also that the “right” here is semantic only, and does not necessarily correspond to a right-shift instruction applied to the underlying integer storage.

This has no effect when by is 0. When by is self.len(), the bit-slice is entirely cleared to 0.

Panics

This panics if by is not less than self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1];
// these bits stay   ^--------------------------^
bits.shift_right(2);
assert_eq!(bits, bits![0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1]);
// and move here             ^--------------------------^

let bits = bits![mut 1; 2];
bits.shift_right(2);
assert_eq!(bits, bits![0; 2]);

pub fn set_aliased(&self, index: usize, value: bool)

Writes a new value into a single bit, using alias-safe operations.

This is equivalent to .set(), except that it does not require an &mut reference, and allows bit-slices with alias-safe storage to share write permissions.

Parameters

• &self: This method only exists on bit-slices with alias-safe storage, and so does not require exclusive access.
• index: The bit index to set. It must be in 0 .. self.len().
• value: The new bit-value to write into the bit at index.

Panics

This panics if index is out of bounds.

Examples

use bitvec::prelude::*;
use core::cell::Cell;

let bits: &BitSlice<_, _> = bits![Cell<usize>, Lsb0; 0, 1];
bits.set_aliased(0, true);
bits.set_aliased(1, false);

assert_eq!(bits, bits![1, 0]);

pub unsafe fn set_aliased_unchecked(&self, index: usize, value: bool)

Writes a new value into a single bit, using alias-safe operations and without bounds checking.

This is equivalent to .set_unchecked(), except that it does not require an &mut reference, and allows bit-slices with alias-safe storage to share write permissions.

Parameters

• &self: This method only exists on bit-slices with alias-safe storage, and so does not require exclusive access.
• index: The bit index to set. It must be in 0 .. self.len().
• value: The new bit-value to write into the bit at index.

Safety

The caller must ensure that index is not out of bounds.

Examples

use bitvec::prelude::*;
use core::cell::Cell;

let data = Cell::new(0u8);
let bits = &data.view_bits::<Lsb0>()[.. 2];
unsafe {
  bits.set_aliased_unchecked(3, true);
}
assert_eq!(data.get(), 8);

pub const MAX_BITS: usize = 2_305_843_009_213_693_951usize

pub const MAX_ELTS: usize = BitSpan<Const, T, O>::REGION_MAX_ELTS

pub fn to_bitvec(&self) -> BitVec<T::Unalias, O>

Copies a bit-slice into an owned bit-vector.

Since the new vector is freshly owned, this gets marked as ::Unalias to remove any guards that may have been inserted by the bit-slice’s history.

It does not use the underlying memory type, so that a BitSlice<_, Cell<_>> will produce a BitVec<_, Cell<_>>.

Original

slice::to_vec

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 1];
let bv = bits.to_bitvec();
assert_eq!(bits, bv);

Trait Implementations

impl<T, O> AsMut<BitSlice<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn as_mut(&mut self) -> &mut BitSlice<T, O>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, O> AsRef<BitSlice<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn as_ref(&self) -> &BitSlice<T, O>

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, O> Binary for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O, Rhs> BitAnd<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitAndAssign<Rhs>,

type Output = BitBox<T, O>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<T, O> BitAndAssign<&BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitand_assign(&mut self, rhs: &BitBox<T, O>)

Performs the &= operation.

impl<T, O> BitAndAssign<BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitand_assign(&mut self, rhs: BitBox<T, O>)

Performs the &= operation.

impl<T, O, Rhs> BitAndAssign<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitAndAssign<Rhs>,

fn bitand_assign(&mut self, rhs: Rhs)

Performs the &= operation.

impl<T, O> BitField for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitField,

fn load_le<I>(&self) -> I

where I: Integral,

Little-Endian Integer Loading

fn load_be<I>(&self) -> I

where I: Integral,

Big-Endian Integer Loading

fn store_le<I>(&mut self, value: I)

where I: Integral,

Little-Endian Integer Storing

fn store_be<I>(&mut self, value: I)

where I: Integral,

Big-Endian Integer Storing

fn load<I>(&self) -> I

where I: Integral,

Integer Loading

fn store<I>(&mut self, value: I)

where I: Integral,

Integer Storing

impl<T, O, Rhs> BitOr<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitOrAssign<Rhs>,

type Output = BitBox<T, O>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<T, O> BitOrAssign<&BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitor_assign(&mut self, rhs: &BitBox<T, O>)

Performs the |= operation.

impl<T, O> BitOrAssign<BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitor_assign(&mut self, rhs: BitBox<T, O>)

Performs the |= operation.

impl<T, O, Rhs> BitOrAssign<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitOrAssign<Rhs>,

fn bitor_assign(&mut self, rhs: Rhs)

Performs the |= operation.

impl<T, O, Rhs> BitXor<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitXorAssign<Rhs>,

type Output = BitBox<T, O>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<T, O> BitXorAssign<&BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitxor_assign(&mut self, rhs: &BitBox<T, O>)

Performs the ^= operation.

impl<T, O> BitXorAssign<BitBox<T, O>> for BitSlice<T, O>

where T: BitStore, O: BitOrder,

fn bitxor_assign(&mut self, rhs: BitBox<T, O>)

Performs the ^= operation.

impl<T, O, Rhs> BitXorAssign<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: BitXorAssign<Rhs>,

fn bitxor_assign(&mut self, rhs: Rhs)

Performs the ^= operation.

impl<T, O> Borrow<BitSlice<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn borrow(&self) -> &BitSlice<T, O>

Immutably borrows from an owned value.

impl<T, O> BorrowMut<BitSlice<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn borrow_mut(&mut self) -> &mut BitSlice<T, O>

Mutably borrows from an owned value.

impl<T, O> Clone for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, O> Debug for BitBox<T, O>

where T: BitStore, O: BitOrder,

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

Formats the value using the given formatter.

impl<T, O> Default for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn default() -> Self

Returns the “default value” for a type.

impl<T, O> Deref for BitBox<T, O>

where T: BitStore, O: BitOrder,

type Target = BitSlice<T, O>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, O> DerefMut for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, T, O> Deserialize<'de> for BitBox<T, O>

where T: BitStore, O: BitOrder, Vec<T>: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, O> Display for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O> Drop for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, O> From<&BitSlice<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn from(slice: &BitSlice<T, O>) -> Self

Converts to this type from the input type.

impl<A, O> From<BitArray<A, O>> for BitBox<A::Store, O>

where A: BitViewSized, O: BitOrder,

fn from(array: BitArray<A, O>) -> Self

Converts to this type from the input type.

impl<T, O> From<BitBox<T, O>> for BitVec<T, O>

where T: BitStore, O: BitOrder,

fn from(boxed: BitBox<T, O>) -> Self

Converts to this type from the input type.

impl<T, O> From<BitBox<T, O>> for Box<[T]>

where T: BitStore, O: BitOrder,

fn from(bb: BitBox<T, O>) -> Self

Converts to this type from the input type.

impl<T, O> From<BitVec<T, O>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn from(bv: BitVec<T, O>) -> Self

Converts to this type from the input type.

impl<T, O> From<Box<T>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn from(elem: Box<T>) -> Self

Converts to this type from the input type.

impl<'a, T, O> From<Cow<'a, BitSlice<T, O>>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn from(cow: Cow<'a, BitSlice<T, O>>) -> Self

Converts to this type from the input type.

impl<T, O, I> FromIterator<I> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitVec<T, O>: FromIterator<I>,

fn from_iter<II>(iter: II) -> Self

where II: IntoIterator<Item = I>,

Creates a value from an iterator.

impl<T, O> Hash for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, O, Idx> Index<Idx> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: Index<Idx>,

type Output = <BitSlice<T, O> as Index<Idx>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, O, Idx> IndexMut<Idx> for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: IndexMut<Idx>,

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, O> IntoIterator for BitBox<T, O>

where T: BitStore, O: BitOrder,

Original

type IntoIter = IntoIter<T, O>

Which kind of iterator are we turning this into?

type Item = bool

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, O> LowerHex for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O> Not for BitBox<T, O>

where T: BitStore, O: BitOrder,

type Output = BitBox<T, O>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, O> Octal for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O> Ord for BitBox<T, O>

where T: BitStore, O: BitOrder,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn eq(&self, other: &BitBox<T2, O2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for &mut BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn eq(&self, other: &BitBox<T2, O2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<O1, O2, T1, T2> PartialEq<BitBox<T2, O2>> for BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn eq(&self, other: &BitBox<T2, O2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, O, Rhs> PartialEq<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, Rhs: ?Sized + PartialEq<BitSlice<T, O>>,

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for &'a mut BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<O1, O2, T1, T2> PartialOrd<BitBox<T2, O2>> for BitSlice<T1, O1>

where O1: BitOrder, O2: BitOrder, T1: BitStore, T2: BitStore,

fn partial_cmp(&self, other: &BitBox<T2, O2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, O, Rhs> PartialOrd<Rhs> for BitBox<T, O>

where T: BitStore, O: BitOrder, Rhs: ?Sized + PartialOrd<BitSlice<T, O>>,

fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, O> Pointer for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O> Serialize for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: Serialize,

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, O> TryFrom<Box<[T]>> for BitBox<T, O>

where T: BitStore, O: BitOrder,

type Error = Box<[T]>

The type returned in the event of a conversion error.

fn try_from(boxed: Box<[T]>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, O> UpperHex for BitBox<T, O>

where O: BitOrder, T: BitStore,

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

Formats the value using the given formatter.

impl<T, O> Eq for BitBox<T, O>

where T: BitStore, O: BitOrder,

impl<T, O> Send for BitBox<T, O>

where T: BitStore, O: BitOrder,

impl<T, O> Sync for BitBox<T, O>

where T: BitStore, O: BitOrder,

impl<T, O> Unpin for BitBox<T, O>

where T: BitStore, O: BitOrder,