Struct BitVec

pub struct BitVec<B = Vec<usize>> { /* private fields */ }

A bit vector.

Implementations

impl<B> BitVec<B>

pub fn len(&self) -> usize

Returns the number of bits in the bit vector.

This method is equivalent to BitLength::len, but it is provided to reduce ambiguity in method resolution.

pub unsafe fn from_raw_parts(bits: B, len: usize) -> Self

Safety

len must be between 0 (included) the number of bits in bits (included).

pub fn into_raw_parts(self) -> (B, usize)

pub unsafe fn map<B2>(self, f: impl FnOnce(B) -> B2) -> BitVec<B2>

Modify the bit vector in place.

Safety

This is unsafe because it’s the caller’s responsibility to ensure that that the length is compatible with the modified bits.

impl<B: AsRef<[usize]>> BitVec<B>

pub fn to_owned(&self) -> BitVec

Returns an owned copy of the bit vector.

pub fn get(&self, index: usize) -> bool

Returns true if the bit of given index is set.

pub unsafe fn get_unchecked(&self, index: usize) -> bool

Returns true if the bit of given index is set, without bound checks.

Safety

index must be between 0 (included) and BitVec::len (excluded).

impl<B: AsRef<[usize]> + AsMut<[usize]>> BitVec<B>

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

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

Safety

index must be between 0 (included) and BitVec::len (excluded).

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

Sets all bits to the given value.

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

Sets all bits to the given value using a parallel implementation.

pub fn reset(&mut self)

Sets all bits to zero.

pub fn par_reset(&mut self)

Sets all bits to zero using a parallel implementation.

pub fn flip(&mut self)

Flip all bits.

pub fn par_flip(&mut self)

Flip all bits using a parallel implementation.

pub fn par_count_ones(&self) -> usize

A parallel version of BitVec::count_ones.

impl BitVec<Vec<usize>>

pub fn new(len: usize) -> Self

Creates a new bit vector of length len initialized to false.

pub fn with_value(len: usize, value: bool) -> Self

Creates a new bit vector of length len initialized to value.

pub fn with_capacity(capacity: usize) -> Self

Creates a new zero-length bit vector of given capacity.

Note that the capacity will be rounded up to a multiple of the word size.

pub fn capacity(&self) -> usize

pub fn push(&mut self, b: bool)

pub fn pop(&mut self) -> Option<bool>

pub fn resize(&mut self, new_len: usize, value: bool)

impl<B: AsRef<[usize]>> BitVec<B>

pub fn iter(&self) -> BitIterator<'_, B>

pub fn iter_ones(&self) -> OnesIterator<'_, B>

pub fn iter_zeros(&self) -> ZerosIterator<'_, B>

Trait Implementations

impl<B> AlignHash for BitVec<B>

where B: AlignHash,

fn align_hash(hasher: &mut impl Hasher, _offset_of: &mut usize)

Accumulate alignment information in hasher assuming to be positioned at offset_of.

fn align_hash_val(&self, hasher: &mut impl Hasher, offset_of: &mut usize)

Call AlignHash::align_hash on a value.

impl<W, B: AsMut<[W]>> AsMut<[W]> for BitVec<B>

fn as_mut(&mut self) -> &mut [W]

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

impl<W, B: AsRef<[W]>> AsRef<[W]> for BitVec<B>

fn as_ref(&self) -> &[W]

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

impl<B: AsRef<[usize]>> BitCount for BitVec<B>

fn count_ones(&self) -> usize

Returns the number of ones in the underlying bit vector, with a possibly expensive computation; see NumBits::num_ones for constant-time version.

fn count_zeros(&self) -> usize

Returns the number of zeros in the underlying bit vector, with a possibly expensive computation; see NumBits::num_zeros for constant-time version.

impl<B> BitLength for BitVec<B>

fn len(&self) -> usize

Returns a length in bits.

impl<B: Clone> Clone for BitVec<B>

fn clone(&self) -> BitVec<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B> CopyType for BitVec<B>

type Copy = Deep

impl<B> CopyType for BitVec<B>

where B: MemSize, usize: MemSize,

type Copy = False

impl<B: Debug> Debug for BitVec<B>

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

Formats the value using the given formatter.

impl<B> DeserializeInner for BitVec<B>

where B: DeserializeInner, usize: DeserializeInner,

type DeserType<'epserde_desertype> = BitVec<<B as DeserializeInner>::DeserType<'epserde_desertype>>

The deserialization type associated with this type. It can be retrieved conveniently with the alias DeserType.

fn _deserialize_full_inner( backend: &mut impl ReadWithPos, ) -> Result<Self, Error>

fn _deserialize_eps_inner<'deserialize_eps_inner_lifetime>( backend: &mut SliceWithPos<'deserialize_eps_inner_lifetime>, ) -> Result<Self::DeserType<'deserialize_eps_inner_lifetime>, Error>

impl<B: AsRef<[usize]>> Display for BitVec<B>

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

Formats the value using the given formatter.

impl Extend<bool> for BitVec<Vec<usize>>

fn extend<T>(&mut self, i: T)

where T: IntoIterator<Item = bool>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, W: IntoAtomic> From<AtomicBitVec<&'a [<W as IntoAtomic>::AtomicType]>> for BitVec<&'a [W]>

fn from(value: AtomicBitVec<&'a [W::AtomicType]>) -> Self

Converts to this type from the input type.

impl<'a, W: IntoAtomic> From<AtomicBitVec<&'a mut [<W as IntoAtomic>::AtomicType]>> for BitVec<&'a mut [W]>

fn from(value: AtomicBitVec<&'a mut [W::AtomicType]>) -> Self

Converts to this type from the input type.

impl<W: IntoAtomic> From<AtomicBitVec<Box<[<W as IntoAtomic>::AtomicType]>>> for BitVec<Box<[W]>>

fn from(value: AtomicBitVec<Box<[W::AtomicType]>>) -> Self

Converts to this type from the input type.

impl<W: IntoAtomic> From<AtomicBitVec<Vec<<W as IntoAtomic>::AtomicType>>> for BitVec<Vec<W>>

fn from(value: AtomicBitVec<Vec<W::AtomicType>>) -> Self

Converts to this type from the input type.

impl<'a, W: IntoAtomic> From<BitVec<&'a [W]>> for AtomicBitVec<&'a [W::AtomicType]>

fn from(value: BitVec<&'a [W]>) -> Self

Converts to this type from the input type.

impl<'a, W: IntoAtomic> From<BitVec<&'a mut [W]>> for AtomicBitVec<&'a mut [W::AtomicType]>

fn from(value: BitVec<&'a mut [W]>) -> Self

Converts to this type from the input type.

impl<W: IntoAtomic> From<BitVec<Box<[W]>>> for AtomicBitVec<Box<[W::AtomicType]>>

fn from(value: BitVec<Box<[W]>>) -> Self

Converts to this type from the input type.

impl<W> From<BitVec<Box<[W]>>> for BitVec<Vec<W>>

fn from(value: BitVec<Box<[W]>>) -> Self

Converts to this type from the input type.

impl<W: IntoAtomic> From<BitVec<Vec<W>>> for AtomicBitVec<Vec<W::AtomicType>>

fn from(value: BitVec<Vec<W>>) -> Self

Converts to this type from the input type.

impl<W> From<BitVec<Vec<W>>> for BitVec<Box<[W]>>

fn from(value: BitVec<Vec<W>>) -> Self

Converts to this type from the input type.

impl FromIterator<bool> for BitVec<Vec<usize>>

fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self

Creates a value from an iterator.

impl<B: AsRef<[usize]>> Index<usize> for BitVec<B>

type Output = bool

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, B: AsRef<[usize]>> IntoIterator for &'a BitVec<B>

type IntoIter = BitIterator<'a, B>

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<B> MemDbgImpl for BitVec<B>

where B: MemDbgImpl, usize: MemDbgImpl,

fn _mem_dbg_rec_on( &self, _memdbg_writer: &mut impl Write, _memdbg_total_size: usize, _memdbg_max_depth: usize, _memdbg_prefix: &mut String, _memdbg_is_last: bool, _memdbg_flags: DbgFlags, ) -> Result

fn _mem_dbg_depth_on( &self, writer: &mut impl Write, total_size: usize, max_depth: usize, prefix: &mut String, field_name: Option<&str>, is_last: bool, padded_size: usize, flags: DbgFlags, ) -> Result<(), Error>

impl<B> MemSize for BitVec<B>

where B: MemSize, usize: MemSize,

fn mem_size(&self, _memsize_flags: SizeFlags) -> usize

Returns the (recursively computed) overall memory size of the structure in bytes.

impl<B: AsRef<[usize]>, C: AsRef<[usize]>> PartialEq<BitVec<C>> for BitVec<B>

fn eq(&self, other: &BitVec<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<B: AsRef<[usize]>> RankHinted<64> for BitVec<B>

unsafe fn rank_hinted( &self, pos: usize, hint_pos: usize, hint_rank: usize, ) -> usize

Returns the number of ones preceding the specified position, provided a preceding position and its associated rank.

impl<B: AsRef<[usize]>> SelectHinted for BitVec<B>

unsafe fn select_hinted( &self, rank: usize, hint_pos: usize, hint_rank: usize, ) -> usize

Selection the one of given rank, provided the position of a preceding one and its rank.

impl<B: AsRef<[usize]>> SelectZeroHinted for BitVec<B>

unsafe fn select_zero_hinted( &self, rank: usize, hint_pos: usize, hint_rank: usize, ) -> usize

Selection the zero of given rank, provided the position of a preceding zero and its rank.

impl<B> SerializeInner for BitVec<B>

where B: SerializeInner, usize: SerializeInner,

const IS_ZERO_COPY: bool

Inner constant used by the derive macros to keep track recursively of whether the type satisfies the conditions for being zero-copy. It is checked at runtime against the trait implemented by the type, and if a ZeroCopy type has this constant set to false serialization will panic.

const ZERO_COPY_MISMATCH: bool

Inner constant used by the derive macros to keep track of whether all fields of a type are zero-copy but neither the attribute #[zero_copy] nor the attribute #[deep_copy] was specified. It is checked at runtime, and if it is true a warning will be issued, as the type could be zero-copy, which would be more efficient.

type SerType = BitVec<<B as SerializeInner>::SerType>

This is the type that will be written in the header of the file, and thus the type that will be deserialized. In most cases it is Self, but in some cases, as for references to slices, it is customized.

fn _serialize_inner(&self, backend: &mut impl WriteWithNames) -> Result<()>

Serialize this structure using the given backend.

impl<B> TypeHash for BitVec<B>

where B: TypeHash,

fn type_hash(hasher: &mut impl Hasher)

Accumulate type information in hasher.

fn type_hash_val(&self, hasher: &mut impl Hasher)

Call TypeHash::type_hash on a value.

impl Eq for BitVec<Vec<usize>>