Struct AtomicBitFieldVec 

pub struct AtomicBitFieldVec<B: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>> = Vec<Atomic<usize>>> { /* private fields */ }

A tentatively thread-safe vector of bit fields of fixed width (AKA “compact arrays”, “bit array”, etc.)

This implementation provides some concurrency guarantees, albeit not full-fledged thread safety: more precisely, we can guarantee thread-safety if the bit width is a power of two; otherwise, concurrent writes to values that cross word boundaries might end up in different threads succeeding in writing only part of a value. If the user can guarantee that no two threads ever write to the same boundary-crossing value, then no race condition can happen.

See the module documentation for more details.

Implementations

impl<B: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> AtomicBitFieldVec<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 as PrimitiveAtomic>::Value

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

impl<B: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>> + AsRef<[B::Word]>> AtomicBitFieldVec<B>

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

Returns the backend of the AtomicBitFieldVec as a slice of atomic words.

impl<A: PrimitiveAtomicUnsigned<Value: Word>> AtomicBitFieldVec<Vec<A>>

pub fn new(bit_width: usize, len: usize) -> AtomicBitFieldVec<Vec<A>>

Trait Implementations

impl<B> AlignHash for AtomicBitFieldVec<B>

where B: SerInner<SerType: AlignHash> + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: SerInner<SerType: AlignHash>, <B::Word as PrimitiveAtomic>::Value: 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<Word: PrimitiveAtomicUnsigned<Value: Word>> + AsRef<[B::Word]>> AtomicBitFieldSlice<<B as Backend>::Word> for AtomicBitFieldVec<B>

fn set_atomic( &self, index: usize, value: <B::Word as PrimitiveAtomic>::Value, order: Ordering, )

Sets the element of the slice at the specified index.

May panic if the index is not in [0..len) or the value does not fit in BitWidth::bit_width bits.

fn len(&self) -> usize

See slice::len.

unsafe fn get_atomic_unchecked( &self, index: usize, order: Ordering, ) -> <B::Word as PrimitiveAtomic>::Value

Returns the value at the specified index.

unsafe fn set_atomic_unchecked( &self, index: usize, value: <B::Word as PrimitiveAtomic>::Value, order: Ordering, )

Sets the element of the slice at the specified index.

fn reset_atomic(&mut self, ordering: Ordering)

Sets all values to zero.

fn par_reset_atomic(&mut self, ordering: Ordering)

Available on crate feature rayon only.

Sets all values to zero using a parallel implementation.

fn is_empty(&self) -> bool

See slice::is_empty.

fn get_atomic(&self, index: usize, order: Ordering) -> A::Value

Returns the value at the specified index.

impl<B: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> AtomicBitWidth for AtomicBitFieldVec<B>

fn atomic_bit_width(&self) -> usize

Returns the bit width of the atomic slice.

impl<B> Backend for AtomicBitFieldVec<B>

where B: Backend + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>,

type Word = <B as Backend>::Word

The word type used by this backend.

impl<B: Clone + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> Clone for AtomicBitFieldVec<B>

where B::Word: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> CopyType for AtomicBitFieldVec<B>

type Copy = Deep

impl<B: Debug + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> Debug for AtomicBitFieldVec<B>

where B::Word: Debug,

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

Formats the value using the given formatter.

impl<B> DeserInner for AtomicBitFieldVec<B>

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

type DeserType<'__epserde_desertype> = AtomicBitFieldVec<<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<B> FlatType for AtomicBitFieldVec<B>

where B: MemSize + FlatType + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: MemSize + FlatType, <B::Word as PrimitiveAtomic>::Value: 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 + 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<B: Hash + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>> Hash for AtomicBitFieldVec<B>

where B::Word: Hash,

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

where B: MemDbgImpl + FlatType + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: MemDbgImpl + FlatType, <B::Word as PrimitiveAtomic>::Value: 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 AtomicBitFieldVec<B>

where B: MemSize + FlatType + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: MemSize + FlatType, <B::Word as PrimitiveAtomic>::Value: 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> SerInner for AtomicBitFieldVec<B>

where B: SerInner + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: SerInner, <B::Word as PrimitiveAtomic>::Value: SerInner, SerType<B>: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>,

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 = AtomicBitFieldVec<<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: Backend<Word: PrimitiveAtomicUnsigned<Value: Word>> + AsRef<[B::Word]>> SliceByValue for AtomicBitFieldVec<B>

type Value = <<B as Backend>::Word as PrimitiveAtomic>::Value

The type of the values in the slice.

fn len(&self) -> usize

See slice::len.

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

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<'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<B> TypeHash for AtomicBitFieldVec<B>

where B: SerInner<SerType: TypeHash> + Backend<Word: PrimitiveAtomicUnsigned<Value: Word>>, usize: SerInner<SerType: TypeHash>, <B::Word as PrimitiveAtomic>::Value: 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.