Struct BitVec 

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

A bit vector.

Instances can be created using new, with_value, with the convenience macro bit_vec!, or with a FromIterator implementation.

See the module documentation for more details.

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

Returns the current capacity of this bit vector.

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

Appends a bit to the end of this bit vector.

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

Removes the last bit from the bit vector and returns it, or None if it is empty.

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

Resizes the bit vector in place, extending it with value if it is necessary.

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

pub fn to_owned(&self) -> BitVec

Returns an owned copy of the bit vector.

Trait Implementations

impl<B> AlignHash for BitVec<B>

where B: SerInner<SerType: AlignHash>, usize: SerInner<SerType: AlignHash>,

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

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

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

Calls 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 duplicate 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: Debug> Debug for BitVec<B>

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

Formats the value using the given formatter.

impl<B> DeserInner for BitVec<B>

where B: DeserInner, usize: DeserInner,

type DeserType<'__epserde_desertype> = BitVec<<B as DeserInner>::DeserType<'__epserde_desertype>>

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

fn __check_covariance<'__long: '__short, '__short>( proof: CovariantProof<Self::DeserType<'__long>>, ) -> CovariantProof<Self::DeserType<'__short>>

Internal method for checking the covariance of DeserType.

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

Safety

unsafe fn _deser_eps_inner<'deser_eps_inner_lifetime>( backend: &mut SliceWithPos<'deser_eps_inner_lifetime>, ) -> Result<Self::DeserType<'deser_eps_inner_lifetime>, Error>

Safety

impl<'de, B> Deserialize<'de> for BitVec<B>

where B: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

where B: MemSize + FlatType, usize: MemSize + FlatType,

type Flat = False

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<Box<[<W as IntoAtomic>::AtomicType]>>> for BitVec<Vec<W>>

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

Converts to this type from the input type.

impl<W: IntoAtomic + Copy> 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<Box<[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 = BitIter<'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 + FlatType, usize: MemDbgImpl + FlatType,

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, _memdbg_refs: &mut HashSet<usize>, ) -> 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, dbg_refs: &mut HashSet<usize>, ) -> Result<(), Error>

fn _mem_dbg_depth_on_impl( &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, dbg_refs: &mut HashSet<usize>, ref_display: RefDisplay, ) -> Result<(), Error>

Internal implementation for depth display.

impl<B> MemSize for BitVec<B>

where B: MemSize + FlatType, usize: MemSize + FlatType,

fn mem_size_rec( &self, _memsize_flags: SizeFlags, _memsize_refs: &mut HashMap<usize, usize>, ) -> usize

Recursive implementation that tracks visited references for deduplication.

fn mem_size(&self, 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

Selects 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

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

impl<B> SerInner for BitVec<B>

where B: SerInner, usize: SerInner,

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.

type SerType = BitVec<<B as SerInner>::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.

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

Serializes this structure using the given backend.

impl<B> Serialize for BitVec<B>

where B: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

This conversion may fail if the alignment of W is not the same as that of W::AtomicType.

type Error = CannotCastToAtomicError<W>

The type returned in the event of a conversion error.

fn try_from(value: BitVec<&'a [W]>) -> Result<Self, Self::Error>

Performs the conversion.

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

This conversion may fail if the alignment of W is not the same as that of W::AtomicType.

type Error = CannotCastToAtomicError<W>

The type returned in the event of a conversion error.

fn try_from(value: BitVec<&'a mut [W]>) -> Result<Self, Self::Error>

Performs the conversion.

impl<B> TypeHash for BitVec<B>

where B: SerInner<SerType: TypeHash>, usize: SerInner<SerType: TypeHash>,

fn type_hash(hasher: &mut impl Hasher)

Accumulates type information in hasher.

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

Calls TypeHash::type_hash on a value.

impl<B: Copy> Copy for BitVec<B>

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