Struct BitFieldVec 

pub struct BitFieldVec<B: Backend = Vec<usize>> { /* private fields */ }

A vector of bit fields of fixed width (AKA “compact array”, “bit array”, etc.).

See the module documentation for more details.

Implementations

impl<B: Backend<Word: Word>> BitFieldVec<B>

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

Safety

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

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

Returns the backend, the bit width, and the length, consuming this vector.

pub const fn mask(&self) -> B::Word

Returns the mask used to extract values from the vector. This will keep the lowest bit_width bits.

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

Replaces the backend by applying a function, consuming this vector.

Safety

The caller must ensure that the length is compatible with the new backend.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> BitFieldVec<B>

pub fn addr_of(&self, index: usize) -> *const B::Word

Gets the address of the item storing (the first part of) the element of given index.

This method is mainly useful for manually prefetching parts of the data structure.

pub fn get_unaligned(&self, index: usize) -> B::Word

Like SliceByValue::index_value, but using unaligned reads.

This method can be used only for bit width smaller than or equal to W::BITS as usize - 8 + 2 or equal to W::BITS as usize - 8 + 4 or W::BITS. Moreover, an additional padding word must be present at the end of the vector.

Note that to guarantee the absence of undefined behavior this method has to perform several tests. Consider using get_unaligned_unchecked if you are sure that the constraints are respected.

Panics

This method will panic if the constraints above are not respected.

pub unsafe fn get_unaligned_unchecked(&self, index: usize) -> B::Word

Like SliceByValue::get_value_unchecked, but using unaligned reads.

Safety

This method can be used only for bit width smaller than or equal to W::BITS as usize - 8 + 2 or equal to W::BITS as usize - 8 + 4 or W::BITS. Moreover, an additional padding word must be present at the end of the vector, and index must be within bounds.

Panics

This method will panic in debug mode if the safety constraints are not respected.

pub fn as_slice(&self) -> &[B::Word]

Returns the backend of the vector as a slice of words.

impl<W: Word> BitFieldVec<Vec<W>>

pub fn new(bit_width: usize, len: usize) -> Self

Creates a new zero-initialized vector of given bit width and length.

pub fn with_capacity(bit_width: usize, capacity: usize) -> Self

Creates an empty vector that doesn’t need to reallocate for up to capacity elements.

pub unsafe fn set_len(&mut self, len: usize)

Sets the length.

Safety

len * bit_width must be at most self.bits.len() * W::BITS as usize. Note that setting the length might result in reading uninitialized data.

pub fn clear(&mut self)

Sets len to 0.

pub const fn bit_width(&self) -> usize

Returns the bit width of the values inside the vector.

pub fn from_slice<S: BitFieldSlice<Value: Word + PrimitiveNumberAs<W>>>( slice: &S, ) -> Result<Self>

Creates a new vector by copying a slice; the bit width will be the minimum width sufficient to hold all values in the slice.

Returns an error if the bit width of the values in slice is larger than W::BITS.

pub fn push(&mut self, value: W)

Adds a value at the end of the vector.

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

Truncates or extends with value the vector.

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

Removes and returns a value from the end of the vector.

Returns None if the BitFieldVec is empty.

pub fn into_padded(self) -> BitFieldVec<Box<[W]>>

Ensures a padding word is present at the end and converts the backend to Box<[W]>.

The extra word ensures that unaligned reads of size_of::<W>() bytes starting at any byte offset within the data never exceed the allocation. If the allocation already has more words than needed for the data, no word is added.

impl<W: Word> BitFieldVec<Box<[W]>>

pub fn new_padded(bit_width: usize, len: usize) -> Self

Creates a new zero-initialized vector of given bit width and length, with a padding word at the end for safe unaligned reads.

This constructor is useful for structures implementing TryIntoUnaligned that want to avoid reallocations.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> BitFieldVec<B>

pub fn iter_from(&self, from: usize) -> BitFieldVecIter<'_, B>

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

Trait Implementations

impl<B> AlignHash for BitFieldVec<B>

where B: SerInner<SerType: AlignHash> + Backend, usize: SerInner<SerType: AlignHash>, B::Word: 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<B> Backend for BitFieldVec<B>

where B: Backend + Backend,

type Word = <B as Backend>::Word

The word type used by this backend.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> BitFieldSlice for BitFieldVec<B>

fn as_slice(&self) -> &[Self::Value]

Returns the backend of the slice as a slice of Self::Value.

impl<B: Backend<Word: Word> + AsRef<[B::Word]> + AsMut<[B::Word]>> BitFieldSliceMut for BitFieldVec<B>

fn reset(&mut self)

Sets all values to zero.

fn par_reset(&mut self)

Available on crate feature rayon only.

Sets all values to zero using a parallel implementation.

fn as_mut_slice(&mut self) -> &mut [B::Word]

Returns the backend of the slice as a mutable slice of Self::Value.

impl<B: Backend<Word: Word>> BitWidth for BitFieldVec<B>

fn bit_width(&self) -> usize

Returns the bit width of the slice.

impl<B: Clone + Backend> Clone for BitFieldVec<B>

where B::Word: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Backend> CopyType for BitFieldVec<B>

type Copy = Deep

impl<B: Debug + Backend> Debug for BitFieldVec<B>

where B::Word: Debug,

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

Formats the value using the given formatter.

impl<B> DeserInner for BitFieldVec<B>

where B: DeserInner + Backend, usize: DeserInner, B::Word: DeserInner, for<'a> <B as DeserInner>::DeserType<'a>: Backend<Word = B::Word>, for<'__epserde_desertype> DeserType<'__epserde_desertype, B>: Backend,

type DeserType<'__epserde_desertype> = BitFieldVec<<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 BitFieldVec<B>

where B: Deserialize<'de> + Backend, B::Word: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<W: Word> Extend<W> for BitFieldVec<Vec<W>>

fn extend<T: IntoIterator<Item = W>>(&mut self, iter: T)

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 BitFieldVec<B>

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

type Flat = False

impl<'a, W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<AtomicBitFieldVec<&'a [<W as AtomicPrimitive>::Atomic]>> for BitFieldVec<&'a [W]>

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

Converts to this type from the input type.

impl<'a, W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<AtomicBitFieldVec<&'a mut [<W as AtomicPrimitive>::Atomic]>> for BitFieldVec<&'a mut [W]>

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

Converts to this type from the input type.

impl<W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<AtomicBitFieldVec<Box<[<W as AtomicPrimitive>::Atomic]>>> for BitFieldVec<Box<[W]>>

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

Converts to this type from the input type.

impl<W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<AtomicBitFieldVec<Vec<<W as AtomicPrimitive>::Atomic>>> for BitFieldVec<Vec<W>>

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

Converts to this type from the input type.

impl<W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<BitFieldVec<Box<[W]>>> for AtomicBitFieldVec<Box<[W::Atomic]>>

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

Converts to this type from the input type.

impl<W: Word> From<BitFieldVec<Box<[W]>>> for BitFieldVec<Vec<W>>

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

Converts to this type from the input type.

impl<W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> From<BitFieldVec<Vec<W>>> for AtomicBitFieldVec<Vec<W::Atomic>>

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

Converts to this type from the input type.

impl<W: Word> From<BitFieldVec<Vec<W>>> for BitFieldVec<Box<[W]>>

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

Converts to this type from the input type.

impl<W: Word> From<BitFieldVecU<Box<[W]>>> for BitFieldVec<Box<[W]>>

fn from(unaligned: BitFieldVecU<Box<[W]>>) -> Self

Converts a BitFieldVecU back into a BitFieldVec.

The padding word is kept in the backing storage so that a subsequent try_into_unaligned does not need to reallocate.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> Hash for BitFieldVec<B>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IntoIterator for &'a BitFieldVec<B>

type Item = <B as Backend>::Word

The type of the elements being iterated over.

type IntoIter = BitFieldVecIter<'a, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IntoIteratorFrom for &'a BitFieldVec<B>

type IntoIterFrom = BitFieldVecIter<'a, B>

The iterator type returned by into_iter_from.

fn into_iter_from(self, from: usize) -> Self::IntoIterFrom

Creates an iterator from a starting position.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IntoUncheckedBackIterator for &'a BitFieldVec<B>

type Item = <B as Backend>::Word

type IntoUncheckedIterBack = BitFieldVecUncheckedBackIter<'a, B>

fn into_unchecked_iter_back(self) -> Self::IntoUncheckedIterBack

Creates a backward unchecked iterator starting from the end.

fn into_unchecked_iter_back_from( self, from: usize, ) -> Self::IntoUncheckedIterBack

Creates a backward unchecked iterator starting from the given position.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IntoUncheckedIterator for &'a BitFieldVec<B>

type Item = <B as Backend>::Word

type IntoUncheckedIter = BitFieldVecUncheckedIter<'a, B>

fn into_unchecked_iter_from(self, from: usize) -> Self::IntoUncheckedIter

Creates an unchecked iterator starting from the given position.

fn into_unchecked_iter(self) -> Self::IntoUncheckedIter

Creates an unchecked iterator starting from the first position.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> IterateByValue for BitFieldVec<B>

fn iter_value(&self) -> <Self as IterateByValueGat<'_>>::Iter

Returns an iterator on values.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> IterateByValueFrom for BitFieldVec<B>

fn iter_value_from(&self, from: usize) -> <Self as IterateByValueGat<'_>>::Iter

Returns an iterator on values starting at the given position.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IterateByValueFromGat<'a> for BitFieldVec<B>

type Item = <B as Backend>::Word

The type of the items returned by the iterator.

type IterFrom = BitFieldVecIter<'a, B>

The type of the iterator returned by iter_value_from.

impl<'a, B: Backend<Word: Word> + AsRef<[B::Word]>> IterateByValueGat<'a> for BitFieldVec<B>

type Item = <B as Backend>::Word

The type of the items returned by the iterator.

type Iter = BitFieldVecIter<'a, B>

The type of the iterator returned by iter_value.

impl<B> MemDbgImpl for BitFieldVec<B>

where B: MemDbgImpl + FlatType + Backend, usize: MemDbgImpl + FlatType, B::Word: 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 BitFieldVec<B>

where B: MemSize + FlatType + Backend, usize: MemSize + FlatType, B::Word: 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: Backend<Word: Word> + AsRef<[B::Word]>, C: Backend<Word = B::Word> + AsRef<[B::Word]>> PartialEq<BitFieldVec<C>> for BitFieldVec<B>

Equality between bit-field vectors requires that the word is the same, the bit width is the same, and the content is the same.

fn eq(&self, other: &BitFieldVec<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> SerInner for BitFieldVec<B>

where B: SerInner + Backend, usize: SerInner, B::Word: SerInner, SerType<B>: Backend,

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 = BitFieldVec<<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 BitFieldVec<B>

where B: Serialize + Backend, B::Word: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<B: Backend<Word: Word> + AsRef<[B::Word]>> SliceByValue for BitFieldVec<B>

type Value = <B as Backend>::Word

The type of the values in the slice.

fn len(&self) -> usize

See slice::len.

unsafe fn get_value_unchecked(&self, index: usize) -> B::Word

See slice::get_unchecked.

fn is_empty(&self) -> bool

See slice::is_empty.

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

See the Index implementation for slices.

fn get_value(&self, index: usize) -> Option<Self::Value>

See slice::get.

impl<B: Backend<Word: Word> + AsRef<[B::Word]> + AsMut<[B::Word]>> SliceByValueMut for BitFieldVec<B>

fn copy(&self, from: usize, dst: &mut Self, to: usize, len: usize)

This implementation performs the copy word by word, which is significantly faster than the default implementation.

unsafe fn apply_in_place_unchecked<F>(&mut self, f: F)

where F: FnMut(Self::Value) -> Self::Value,

This implementation keeps a buffer of W::BITS bits for reading and writing, obtaining a significant speedup with respect to the default implementation.

fn try_chunks_mut( &mut self, chunk_size: usize, ) -> Result<Self::ChunksMut<'_>, ChunksMutError<B::Word>>

Errors

This method will return an error if the chunk size multiplied by the bit width is not a multiple of W::BITS and more than one chunk must be returned.

type ChunksMut<'a> = ChunksMut<'a, <B as Backend>::Word> where Self: 'a

The iterator type returned by try_chunks_mut.

type ChunksMutError = ChunksMutError<<B as Backend>::Word>

The error type returned by try_chunks_mut.

fn set_value(&mut self, index: usize, value: B::Word)

Sets the value at the given index to the given value.

unsafe fn set_value_unchecked(&mut self, index: usize, value: B::Word)

Sets the value at the given index to the given value without doing bounds checking.

fn replace_value(&mut self, index: usize, value: B::Word) -> B::Word

Sets the value at the given index to the given value and returns the previous value.

unsafe fn replace_value_unchecked( &mut self, index: usize, value: B::Word, ) -> B::Word

Sets the value at the given index to the given value and returns the previous value, without doing bounds checking.

fn apply_in_place<F>(&mut self, f: F)

where F: FnMut(Self::Value) -> Self::Value,

Applies a function to all elements of the slice in place.

impl<'__subslice_impl, B> SliceByValueSubsliceGat<'__subslice_impl> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

type Subslice = BitFieldVecSubsliceImpl<'__subslice_impl, B>

The type of the subslice.

impl<'__subslice_impl, B> SliceByValueSubsliceGatMut<'__subslice_impl> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

type SubsliceMut = BitFieldVecSubsliceImplMut<'__subslice_impl, B>

The type of the mutable subslice.

impl<B> SliceByValueSubsliceRange<Range<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked( &self, range: Range<usize>, ) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRange<RangeFrom<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked( &self, range: RangeFrom<usize>, ) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRange<RangeFull> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked(&self, range: RangeFull) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRange<RangeInclusive<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked( &self, range: RangeInclusive<usize>, ) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRange<RangeTo<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked( &self, range: RangeTo<usize>, ) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRange<RangeToInclusive<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked( &self, range: RangeToInclusive<usize>, ) -> Subslice<'_, Self>

See slice::get_unchecked.

fn index_subslice(&self, range: R) -> Self::Subslice

See the Index implementation for slices.

fn get_subslice(&self, range: R) -> Option<Self::Subslice>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<Range<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: Range<usize>, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<RangeFrom<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: RangeFrom<usize>, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<RangeFull> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: RangeFull, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<RangeInclusive<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: RangeInclusive<usize>, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<RangeTo<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: RangeTo<usize>, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B> SliceByValueSubsliceRangeMut<RangeToInclusive<usize>> for BitFieldVec<B>

where B: AsRef<[B::Word]> + AsMut<[B::Word]> + Backend, B::Word: Word,

unsafe fn get_subslice_unchecked_mut( &mut self, range: RangeToInclusive<usize>, ) -> SubsliceMut<'_, Self>

See slice::get_unchecked.

fn index_subslice_mut(&mut self, range: R) -> Self::SubsliceMut

See the Index implementation for slices.

fn get_subslice_mut(&mut self, range: R) -> Option<Self::SubsliceMut>

See slice::get.

impl<B: Backend<Word: Word>> TruncateHash<<B as Backend>::Word> for BitFieldVec<B>

where u64: PrimitiveNumberAs<B::Word>,

fn truncate_hash(&self, hash: u64) -> B::Word

Returns the given hash truncated to the bit width of the stored values.

impl<'a, W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> TryFrom<BitFieldVec<&'a [W]>> for AtomicBitFieldVec<&'a [W::Atomic]>

type Error = CannotCastToAtomicError<W>

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<'a, W: Word + AtomicPrimitive<Atomic: PrimitiveAtomicUnsigned>> TryFrom<BitFieldVec<&'a mut [W]>> for AtomicBitFieldVec<&'a mut [W::Atomic]>

type Error = CannotCastToAtomicError<W>

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<W: Word> TryIntoUnaligned for BitFieldVec<Box<[W]>>

fn try_into_unaligned(self) -> Result<Self::Unaligned, UnalignedConversionError>

Converts a BitFieldVec into a BitFieldVecU, adding a padding word at the end if one is not already present.

Errors

Returns an error if the bit width does not satisfy the constraints of BitFieldVec::get_unaligned_unchecked: it must be at most W::BITS - 6, or exactly W::BITS - 4, or exactly W::BITS.

type Unaligned = BitFieldVecU<Box<[W]>>

The unaligned version of this type.

impl<B> TypeHash for BitFieldVec<B>

where B: SerInner<SerType: TypeHash> + Backend, usize: SerInner<SerType: TypeHash>, B::Word: 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: Backend<Word: Word> + AsRef<[B::Word]>> Eq for BitFieldVec<B>