Struct bitvec::boxed::BitBox[][src]

#[repr(transparent)]pub struct BitBox<O = Lsb0, T = usize> where
    O: BitOrder,
    T: BitStore
{ /* fields omitted */ }

A frozen heap-allocated buffer of individual bits.

This is essentially a BitVec that has frozen its allocation, and given up the ability to change size. It is analagous to Box<[bool]>, and is written to be as close as possible to drop-in replacable for it. This type contains almost no interesting behavior in its own right; it dereferences to BitSlice to manipulate its contents, and it converts to and from BitVec for allocation control.

If you know the length of your bit sequence at compile-time, and it is expressible within the limits of BitArray, you should prefer that type instead. Large BitArrays can be Boxed normally as desired.

Documentation

All APIs that mirror something in the standard library will have an Original section linking to the corresponding item. All APIs that have a different signature or behavior than the original will have an API Differences section explaining what has changed, and how to adapt your existing code to the change.

These sections look like this:

Original

Box<[T]>

API Differences

The buffer type Box<[bool]> has no type parameters. BitBox<O, T> has the same two type parameters as BitSlice<O, T>. Otherwise, BitBox is able to implement the full API surface of Box<[bool]>.

Behavior

Because BitBox is a fully-owned buffer, it is able to operate on its memory without concern for any other views that may alias. This enables it to specialize some BitSlice behavior to be faster or more efficient.

Type Parameters

This takes the same two type parameters, O: BitOrder and T: BitStore, as BitSlice.

Safety

Like BitSlice, BitBox is exactly equal in size to Box<[bool]>, and is also absolutely representation-incompatible with it. You must never attempt to type-cast between Box<[bool]> and BitBox in any way, nor attempt to modify the memory value of a BitBox handle. Doing so will cause allocator and memory errors in your program, likely inducing a panic.

Everything in the BitBox public API, even the unsafe parts, are guaranteed to have no more unsafety than their equivalent items in the standard library. All unsafe APIs will have documentation explicitly detailing what the API requires you to uphold in order for it to function safely and correctly. All safe APIs will do so themselves.

Performance

Iteration over the buffer is governed by the BitSlice characteristics on the type parameter. You are generally better off using larger types when your buffer is a data collection rather than a specific I/O protocol buffer.

Macro Construction

Heap allocation can only occur at runtime, but the bitbox! macro will construct an appropriate BitSlice buffer at compile-time, and at run-time, only copy the buffer into a heap allocation.

Implementations

impl<O, T> BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

pub fn new(x: &BitSlice<O, T>) -> Self[src]

👎 Deprecated since 0.18.0:

Prefer ::from_bitslice

Allocates memory on the heap and copies x into it.

This doesn’t actually allocate if x is zero-length.

Original

Box::new

API Differences

Box::<[T]>::new does not exist, because new cannot take unsized types by value. Instead, this takes a slice reference, and boxes the referent slice.

Examples

use bitvec::prelude::*;

let boxed = BitBox::new(bits![0; 5]);

pub fn pin(x: &BitSlice<O, T>) -> Pin<Self> where
    O: Unpin,
    T: Unpin
[src]

Constructs a new Pin<BitBox<O, T>>.

BitSlice is always Unpin, so this has no actual immobility effect.

Original

Box::pin

API Differences

As with ::new, this only exists on Box when T is not unsized. This takes a slice reference, and pins the referent slice.

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

Constructs a box from a raw pointer.

After calling this function, the raw pointer is owned by the resulting BitBox. Specifically, the Box destructor will free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by BitBox.

Original

Box::from_raw

Safety

This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.

Examples

Recreate a BitBox which was previously converted to a raw pointer using BitBox::into_raw:

use bitvec::prelude::*;

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

pub fn into_raw(b: Self) -> *mut BitSlice<O, T>[src]

Consumes the BitBox, returning a wrapped raw pointer.

The pointer will be properly aligned and non-null.

After calling this function, the caller is responsible for the memory previously managed by the BitBox. In particular, the caller should properly release the memory by converting the pointer back into a BitBox with the BitBox::from_raw function, allowing the BitBox destructor to perform the cleanup.

Note: this is an associated function, which means that you have to call it as BitBox::into_raw(b) instead of b.into_raw(). This is to match layout with the standard library’s Box API; there will never be a name conflict with BitSlice.

Original

Box::into_raw

Examples

Converting the raw pointer back into a BitBox with BitBox::from_raw for automatic cleanup:

use bitvec::prelude::*;

let b = BitBox::new(bits![Msb0, u32; 0; 32]);
let ptr = BitBox::into_raw(b);
let b = unsafe { BitBox::from_raw(ptr) };

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

Notable traits for &'a BitSlice<O, T>

impl<'a, O, T> Read for &'a BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitField
impl<'a, O, T> Write for &'a mut BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
where
    T: 'a, 
[src]

Consumes and leaks the BitBox, returning a mutable reference, &'a mut BitSlice<O, T>. Note that the memory region [T] must outlive the chosen lifetime 'a.

This function is mainly useful for bit regions that live for the remainder of the program’s life. Dropping the returned reference will cause a memory leak. If this is not acceptable, the reference should first be wrapped with the BitBox::from_raw function, producing a BitBox. This BitBox can then be dropped which will properly deallocate the memory.

Note: this is an associated function, which means that you have to call it as BitBox::leak(b) instead of b.leak(). This is to match layout with the standard library’s Box API; there will never be a name conflict with BitSlice.

Original

Box::leak

Examples

Simple usage:

use bitvec::prelude::*;

let b = bitbox![LocalBits, u32; 0; 32];
let static_ref: &'static mut BitSlice<LocalBits, u32> = BitBox::leak(b);
static_ref.set(0, true);
assert_eq!(static_ref.count_ones(), 1);

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

Notable traits for BitVec<O, T>

impl<O, T> Write for BitVec<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
[src]

Converts self into a vector without clones or allocation.

The resulting vector can be converted back into a box via BitVec<O, T>’s into_boxed_bitslice method.

Original

slice::into_vec

API Differences

Despite taking a Box<[T]> receiver, this function is written in an impl<T> [T] block.

Rust does not allow the text

impl<O, T> BitSlice<O, T> {
  fn into_bitvec(self: BitBox<O, T>);
}

to be written, and BitBox exists specifically because Box<BitSlice<>> cannot be written either, so this function must be implemented directly on BitBox rather than on BitSlice with a boxed receiver.

Examples

use bitvec::prelude::*;

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

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

impl<O, T> BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

Methods specific to BitBox<_, T>, and not present on Box<[T]>.

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

Clones a &BitSlice into a BitVec.

Original

<Box<T: Clone> as Clone>::clone

Effects

This performs a direct element-wise copy from the source slice to the newly-allocated buffer, then sets the box to have the same starting bit as the slice did. This allows for faster behavior.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 0, 1, 1, 0, 1, 1];
let bb = BitBox::from_bitslice(&bits[2 ..]);
assert_eq!(bb, bits[2 ..]);

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

Converts a Box<[T]> into a BitBox<O, T>` without copying its buffer.

Parameters

  • boxed: A boxed slice to view as bits.

Returns

A BitBox over the boxed buffer.

Panics

This panics if boxed is too long to convert into a BitBox. See BitSlice::MAX_ELTS.

Examples

use bitvec::prelude::*;

let boxed: Box<[u8]> = Box::new([0; 4]);
let bb = BitBox::<LocalBits, _>::from_boxed_slice(boxed);
assert_eq!(bb, bits![0; 32]);

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

Converts a Box<[T]> into a BitBox<O, T> without copying its buffer.

This method takes ownership of a memory buffer and enables it to be used as a bit-box. Because Box<[T]> can be longer than BitBoxes, this is a fallible method, and the original box will be returned if it cannot be converted.

Parameters

  • boxed: Some boxed slice of memory, to be viewed as bits.

Returns

If boxed is short enough to be viewed as a BitBox, then this returns a BitBox over the boxed buffer. If boxed is too long, then this returns boxed unmodified.

Examples

use bitvec::prelude::*;

let boxed: Box<[u8]> = Box::new([0; 4]);
let bb = BitBox::<LocalBits, _>::try_from_boxed_slice(boxed).unwrap();
assert_eq!(bb[..], bits![0; 32]);

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

Converts the slice back into an ordinary slice of memory elements.

This does not affect the slice’s buffer, only the handle used to control it.

Parameters

  • self

Returns

An ordinary boxed slice containing all of the bit-slice’s memory buffer.

Examples

use bitvec::prelude::*;

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

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

Notable traits for &'a BitSlice<O, T>

impl<'a, O, T> Read for &'a BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitField
impl<'a, O, T> Write for &'a mut BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
[src]

Views the buffer’s contents as a BitSlice.

This is equivalent to &bb[..].

Original

<Box<[T]> as AsRef<[T]>>::as_ref

Examples

use bitvec::prelude::*;

let bb = bitbox![0, 1, 1, 0];
let bits = bb.as_bitslice();

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

Notable traits for &'a BitSlice<O, T>

impl<'a, O, T> Read for &'a BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitField
impl<'a, O, T> Write for &'a mut BitSlice<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
[src]

Extracts a mutable bit-slice of the entire vector.

Equivalent to &mut bv[..].

Original

<Box<[T]> as AsMut<[T]>>::as_mut

Examples

use bitvec::prelude::*;

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

pub fn as_slice(&self) -> &[T][src]

Extracts an element slice containing the entire box.

Original

<Box<[T]> as AsRef<[T]>>::as_ref

Analogue

See as_bitslice for a &BitBox -> &BitSlice transform.

Examples

use bitvec::prelude::*;
use std::io::{self, Write};
let buffer = bitbox![Msb0, u8; 0, 1, 0, 1, 1, 0, 0, 0];
io::sink().write(buffer.as_slice()).unwrap();

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

Extracts a mutable slice of the entire box.

Original

<Box<[T]> as AsMut<[T]>>::as_mut

Analogue

See as_mut_bitslice for a &mut BitBox -> &mut BitSlice transform.

Examples

use bitvec::prelude::*;
use std::io::{self, Read};
let mut buffer = bitbox![Msb0, u8; 0; 24];
io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();

pub fn set_uninitialized(&mut self, value: bool)[src]

Sets the uninitialized bits of the vector to a fixed value.

This method modifies all bits in the allocated buffer that are outside the self.as_bitslice() view so that they have a consistent value. This can be used to zero the uninitialized memory so that when viewed as a raw memory slice, bits outside the live region have a predictable value.

Examples

use bitvec::prelude::*;

let mut bb = BitBox::new(&220u8.view_bits::<Lsb0>()[.. 4]);
assert_eq!(bb.count_ones(), 2);
assert_eq!(bb.as_slice(), &[220u8]);

bb.set_uninitialized(false);
assert_eq!(bb.as_slice(), &[12u8]);

bb.set_uninitialized(true);
assert_eq!(bb.as_slice(), &[!3u8]);

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

pub fn len(&self) -> usize[src]

Returns the number of bits in the slice.

Original

slice::len

Examples

use bitvec::prelude::*;

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

pub fn is_empty(&self) -> bool[src]

Returns true if the slice has a length of 0.

Original

slice::is_empty

Examples

use bitvec::prelude::*;

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

pub fn first(&self) -> Option<&bool>[src]

Returns the first bit of the slice, or None if it is empty.

Original

slice::first

Examples

use bitvec::prelude::*;

assert_eq!(Some(&true), bits![1, 0].first());
assert!(bits![].first().is_none());

pub fn first_mut(&mut self) -> Option<BitMut<'_, O, T>>[src]

Returns a mutable pointer to the first bit of the slice, or None if it is empty.

Original

slice::first_mut

API Differences

This crate cannot manifest &mut bool references, and must use the BitMut proxy type where &mut bool exists in the standard library API. The proxy value must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

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

pub fn split_first(&self) -> Option<(&bool, &Self)>[src]

Returns the first and all the rest of the bits of the slice, or None if it is empty.

Original

slice::split_first

Examples

use bitvec::prelude::*;

if let Some((first, rest)) = bits![1].split_first() {
  assert!(*first);
  assert!(rest.is_empty());
}

pub fn split_first_mut(
    &mut self
) -> Option<(BitMut<'_, O, T::Alias>, &mut BitSlice<O, T::Alias>)>
[src]

Returns the first and all the rest of the bits of the slice, or None if it is empty.

Original

slice::split_first_mut

API Differences

This crate cannot manifest &mut bool references, and must use the BitMut proxy type where &mut bool exists in the standard library API. The proxy value must be bound as mut in order to write through it.

Because the references are permitted to use the same memory address, they are marked as aliasing in order to satisfy Rust’s requirements about freedom from data races.

Examples

use bitvec::prelude::*;

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

pub fn split_last(&self) -> Option<(&bool, &Self)>[src]

Returns the last and all the rest of the bits of the slice, or None if it is empty.

Original

slice::split_last

Examples

use bitvec::prelude::*;

let bits = bits![1];
if let Some((last, rest)) = bits.split_last() {
  assert!(*last);
  assert!(rest.is_empty());
}

pub fn split_last_mut(
    &mut self
) -> Option<(BitMut<'_, O, T::Alias>, &mut BitSlice<O, T::Alias>)>
[src]

Returns the last and all the rest of the bits of the slice, or None if it is empty.

Original

slice::split_last_mut

API Differences

This crate cannot manifest &mut bool references, and must use the BitMut proxy type where &mut bool exists in the standard library API. The proxy value must be bound as mut in order to write through it.

Because the references are permitted to use the same memory address, they are marked as aliasing in order to satisfy Rust’s requirements about freedom from data races.

Examples

use bitvec::prelude::*;

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

if let Some((mut last, rest)) = bits.split_last_mut() {
  *last = true;
  *rest.get_mut(1).unwrap() = true;
}
assert_eq!(bits.count_ones(), 2);
assert!(bits![mut].split_last_mut().is_none());

pub fn last(&self) -> Option<&bool>[src]

Returns the last bit of the slice, or None if it is empty.

Original

slice::last

Examples

use bitvec::prelude::*;

assert_eq!(Some(&true), bits![0, 1].last());
assert!(bits![].last().is_none());

pub fn last_mut(&mut self) -> Option<BitMut<'_, O, T>>[src]

Returns a mutable pointer to the last bit of the slice, or None if it is empty.

Original

slice::last_mut

API Differences

This crate cannot manifest &mut bool references, and must use the BitMut proxy type where &mut bool exists in the standard library API. The proxy value must be bound as mut in order to write through it.

Examples

use bitvec::prelude::*;

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

pub fn get<'a, I>(&'a self, index: I) -> Option<I::Immut> where
    I: BitSliceIndex<'a, O, T>, 
[src]

Returns a reference to an element or subslice depending on the type of index.

  • If given a position, returns a reference to the element at that position or None if out of bounds.
  • If given a range, returns the subslice corresponding to that range, or None if out of bounds.

Original

slice::get

Examples

use bitvec::prelude::*;

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

assert_eq!(Some(&true), bits.get(1));
assert_eq!(Some(&bits[1 .. 3]), bits.get(1 .. 3));
assert!(bits.get(9).is_none());
assert!(bits.get(8 .. 10).is_none());

pub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::Mut> where
    I: BitSliceIndex<'a, O, T>, 
[src]

Returns a mutable reference to an element or subslice depending on the type of index (see get) or None if the index is out of bounds.

Original

slice::get_mut

API Differences

When I is usize, this returns BitMut instead of &mut bool.

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 2];
assert!(!bits.get(1).unwrap());
*bits.get_mut(1).unwrap() = true;
assert!(bits.get(1).unwrap());

pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Immut where
    I: BitSliceIndex<'a, O, T>, 
[src]

Returns a reference to an element or subslice, without doing bounds checking.

This is generally not recommended; use with caution!

Unlike the original slice function, calling this with an out-of-bounds index is not technically compile-time undefined behavior, as the references produced do not actually describe local memory. However, the use of an out-of-bounds index will eventually cause an out-of-bounds memory read, which is a runtime safety violation. For a safe alternative see get.

Original

slice::get_unchecked

Examples

use bitvec::prelude::*;

let bits = bits![0, 1];
unsafe {
  assert!(*bits.get_unchecked(1));
}

pub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::Mut where
    I: BitSliceIndex<'a, O, T>, 
[src]

Returns a mutable reference to the output at this location, without doing bounds checking.

This is generally not recommended; use with caution!

Unlike the original slice function, calling this with an out-of-bounds index is not technically compile-time undefined behavior, as the references produced do not actually describe local memory. However, the use of an out-of-bounds index will eventually cause an out-of-bounds memory write, which is a runtime safety violation. For a safe alternative see get_mut.

Original

slice::get_unchecked_mut

Examples

use bitvec::prelude::*;

let bits = bits![mut 0; 2];
unsafe {
  let mut bit = bits.get_unchecked_mut(1);
  *bit = true;
}
assert!(bits[1]);

pub fn as_ptr(&self) -> *const Self[src]

Returns a raw bit-slice pointer to the region.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

The caller must also ensure that the memory the pointer (non-transitively) points to is only written to if T allows shared mutation, using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

Modifying the container (such as BitVec) referenced by this slice may cause its buffer to be reällocated, which would also make any pointers to it invalid.

Original

slice::as_ptr

API Differences

This returns *const BitSlice, which is the equivalent of *const [T] instead of *const T. The pointer encoding used requires more than one CPU word of space to address a single bit, so there is no advantage to removing the length information from the encoded pointer value.

Notes

You cannot use any of the methods in the pointer fundamental type or the core::ptr module on the *_ BitSlice type. This pointer retains the bitvec-specific value encoding, and is incomprehensible by the Rust standard library.

The only thing you can do with this pointer is dereference it.

Examples

use bitvec::prelude::*;

let bits = bits![0, 1, 1, 0];
let bits_ptr = bits.as_ptr();

for i in 0 .. bits.len() {
  assert_eq!(bits[i], unsafe {
    (&*bits_ptr)[i]
  });
}

pub fn as_mut_ptr(&mut self) -> *mut Self[src]

Returns an unsafe mutable bit-slice pointer to the region.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container (such as BitVec) referenced by this slice may cause its buffer to be reällocated, which would also make any pointers to it invalid.

Original

slice::as_mut_ptr

API Differences

This returns *mut BitSlice, which is the equivalont of *mut [T] instead of *mut T. The pointer encoding used requires more than one CPU word of space to address a single bit, so there is no advantage to removing the length information from the encoded pointer value.

Notes

You cannot use any of the methods in the pointer fundamental type or the core::ptr module on the *_ BitSlice type. This pointer retains the bitvec-specific value encoding, and is incomprehensible by the Rust standard library.

Examples

use bitvec::prelude::*;

let bits = bits![mut Lsb0, u8; 0; 8];
let bits_ptr = bits.as_mut_ptr();

for i in 0 .. bits.len() {
  unsafe { &mut *bits_ptr }.set(i, i % 3 == 0);
}
assert_eq!(bits.as_slice()[0], 0b0100_1001);

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

Swaps two bits in the slice.

Original

slice::swap

Arguments

  • a: The index of the first bit
  • b: The index of the second bit

Panics

Panics if 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)[src]

Reverses the order of bits in the slice, in place.

Original

slice::reverse

Examples

use bitvec::prelude::*;

let mut data = 0b1_1001100u8;
let bits = data.view_bits_mut::<Msb0>();
bits[1 ..].reverse();
assert_eq!(data, 0b1_0011001);

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

Notable traits for Iter<'a, O, T>

impl<'a, O, T> Iterator for Iter<'a, O, T> where
    O: 'a + BitOrder,
    T: 'a + BitStore
type Item = <usize as BitSliceIndex<'a, O, T>>::Immut;
[src]

Returns an iterator over the slice.

Original

slice::iter

Examples

use bitvec::prelude::*;

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

assert_eq!(iterator.next(), Some(&false));
assert_eq!(iterator.next(), Some(&true));
assert_eq!(iterator.nth(5), Some(&true));
assert_eq!(iterator.next(), None);

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

Notable traits for IterMut<'a, O, T>

impl<'a, O, T> Iterator for IterMut<'a, O, T> where
    O: 'a + BitOrder,
    T: 'a + BitStore
type Item = <usize as BitSliceIndex<'a, O, T::Alias>>::Mut;
[src]

Returns an iterator that allows modifying each bit.

Original

slice::iter_mut

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0; 8];
for (idx, mut elem) in bits.iter_mut().enumerate() {
  *elem = idx % 3 == 0;
}
assert_eq!(bits.as_slice()[0], 0b100_100_10);

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

Notable traits for Windows<'a, O, T>

impl<'a, O, T> Iterator for Windows<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a BitSlice<O, T>;
[src]

Returns an iterator over all contiguous windows of length size. The windows overlap. If the slice is shorter than size, the iterator returns no values.

Original

slice::windows

Panics

Panics if size is 0.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[.. 6]);
assert_eq!(iter.next().unwrap(), &bits[1 .. 7]);
assert_eq!(iter.next().unwrap(), &bits[2 ..]);
assert!(iter.next().is_none());

If the slice is shorter than size:

use bitvec::prelude::*;

let bits = BitSlice::<LocalBits, usize>::empty();
let mut iter = bits.windows(1);
assert!(iter.next().is_none());

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

Notable traits for Chunks<'a, O, T>

impl<'a, O, T> Iterator for Chunks<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a BitSlice<O, T>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See chunks_exact for a variant of this iterator that returns chunks of always exactly chunk_size bits, and rchunks for the same iterator but starting at the end of the slice.

Original

slice::chunks

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[.. 3]);
assert_eq!(iter.next().unwrap(), &bits[3 .. 6]);
assert_eq!(iter.next().unwrap(), &bits[6 ..]);
assert!(iter.next().is_none());

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

Notable traits for ChunksMut<'a, O, T>

impl<'a, O, T> Iterator for ChunksMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a mut BitSlice<O, T::Alias>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See chunks_exact_mut for a variant of this iterator that returns chunks of always exactly chunk_size bits, and rchunks_mut for the same iterator but starting at the end of the slice.

Original

slice::chunks_mut

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut Lsb0, u8; 0; 8];
for (idx, chunk) in bits.chunks_mut(3).enumerate() {
  chunk.set(2 - idx, true);
}
assert_eq!(bits.as_slice()[0], 0b01_010_100);

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

Notable traits for ChunksExact<'a, O, T>

impl<'a, O, T> Iterator for ChunksExact<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a BitSlice<O, T>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 bits will be omitted and can be retrieved from the remainder function of the iterator.

Due to each chunk having exactly chunk_size bits, the compiler may optimize the resulting code better than in the case of chunks.

See chunks for a variant of this iterator that also returns the remainder as a smaller chunk, and rchunks_exact for the same iterator but starting at the end of the slice.

Original

slice::chunks_exact

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[.. 3]);
assert_eq!(iter.next().unwrap(), &bits[3 .. 6]);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &bits[6 ..]);

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

Notable traits for ChunksExactMut<'a, O, T>

impl<'a, O, T> Iterator for ChunksExactMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a mut BitSlice<O, T::Alias>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the beginning length of the slice, then the last up to chunk_size-1 bits will be omitted and can be retrieved from the into_remainder function of the iterator.

Due to each chunk having exactly chunk_size bits, the compiler may optimize the resulting code better than in the case of chunks_mut.

See chunks_mut for a variant of this iterator that also returns the remainder as a smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of the slice.

Original

slice::chunks_exact_mut

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut Lsb0, u8; 0; 8];
for (idx, chunk) in bits.chunks_exact_mut(3).enumerate() {
  chunk.set(idx, true);
}
assert_eq!(bits.as_slice()[0], 0b00_010_001);

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

Notable traits for RChunks<'a, O, T>

impl<'a, O, T> Iterator for RChunks<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a BitSlice<O, T>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the end of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See rchunks_exact for a variant of this iterator that returns chunks of always exactly chunk_size bits, and chunks for the same iterator but starting at the beginning of the slice.

Original

slice::rchunks

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

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

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

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

Notable traits for RChunksMut<'a, O, T>

impl<'a, O, T> Iterator for RChunksMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a mut BitSlice<O, T::Alias>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the end of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See rchunks_exact_mut for a variant of this iterator that returns chunks of always exactly chunk_size bits, and chunks_mut for the same iterator but starting at the beginning of the slice.

Original

slice::rchunks_mut

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut Lsb0, u8; 0; 8];
for (idx, chunk) in bits.rchunks_mut(3).enumerate() {
  chunk.set(2 - idx, true);
}
assert_eq!(bits.as_slice()[0], 0b100_010_01);

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

Notable traits for RChunksExact<'a, O, T>

impl<'a, O, T> Iterator for RChunksExact<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a BitSlice<O, T>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the end of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 bits will be omitted and can be retrieved from the remainder function of the iterator.

Due to each chunk having exactly chunk_size bits, the compiler can often optimize the resulting code better than in the case of chunks.

See rchunks for a variant of this iterator that also returns the remainder as a smaller chunk, and chunks_exact for the same iterator but starting at the beginning of the slice.

Original

slice::rchunks_exact

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[5 ..]);
assert_eq!(iter.next().unwrap(), &bits[2 .. 5]);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &bits[.. 2]);

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

Notable traits for RChunksExactMut<'a, O, T>

impl<'a, O, T> Iterator for RChunksExactMut<'a, O, T> where
    O: BitOrder,
    T: 'a + BitStore
type Item = &'a mut BitSlice<O, T::Alias>;
[src]

Returns an iterator over chunk_size bits of the slice at a time, starting at the end of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 bits will be omitted and can be retrieved from the into_remainder function of the iterator.

Due to each chunk having exactly chunk_size bits, the compiler can often optimize the resulting code better than in the case of chunks_mut.

See rchunks_mut for a variant of this iterator that also returns the remainder as a smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning of the slice.

Panics

Panics if chunk_size is 0.

Examples

use bitvec::prelude::*;

let bits = bits![mut Lsb0, u8; 0; 8];
for (idx, chunk) in bits.rchunks_exact_mut(3).enumerate() {
  chunk.set(idx, true);
}
assert_eq!(bits.as_slice()[0], 0b001_010_00);

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

Divides one slice into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Original

slice::split_at

Panics

Panics if mid > len.

Behavior

When mid is 0 or self.len(), then the left or right return values, respectively, are empty slices. Empty slice references produced by this method are specified to have the address information you would expect: a left empty slice has the same base address and start bit as self, and a right empty slice will have its address raised by self.len().

Examples

use bitvec::prelude::*;

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

let (left, right) = bits.split_at(0);
assert!(left.is_empty());
assert_eq!(right, bits);

let (left, right) = bits.split_at(2);
assert_eq!(left, &bits[.. 2]);
assert_eq!(right, &bits[2 ..]);

let (left, right) = bits.split_at(8);
assert_eq!(left, bits);
assert!(right.is_empty());

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

Divides one mutable slice into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Original

slice::split_at_mut

API Differences

Because the partition point mid is permitted to occur in the interior of a memory element T, this method is required to mark the returned slices as being to aliased memory. This marking ensures that writes to the covered memory use the appropriate synchronization behavior of your build to avoid data races – by default, this makes all writes atomic; on builds with the atomic feature disabled, this uses Cells and forbids the produced subslices from leaving the current thread.

See the BitStore documentation for more information.

Panics

Panics if mid > len.

Behavior

When mid is 0 or self.len(), then the left or right return values, respectively, are empty slices. Empty slice references produced by this method are specified to have the address information you would expect: a left empty slice has the same base address and start bit as self, and a right empty slice will have its address raised by self.len().

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0; 8];
// scoped to restrict the lifetime of the borrows
{
  let (left, right) = bits.split_at_mut(3);
  *left.get_mut(1).unwrap() = true;
  *right.get_mut(2).unwrap() = true;
}
assert_eq!(bits.as_slice()[0], 0b010_00100);

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

Notable traits for Split<'a, O, T, P>

impl<'a, O, T, P> Iterator for Split<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = &'a BitSlice<O, T>;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred. The matched bit is not contained in the subslices.

Original

slice::split

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[.. 1]);
assert_eq!(iter.next().unwrap(), &bits[2 .. 4]);
assert_eq!(iter.next().unwrap(), &bits[5 ..]);
assert!(iter.next().is_none());

If the first bit is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:

use bitvec::prelude::*;

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

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

If two matched bits are directly adjacent, an empty slice will be present between them:

use bitvec::prelude::*;

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

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

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

Notable traits for SplitMut<'a, O, T, P>

impl<'a, O, T, P> Iterator for SplitMut<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = &'a mut BitSlice<O, T::Alias>;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over mutable subslices separated by bits that match pred. The matched bit is not contained in the subslices.

Original

slice::split_mut

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0, 0, 1, 0, 0, 0, 1, 0];
for group in bits.split_mut(|_pos, bit| *bit) {
  *group.get_mut(0).unwrap() = true;
}
assert_eq!(bits.as_slice()[0], 0b101_100_11);

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

Notable traits for RSplit<'a, O, T, P>

impl<'a, O, T, P> Iterator for RSplit<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = &'a BitSlice<O, T>;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred, starting at the end of the slice and working backwards. The matched bit is not contained in the subslices.

Original

slice::rsplit

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

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

assert_eq!(iter.next().unwrap(), &bits[4 ..]);
assert_eq!(iter.next().unwrap(), &bits[.. 3]);
assert!(iter.next().is_none());

As with split(), if the first or last bit is matched, an empty slice will be the first (or last) item returned by the iterator.

use bitvec::prelude::*;

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

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

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

Notable traits for RSplitMut<'a, O, T, P>

impl<'a, O, T, P> Iterator for RSplitMut<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = &'a mut BitSlice<O, T::Alias>;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over mutable subslices separated by bits that match pred, starting at the end of the slice and working backwards. The matched bit is not contained in the subslices.

Original

slice::rsplit_mut

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0, 0, 1, 0, 0, 0, 1, 0];
for group in bits.rsplit_mut(|_pos, bit| *bit) {
  *group.get_mut(0).unwrap() = true;
}
assert_eq!(bits.as_slice()[0], 0b101_100_11);

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

Notable traits for SplitN<'a, O, T, P>

impl<'a, O, T, P> Iterator for SplitN<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = <Split<'a, O, T, P> as Iterator>::Item;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred, limited to returning at most n items. The matched bit is not contained in the subslices.

The last item returned, if any, will contain the remainder of the slice.

Original

slice::splitn

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![1, 0, 1, 0, 0, 1, 0, 1];
for group in bits.splitn(2, |pos, _bit| pos % 3 == 2) {
  println!("{}", group.len());
}
//  2
//  5

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

Notable traits for SplitNMut<'a, O, T, P>

impl<'a, O, T, P> Iterator for SplitNMut<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = <SplitMut<'a, O, T, P> as Iterator>::Item;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

The last item returned, if any, will contain the remainder of the slice.

Original

slice::splitn_mut

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0, 0, 1, 0, 0, 0, 1, 0];
for group in bits.splitn_mut(2, |_pos, bit| *bit) {
  *group.get_mut(0).unwrap() = true;
}
assert_eq!(bits.as_slice()[0], 0b101_100_10);

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

Notable traits for RSplitN<'a, O, T, P>

impl<'a, O, T, P> Iterator for RSplitN<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = <RSplit<'a, O, T, P> as Iterator>::Item;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred limited to returining at most n items. This starts at the end of the slice and works backwards. The matched bit is not contained in the subslices.

The last item returned, if any, will contain the remainder of the slice.

Original

slice::rsplitn

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![Msb0, u8; 1, 0, 1, 0, 0, 1, 0, 1];
for group in bits.rsplitn(2, |pos, _bit| pos % 3 == 2) {
  println!("{}", group.len());
}
//  2
//  5

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

Notable traits for RSplitNMut<'a, O, T, P>

impl<'a, O, T, P> Iterator for RSplitNMut<'a, O, T, P> where
    O: 'a + BitOrder,
    T: 'a + BitStore,
    P: FnMut(usize, &bool) -> bool
type Item = <RSplitMut<'a, O, T, P> as Iterator>::Item;
where
    F: FnMut(usize, &bool) -> bool
[src]

Returns an iterator over subslices separated by bits that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched bit is not contained in the subslices.

The last item returned, if any, will contain the remainder of the slice.

Original

slice::rsplitn_mut

API Differences

In order to allow more than one bit of information for the split decision, the predicate receives the index of each bit, as well as its value.

Examples

use bitvec::prelude::*;

let bits = bits![mut Msb0, u8; 0, 0, 1, 0, 0, 0, 1, 0];
for group in bits.rsplitn_mut(2, |_pos, bit| *bit) {
  *group.get_mut(0).unwrap() = true;
}
assert_eq!(bits.as_slice()[0], 0b101_000_11);

pub fn contains<O2, T2>(&self, x: &BitSlice<O2, T2>) -> bool where
    O2: BitOrder,
    T2: BitStore
[src]

Returns true if the slice contains a subslice that matches the given span.

Original

slice::contains

API Differences

This searches for a matching subslice (allowing different type parameters) rather than for a specific bit. Searching for a contained element with a given value is not as useful on a collection of bool.

Furthermore, BitSlice defines any and not_all, which are optimized searchers for any true or false bit, respectively, in a sequence.

Examples

use bitvec::prelude::*;

let data = 0b0101_1010u8;
let bits_msb = data.view_bits::<Msb0>();
let bits_lsb = data.view_bits::<Lsb0>();
assert!(bits_msb.contains(&bits_lsb[1 .. 5]));

This example uses a palindrome pattern to demonstrate that the slice being searched for does not need to have the same type parameters as the slice being searched.

pub fn starts_with<O2, T2>(&self, needle: &BitSlice<O2, T2>) -> bool where
    O2: BitOrder,
    T2: BitStore
[src]

Returns true if needle is a prefix of the slice.

Original

slice::starts_with

Examples

use bitvec::prelude::*;

let data = 0b0100_1011u8;
let haystack = data.view_bits::<Msb0>();
let needle = &data.view_bits::<Lsb0>()[2 .. 5];

assert!(haystack.starts_with(&needle[.. 2]));
assert!(haystack.starts_with(needle));
assert!(!haystack.starts_with(&haystack[2 .. 4]));

Always returns true if needle is an empty slice:

use bitvec::prelude::*;

let empty = BitSlice::<LocalBits, usize>::empty();
assert!(0u8.view_bits::<LocalBits>().starts_with(empty));
assert!(empty.starts_with(empty));

pub fn ends_with<O2, T2>(&self, needle: &BitSlice<O2, T2>) -> bool where
    O2: BitOrder,
    T2: BitStore
[src]

Returns true if needle is a suffix of the slice.

Original

slice::ends_with

Examples

use bitvec::prelude::*;

let data = 0b0100_1011u8;
let haystack = data.view_bits::<Lsb0>();
let needle = &data.view_bits::<Msb0>()[3 .. 6];

assert!(haystack.ends_with(&needle[1 ..]));
assert!(haystack.ends_with(needle));
assert!(!haystack.ends_with(&haystack[2 .. 4]));

Always returns true if needle is an empty slice:

use bitvec::prelude::*;

let empty = BitSlice::<LocalBits, usize>::empty();
assert!(0u8.view_bits::<LocalBits>().ends_with(empty));
assert!(empty.ends_with(empty));

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

Rotates the slice in-place such that the first by bits of the slice move to the end while the last self.len() - by bits move to the front. After calling rotate_left, the bit previously at index by will become the first bit in the slice.

Original

slice::rotate_left

Panics

This function will panic if by is greater than the length of the slice. Note that by == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

use bitvec::prelude::*;

let mut data = 0xF0u8;
let bits = data.view_bits_mut::<Msb0>();
bits.rotate_left(2);
assert_eq!(data, 0xC3);

Rotating a subslice:

use bitvec::prelude::*;

let mut data = 0xF0u8;
let bits = data.view_bits_mut::<Msb0>();
bits[1 .. 5].rotate_left(1);
assert_eq!(data, 0b1_1101_000);

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

Rotates the slice in-place such that the first self.len() - by bits of the slice move to the end while the last by bits move to the front. After calling rotate_right, the bit previously at index self.len() - by will become the first bit in the slice.

Original

slice::rotate_right

Panics

This function will panic if by is greater than the length of the slice. Note that by == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

use bitvec::prelude::*;

let mut data = 0xF0u8;
let bits = data.view_bits_mut::<Msb0>();
bits.rotate_right(2);
assert_eq!(data, 0x3C);

Rotate a subslice:

use bitvec::prelude::*;

let mut data = 0xF0u8;
let bits = data.view_bits_mut::<Msb0>();
bits[1 .. 5].rotate_right(1);
assert_eq!(data, 0b1_0111_000);

pub fn clone_from_bitslice<O2, T2>(&mut self, src: &BitSlice<O2, T2>) where
    O2: BitOrder,
    T2: BitStore
[src]

Copies the bits from src into self.

The length of src must be the same as self.

If you are attempting to write an integer value into a BitSlice, see the BitField::store trait function.

Implementation

This method is by necessity a bit-by-bit individual walk across both slices. Benchmarks indicate that where the slices share type parameters, this is very close in performance to an element-wise memcpy. You should use this method as the default transfer behavior, and only switch to [.copy_from_bitslice()] where you know that your performance is an issue and you can demonstrate that .copy_from_bitslice() is meaningfully better.

Where self and src are not of the same type parameters, crate benchmarks show a roughly halved runtime performance.

Original

slice::clone_from_slice

API Differences

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

Panics

This function will panic if the two slices have different lengths.

Examples

Cloning two bits from a slice into another:

use bitvec::prelude::*;

let mut data = 0u8;
let bits = data.view_bits_mut::<Msb0>();
let src = 0x0Fu16.view_bits::<Lsb0>();
bits[.. 2].clone_from_bitslice(&src[2 .. 4]);
assert_eq!(data, 0xC0);

Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use clone_from_bitslice on a single slice will result in a compile failure:

use bitvec::prelude::*;

let mut data = 3u8;
let bits = data.view_bits_mut::<Msb0>();
bits[.. 2].clone_from_bitslice(&bits[6 ..]);

To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

use bitvec::prelude::*;

let mut data = 3u8;
let bits = data.view_bits_mut::<Msb0>();
let (head, tail) = bits.split_at_mut(4);
head.clone_from_bitslice(tail);
assert_eq!(data, 0x33);

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

Copies all bits from src into self.

The length of src must be the same as self.

If you are attempting to write an integer value into a BitSlice, see the BitField::store trait function.

Implementation

This method attempts to use memcpy element-wise copy acceleration where possible. This will only occur when both src and self are exactly similar: in addition to having the same type parameters and length, they must begin at the same offset in an element.

Benchmarks do not indicate that memcpy element-wise copy is significantly faster than .clone_from_bitslice()’s bit-wise crawl. This implementation is retained so that you have the ability to observe performance characteristics on your own targets and choose as appropriate.

Original

slice::copy_from_slice

API Differences

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

Panics

This function will panic if the two slices have different lengths.

Examples

Copying two bits from a slice into another:

use bitvec::prelude::*;

let mut dst = bits![mut 0; 200];
let src = bits![1; 200];

assert!(dst.not_any());
dst.copy_from_bitslice(src);
assert!(dst.all());

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

Copies bits from one part of the slice to another part of itself.

src is the range within self to copy from. dest is the starting index of the range within self to copy to, which will have the same length as src. The two ranges may overlap. The ends of the two ranges must be less than or equal to self.len().

Original

slice::copy_within

Panics

This function will panic if either range exceeds the end of the slice, or if the end of src is before the start.

Examples

Copying four bytes within a slice:

use bitvec::prelude::*;

let mut data = 0x07u8;
let bits = data.view_bits_mut::<Msb0>();
bits.copy_within(5 .., 0);
assert_eq!(data, 0xE7);

pub fn swap_with_bitslice<O2, T2>(&mut self, other: &mut BitSlice<O2, T2>) where
    O2: BitOrder,
    T2: BitStore
[src]

Swaps all bits in self with those in other.

The length of other must be the same as self.

Original

slice::swap_with_slice

API Differences

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

Panics

This function will panic if the two 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 unsafe fn align_to<U>(&self) -> (&Self, &BitSlice<O, U>, &Self) where
    U: BitStore
[src]

Transmute the bitslice to a bitslice of another type, ensuring alignment of the types is maintained.

This method splits the bitslice into three distinct bitslices: prefix, correctly aligned middle bitslice of a new type, and the suffix bitslice. The method may make the middle bitslice the greatest length possible for a given type and input bitslice, but only your algorithm’s performance should depend on that, not its correctness. It is permissible for all of the input data to be returned as the prefix or suffix bitslice.

Original

slice::align_to

API Differences

Type U is required to have the same type family as type T. Whatever T is of the fundamental integers, atomics, or Cell wrappers, U must be a different width in the same family. Changing the type family with this method is unsound and strictly forbidden. Unfortunately, it cannot be guaranteed by this function, so you are required to abide by this limitation.

Safety

This method is essentially a transmute with respect to the elements in the returned middle bitslice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

use bitvec::prelude::*;

unsafe {
  let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
  let bits = bytes.view_bits::<LocalBits>();
  let (prefix, shorts, suffix) = bits.align_to::<u16>();
  match prefix.len() {
    0 => {
      assert_eq!(shorts, bits[.. 48]);
      assert_eq!(suffix, bits[48 ..]);
    },
    8 => {
      assert_eq!(prefix, bits[.. 8]);
      assert_eq!(shorts, bits[8 ..]);
    },
    _ => unreachable!("This case will not occur")
  }
}

pub unsafe fn align_to_mut<U>(
    &mut self
) -> (&mut Self, &mut BitSlice<O, U>, &mut Self) where
    U: BitStore
[src]

Transmute the bitslice to a bitslice of another type, ensuring alignment of the types is maintained.

This method splits the bitslice into three distinct bitslices: prefix, correctly aligned middle bitslice of a new type, and the suffix bitslice. The method may make the middle bitslice the greatest length possible for a given type and input bitslice, but only your algorithm’s performance should depend on that, not its correctness. It is permissible for all of the input data to be returned as the prefix or suffix bitslice.

Original

slice::align_to

API Differences

Type U is required to have the same type family as type T. Whatever T is of the fundamental integers, atomics, or Cell wrappers, U must be a different width in the same family. Changing the type family with this method is unsound and strictly forbidden. Unfortunately, it cannot be guaranteed by this function, so you are required to abide by this limitation.

Safety

This method is essentially a transmute with respect to the elements in the returned middle bitslice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

use bitvec::prelude::*;

unsafe {
  let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
  let bits = bytes.view_bits_mut::<LocalBits>();
  let (prefix, shorts, suffix) = bits.align_to_mut::<u16>();
  //  same access and behavior as in `align_to`
}

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

Notable traits for BitVec<O, T>

impl<O, T> Write for BitVec<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
[src]

Copies self into a new BitVec.

Original

slice::to_vec

Examples

use bitvec::prelude::*;

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

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

Notable traits for BitVec<O, T>

impl<O, T> Write for BitVec<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T::Alias>: BitField
where
    O: BitOrder,
    T: BitStore
[src]

Creates a vector by repeating a slice n times.

Original

slice::repeat

Panics

This function will panic if the capacity would overflow.

Examples

Basic usage:

use bitvec::prelude::*;

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

A panic upon overflow:

use bitvec::prelude::*;

// this will panic at runtime
bits![0, 1].repeat(BitSlice::<LocalBits, usize>::MAX_BITS);

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

Sets the bit value at the given position.

Parameters

  • &mut self
  • index: The bit index to set. It must be in the range 0 .. self.len().
  • value: The value to be set, true for 1 and false for 0.

Effects

If index is valid, then the bit to which it refers is set to value.

Panics

This method panics if index is outside the slice domain.

Examples

use bitvec::prelude::*;

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

assert!(!bits.get(7).unwrap());
bits.set(7, true);
assert!(bits.get(7).unwrap());
assert_eq!(data, 1);

This example panics when it attempts to set a bit that is out of bounds.

use bitvec::prelude::*;

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

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

Sets a bit at an index, without checking boundary conditions.

This is generally not recommended; use with caution! For a safe alternative, see set.

Parameters

  • &mut self
  • index: The bit index to set. It must be in the range 0 .. self.len(). It will not be checked.

Effects

The bit at index is set to value.

Safety

This method is not safe. It performs raw pointer arithmetic to seek from the start of the slice to the requested index, and set the bit there. It does not inspect the length of self, and it is free to perform out-of-bounds memory write access.

Use this method only when you have already performed the bounds check, and can guarantee that the call occurs with a safely in-bounds index.

Examples

This example uses a bit slice of length 2, and demonstrates out-of-bounds access to the last bit in the element.

use bitvec::prelude::*;

let mut data = 0u8;
let bits = &mut data.view_bits_mut::<Msb0>()[2 .. 4];

assert_eq!(bits.len(), 2);
unsafe {
  bits.set_unchecked(5, true);
}
assert_eq!(data, 1);

pub fn all(&self) -> bool[src]

Tests if all bits in the slice domain are set (logical ).

Truth Table

0 0 => 0
0 1 => 0
1 0 => 0
1 1 => 1

Parameters

  • &self

Returns

Whether all bits in the slice domain are set. The empty slice returns true.

Examples

use bitvec::prelude::*;

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

pub fn any(&self) -> bool[src]

Tests if any bit in the slice is set (logical ).

Truth Table

0 0 => 0
0 1 => 1
1 0 => 1
1 1 => 1

Parameters

  • &self

Returns

Whether any bit in the slice domain is set. The empty slice returns false.

Examples

use bitvec::prelude::*;

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

pub fn not_all(&self) -> bool[src]

Tests if any bit in the slice is unset (logical ¬∧).

Truth Table

0 0 => 1
0 1 => 1
1 0 => 1
1 1 => 0

Parameters

  • `&self

Returns

Whether any bit in the slice domain is unset.

Examples

use bitvec::prelude::*;

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

pub fn not_any(&self) -> bool[src]

Tests if all bits in the slice are unset (logical ¬∨).

Truth Table

0 0 => 1
0 1 => 0
1 0 => 0
1 1 => 0

Parameters

  • &self

Returns

Whether all bits in the slice domain are unset.

Examples

use bitvec::prelude::*;

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

pub fn some(&self) -> bool[src]

Tests whether the slice has some, but not all, bits set and some, but not all, bits unset.

This is false if either .all or .not_any are true.

Truth Table

0 0 => 0
0 1 => 1
1 0 => 1
1 1 => 0

Parameters

  • &self

Returns

Whether the slice domain has mixed content. The empty slice returns false.

Examples

use bitvec::prelude::*;

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

assert!(!bits[.. 2].some());
assert!(!bits[2 .. 4].some());
assert!(bits.some());

pub fn count_ones(&self) -> usize[src]

Returns the number of ones in the memory region backing self.

Parameters

  • &self

Returns

The number of high bits in the slice domain.

Examples

Basic usage:

use bitvec::prelude::*;

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

pub fn count_zeros(&self) -> usize[src]

Returns the number of zeros in the memory region backing self.

Parameters

  • &self

Returns

The number of low bits in the slice domain.

Examples

Basic usage:

use bitvec::prelude::*;

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

pub fn set_all(&mut self, value: bool)[src]

Sets all bits in the slice to a value.

Parameters

  • &mut self
  • value: The bit value to which all bits in the slice will be set.

Examples

use bitvec::prelude::*;

let mut src = 0u8;
let bits = src.view_bits_mut::<Msb0>();
bits[2 .. 6].set_all(true);
assert_eq!(bits.as_slice(), &[0b0011_1100]);
bits[3 .. 5].set_all(false);
assert_eq!(bits.as_slice(), &[0b0010_0100]);
bits[.. 1].set_all(true);
assert_eq!(bits.as_slice(), &[0b1010_0100]);

pub fn for_each<F>(&mut self, func: F) where
    F: FnMut(usize, bool) -> bool
[src]

Applies a function to each bit in the slice.

BitSlice cannot implement IndexMut, as it cannot manifest &mut bool references, and the BitMut proxy reference has an unavoidable overhead. This method bypasses both problems, by applying a function to each pair of index and value in the slice, without constructing a proxy reference.

Parameters

  • &mut self
  • func: A function which receives two arguments, index: usize and value: bool, and returns a bool.

Effects

For each index in the slice, the result of invoking func with the index number and current bit value is written into the slice.

Examples

use bitvec::prelude::*;

let mut data = 0u8;
let bits = data.view_bits_mut::<Msb0>();
bits.for_each(|idx, _bit| idx % 3 == 0);
assert_eq!(data, 0b100_100_10);

pub fn as_slice(&self) -> &[T][src]

Accesses the total backing storage of the BitSlice, as a slice of its elements.

This method produces a slice over all the memory elements it touches, using the current storage parameter. This is safe to do, as any events that would create an aliasing view into the elements covered by the returned slice will also have caused the slice to use its alias-aware type.

Parameters

  • &self

Returns

A view of the entire memory region this slice covers, including the edge elements.

Examples

use bitvec::prelude::*;

let data = 0x3Cu8;
let bits = &data.view_bits::<LocalBits>()[2 .. 6];

assert!(bits.all());
assert_eq!(bits.len(), 4);
assert_eq!(bits.as_slice(), &[0x3Cu8]);

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

Views the wholly-filled elements of the BitSlice.

This will not include partially-owned edge elements, as they may be aliased by other handles. To gain access to all elements that the BitSlice region covers, use one of the following:

  • .as_slice produces a shared slice over all elements, marked aliased as appropriate.
  • .domain produces a view describing each component of the region, marking only the contended edges as aliased and the uncontended interior as unaliased.

Parameters

  • &self

Returns

A slice of all the wholly-filled elements in the BitSlice backing storage.

Examples

use bitvec::prelude::*;

let data = [1u8, 66];
let bits = data.view_bits::<Msb0>();

let accum = bits
  .as_raw_slice()
  .iter()
  .copied()
  .map(u8::count_ones)
  .sum::<u32>();
assert_eq!(accum, 3);

pub fn as_raw_slice_mut(&mut self) -> &mut [T::Mem][src]

Views the wholly-filled elements of the BitSlice.

This will not include partially-owned edge elements, as they may be aliased by other handles. To gain access to all elements that the BitSlice region covers, use one of the following:

  • .as_aliased_slice produces a shared slice over all elements, marked as aliased to allow for the possibliity of mutation.
  • .domain_mut produces a view describing each component of the region, marking only the contended edges as aliased and the uncontended interior as unaliased.

Parameters

  • &mut self

Returns

A mutable slice of all the wholly-filled elements in the BitSlice backing storage.

Examples

use bitvec::prelude::*;

let mut data = [1u8, 64];
let bits = data.view_bits_mut::<Msb0>();
for elt in bits.as_raw_slice_mut() {
  *elt |= 2;
}
assert_eq!(&[3, 66], bits.as_slice());

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

Splits the slice into the logical components of its memory domain.

This produces a set of read-only subslices, marking as much as possible as affirmatively lacking any write-capable view (T::NoAlias). The unaliased view is able to safely perform unsynchronized reads from memory without causing undefined behavior, as the type system is able to statically prove that no other write-capable views exist.

Parameters

  • &self

Returns

A BitDomain structure representing the logical components of the memory region.

Safety Exception

The following snippet describes a means of constructing a T::NoAlias view into memory that is, in fact, aliased:

use bitvec::prelude::*;
use core::sync::atomic::AtomicU8;
type Bs<T> = BitSlice<LocalBits, T>;

let data = [AtomicU8::new(0), AtomicU8::new(0), AtomicU8::new(0)];
let bits: &Bs<AtomicU8> = data.view_bits::<LocalBits>();
let subslice: &Bs<AtomicU8> = &bits[4 .. 20];

let (_, noalias, _): (_, &Bs<u8>, _) =
  subslice.bit_domain().region().unwrap();

The noalias reference, which has memory type u8, assumes that it can act as an &u8 reference: unsynchronized loads are permitted, as no handle exists which is capable of modifying the middle bit of data. This means that LLVM is permitted to issue loads from memory wherever it wants in the block during which noalias is live, as all loads are equivalent.

Use of the bits or subslice handles, which are still live for the lifetime of noalias, to issue .set_aliased calls into the middle element introduce undefined behavior. bitvec permits safe code to introduce this undefined behavior solely because it requires deliberate opt-in – you must start from atomic data; this cannot occur when data is non-atomic – and use of the shared-mutation facility simultaneously with the unaliasing view.

The .set_aliased method is speculative, and will be marked as unsafe or removed at any suspicion that its presence in the library has any costs.

Examples

This method can be used to accelerate reads from a slice that is marked as aliased.

use bitvec::prelude::*;
type Bs<T> = BitSlice<LocalBits, T>;

let bits = bits![mut LocalBits, u8; 0; 24];
let (a, b): (
  &mut Bs<<u8 as BitStore>::Alias>,
  &mut Bs<<u8 as BitStore>::Alias>,
) = bits.split_at_mut(4);
let (partial, full, _): (
  &Bs<<u8 as BitStore>::Alias>,
  &Bs<<u8 as BitStore>::Mem>,
  _,
) = b.bit_domain().region().unwrap();
read_from(partial); // uses alias-aware reads
read_from(full); // uses ordinary reads

pub fn bit_domain_mut(&mut self) -> BitDomainMut<'_, O, T>[src]

Splits the slice into the logical components of its memory domain.

This produces a set of mutable subslices, marking as much as possible as affirmatively lacking any other view (T::Mem). The bare view is able to safely perform unsynchronized reads from and writes to memory without causing undefined behavior, as the type system is able to statically prove that no other views exist.

Why This Is More Sound Than .bit_domain

The &mut exclusion rule makes it impossible to construct two references over the same memory where one of them is marked &mut. This makes it impossible to hold a live reference to memory separately from any references produced from this method. For the duration of all references produced by this method, all ancestor references used to reach this method call are either suspended or dead, and the compiler will not allow you to use them.

As such, this method cannot introduce undefined behavior where a reference incorrectly believes that the referent memory region is immutable.

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

Notable traits for Domain<'a, T>

impl<'a, T> Iterator for Domain<'a, T> where
    T: 'a + BitStore
type Item = T::Mem;
[src]

Splits the slice into immutable references to its underlying memory components.

Unlike .bit_domain and .bit_domain_mut, this does not return smaller BitSlice handles but rather appropriately-marked references to the underlying memory elements.

The aliased references allow mutation of these elements. You are required to not use mutating methods on these references at all. This function is not marked unsafe, but this is a contract you must uphold. Use .domain_mut to modify the underlying elements.

It is not currently possible to forbid mutation through these references. This may change in the future.

Safety Exception

As with .bit_domain, this produces unsynchronized immutable references over the fully-populated interior elements. If this view is constructed from a BitSlice handle over atomic memory, then it will remove the atomic access behavior for the interior elements. This by itself is safe, as long as no contemporaneous atomic writes to that memory can occur. You must not retain and use an atomic reference to the memory region marked as NoAlias for the duration of this view’s existence.

Parameters

  • &self

Returns

A read-only descriptor of the memory elements backing *self.

pub fn domain_mut(&mut self) -> DomainMut<'_, T>[src]

Splits the slice into mutable references to its underlying memory elements.

Like .domain, this returns appropriately-marked references to the underlying memory elements. These references are all writable.

The aliased edge references permit modifying memory beyond their bit marker. You are required to only mutate the region of these edge elements that you currently govern. This function is not marked unsafe, but this is a contract you must uphold.

It is not currently possible to forbid out-of-bounds mutation through these references. This may change in the future.

Parameters

  • &mut self

Returns

A descriptor of the memory elements underneath *self, permitting mutation.

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

Splits a slice at some mid-point, without checking boundary conditions.

This is generally not recommended; use with caution! For a safe alternative, see split_at.

Parameters

  • &self
  • mid: The index at which to split the slice. This must be in the range 0 .. self.len().

Returns

  • .0: &self[.. mid]
  • .1: &self[mid ..]

Safety

This function is not safe. It performs raw pointer arithmetic to construct two new references. If mid is out of bounds, then the first slice will be too large, and the second will be catastrophically incorrect. As both are references to invalid memory, they are undefined to construct, and may not ever be used.

Examples

use bitvec::prelude::*;

let data = 0x0180u16;
let bits = data.view_bits::<Msb0>();

let (one, two) = unsafe { bits.split_at_unchecked(8) };
assert!(one[7]);
assert!(two[0]);

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

Splits a mutable slice at some mid-point, without checking boundary conditions.

This is generally not recommended; use with caution! For a safe alternative, see split_at_mut.

Parameters

  • &mut self
  • mid: The index at which to split the slice. This must be in the range 0 .. self.len().

Returns

  • .0: &mut self[.. mid]
  • .1: &mut self[mid ..]

Safety

This function is not safe. It performs raw pointer arithmetic to construct two new references. If mid is out of bounds, then the first slice will be too large, and the second will be catastrophically incorrect. As both are references to invalid memory, they are undefined to construct, and may not ever be used.

Examples

use bitvec::prelude::*;

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

let (one, two) = unsafe { bits.split_at_unchecked_mut(8) };
one.set(7, true);
two.set(0, true);
assert_eq!(data, 0x0180u16);

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

Swaps the bits at two indices without checking boundary conditions.

This is generally not recommended; use with caution! For a safe alternative, see swap.

Parameters

  • &mut self
  • a: One index to swap.
  • b: The other index to swap.

Effects

The bit at index a is written into index b, and the bit at index b is written into a.

Safety

Both a and b must be less than self.len(). Indices greater than the length will cause out-of-bounds memory access, which can lead to memory unsafety and a program crash.

Examples

use bitvec::prelude::*;

let mut data = 8u8;
let bits = data.view_bits_mut::<Msb0>();

unsafe { bits.swap_unchecked(0, 4); }

assert_eq!(data, 128);

pub unsafe fn copy_unchecked(&mut self, from: usize, to: usize)[src]

Copies a bit from one index to another without checking boundary conditions.

Parameters

  • &mut self
  • from: The index whose bit is to be copied
  • to: The index into which the copied bit is written.

Effects

The bit at from is written into to.

Safety

Both from and to must be less than self.len(), in order for self to legally read from and write to them, respectively.

If self had been split from a larger slice, reading from from or writing to to may not necessarily cause a memory-safety violation in the Rust model, due to the aliasing system bitvec employs. However, writing outside the bounds of a slice reference is always a logical error, as it causes changes observable by another reference handle.

Examples

use bitvec::prelude::*;

let mut data = 1u8;
let bits = data.view_bits_mut::<Lsb0>();

unsafe { bits.copy_unchecked(0, 2) };

assert_eq!(data, 5);

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

Copies bits from one part of the slice to another part of itself.

src is the range within self to copy from. dest is the starting index of the range within self to copy to, which will have the same length as src. The two ranges may overlap. The ends of the two ranges must be less than or equal to self.len().

Effects

self[src] is copied to self[dest .. dest + src.end() - src.start()].

Panics

This function will panic if either range exceeds the end of the slice, or if the end of src is before the start.

Safety

Both the src range and the target range dest .. dest + src.len() must not exceed the self.len() slice range.

Examples

use bitvec::prelude::*;

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

unsafe { bits.copy_within_unchecked(5 .., 0); }

assert_eq!(data, 0xE7);

pub fn offset_from(&self, other: &Self) -> isize[src]

Produces the absolute offset in bits between two slice heads.

While this method is sound for any two arbitrary bit slices, the answer it produces is meaningful only when one argument is a strict subslice of the other. If the two slices are created from different buffers entirely, a comparison is undefined; if the two slices are disjoint regions of the same buffer, then the semantically correct distance is between the tail of the lower and the head of the upper, which this does not measure.

Visual Description

Consider the following sequence of bits:

[ 0 1 2 3 4 5 6 7 8 9 a b ]
  |       ^^^^^^^       |
  ^^^^^^^^^^^^^^^^^^^^^^^

It does not matter whether there are bits between the tail of the smaller and the larger slices. The offset is computed from the bit distance between the two heads.

Behavior

This function computes the semantic distance between the heads, rather than the *electrical. It does not take into account the BitOrder implementation of the slice. See the [::electrical_distance] method for that comparison.

Safety and Soundness

One of self or other must contain the other for this comparison to be meaningful.

Parameters

  • &self
  • other: Another bit slice. This must be either a strict subregion or a strict superregion of self.

Returns

The distance in (semantic) bits betwen the heads of each region. The value is positive when other is higher in the address space than self, and negative when other is lower in the address space than self.

[::electrical_distance]: #method.electrical_comparison

pub fn electrical_distance(&self, other: &Self) -> isize[src]

Computes the electrical distance between the heads of two slices.

This method uses the slices’ BitOrder implementation to compute the bit position of their heads, then computes the shift distance, in bits, between them.

This computation presumes that the bits are counted in the same direction as are bytes in the abstract memory map.

Parameters

  • &self
  • other: Another bit slice. This must be either a strict subregion or a strict superregion of self.

Returns

The electrical bit distance between the heads of self and other.

pub fn split_at_aliased_mut(&mut self, mid: usize) -> (&mut Self, &mut Self)[src]

Splits a mutable slice at some mid-point.

This method has the same behavior as split_at_mut, except that it does not apply an aliasing marker to the partitioned subslices.

Safety

Because this method is defined only on BitSlices whose T type is alias-safe, the subslices do not need to be additionally marked.

pub const MAX_BITS: usize[src]

pub const MAX_ELTS: usize[src]

Trait Implementations

impl<O, T> AsMut<BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> AsRef<BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Binary for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T, Rhs> BitAnd<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitAndAssign<Rhs>, 
[src]

type Output = Self

The resulting type after applying the & operator.

impl<O, T, Rhs> BitAndAssign<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitAndAssign<Rhs>, 
[src]

impl<O, T> BitField for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitField
[src]

impl<O, T, Rhs> BitOr<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitOrAssign<Rhs>, 
[src]

type Output = Self

The resulting type after applying the | operator.

impl<O, T, Rhs> BitOrAssign<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitOrAssign<Rhs>, 
[src]

impl<O, T, Rhs> BitXor<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitXorAssign<Rhs>, 
[src]

type Output = Self

The resulting type after applying the ^ operator.

impl<O, T, Rhs> BitXorAssign<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: BitXorAssign<Rhs>, 
[src]

impl<O, T> Borrow<BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> BorrowMut<BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Clone for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Debug for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Default for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Deref for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

type Target = BitSlice<O, T>

The resulting type after dereferencing.

impl<O, T> DerefMut for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<'de, O, T> Deserialize<'de> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    T::Mem: Deserialize<'de>, 
[src]

impl<O, T> Display for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Drop for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Eq for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<'a, O, T> From<&'a BitSlice<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> From<BitBox<O, T>> for BitVec<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> From<BitVec<O, T>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Hash for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T, Idx> Index<Idx> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: Index<Idx>, 
[src]

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

The returned type after indexing.

impl<O, T, Idx> IndexMut<Idx> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    BitSlice<O, T>: IndexMut<Idx>, 
[src]

impl<O, T> Into<Box<[T], Global>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> LowerHex for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Not for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

type Output = Self

The resulting type after applying the ! operator.

impl<O, T> Octal for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Ord for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore
[src]

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore
[src]

impl<O1, O2, T1, T2> PartialEq<BitBox<O2, T2>> for &mut BitSlice<O1, T1> where
    O1: BitOrder,
    O2: BitOrder,
    T1: BitStore,
    T2: BitStore
[src]

impl<O, T, Rhs: ?Sized> PartialEq<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    Rhs: PartialEq<BitSlice<O, T>>, 
[src]

impl<O, T> PartialOrd<BitBox<O, T>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T, Rhs: ?Sized> PartialOrd<Rhs> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    Rhs: PartialOrd<BitSlice<O, T>>, 
[src]

impl<O, T> Pointer for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Send for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> Serialize for BitBox<O, T> where
    O: BitOrder,
    T: BitStore,
    T::Mem: Serialize
[src]

impl<O, T> Sync for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> TryFrom<Box<[T], Global>> for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

type Error = Box<[T]>

The type returned in the event of a conversion error.

impl<O, T> Unpin for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

impl<O, T> UpperHex for BitBox<O, T> where
    O: BitOrder,
    T: BitStore
[src]

Auto Trait Implementations

impl<O, T> RefUnwindSafe for BitBox<O, T> where
    O: RefUnwindSafe,
    T: RefUnwindSafe

impl<O, T> UnwindSafe for BitBox<O, T> where
    O: RefUnwindSafe,
    T: RefUnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Conv for T[src]

impl<T> Conv for T[src]

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T> FmtForward for T[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Pipe for T where
    T: ?Sized
[src]

impl<T> Pipe for T[src]

impl<T> PipeAsRef for T[src]

impl<T> PipeBorrow for T[src]

impl<T> PipeDeref for T[src]

impl<T> PipeRef for T[src]

impl<T> Tap for T[src]

impl<T> Tap for T[src]

impl<T, U> TapAsRef<U> for T where
    U: ?Sized
[src]

impl<T, U> TapBorrow<U> for T where
    U: ?Sized
[src]

impl<T> TapDeref for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T> TryConv for T[src]

impl<T> TryConv for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.