[−]Struct oxygengine::core::prelude::BitSet
A BitSet
is a simple set designed to track which indices are placed
into it.
Note, a BitSet
is limited by design to only usize**4
indices.
Adding beyond this limit will cause the BitSet
to panic.
Implementations
impl BitSet
pub fn new() -> BitSet
Creates an empty BitSet
.
pub fn with_capacity(max: u32) -> BitSet
Creates an empty BitSet
, preallocated for up to max
indices.
pub fn add(&mut self, id: u32) -> bool
Adds id
to the BitSet
. Returns true
if the value was
already in the set.
pub fn remove(&mut self, id: u32) -> bool
Removes id
from the set, returns true
if the value
was removed, and false
if the value was not set
to begin with.
pub fn contains(&self, id: u32) -> bool
Returns true
if id
is in the set.
pub fn contains_set(&self, other: &BitSet) -> bool
Returns true
if all ids in other
are contained in this set
pub fn clear(&mut self)
Completely wipes out the bit set.
pub const BITS_PER_USIZE: usize
How many bits are in a usize
.
This value can be trivially determined. It is provided here as a constant for clarity.
Example
use hibitset::BitSet; assert_eq!(BitSet::BITS_PER_USIZE, std::mem::size_of::<usize>()*8);
pub fn layer0_as_slice(&self) -> &[usize]
Returns the bottom layer of the bitset as a slice. Each bit in this slice refers to a single
Index
.
The slice's length will be at least the length needed to reflect all the 1
s in the bitset,
but is not otherwise guaranteed. Consider it to be an implementation detail.
Example
use hibitset::BitSet; let index: u32 = 12345; let mut bitset = BitSet::new(); bitset.add(index); // layer 0 is 1:1 with Indexes, so we expect that bit in the slice to be set let slice = bitset.layer0_as_slice(); let bit_index = index as usize; // map that bit index to a usize in the slice and a bit within that usize let slice_index = bit_index / BitSet::BITS_PER_USIZE; let bit_at_index = bit_index % BitSet::BITS_PER_USIZE; assert_eq!(slice[slice_index], 1 << bit_at_index);
pub const LAYER1_GRANULARITY: usize
How many Index
es are described by as single layer 1 bit, intended for use with
BitSet::layer1_as_slice()
.
BitSet
s are defined in terms of usize
s summarizing usize
s, so this value can be
trivially determined. It is provided here as a constant for clarity.
Example
use hibitset::BitSet; assert_eq!(BitSet::LAYER1_GRANULARITY, BitSet::BITS_PER_USIZE);
pub fn layer1_as_slice(&self) -> &[usize]
Returns the second layer of the bitset as a slice. Each bit in this slice summarizes a
corresponding usize
from layer0
. (If usize
is 64 bits, bit 0 will be set if any
Index
es 0-63 are set, bit 1 will be set if any Index
es 64-127 are set, etc.)
BitSet::LAYER1_GRANULARITY
reflects how many indexes are summarized per layer 1 bit.
The slice's length is not guaranteed, except that it will be at least the length needed to
reflect all the 1
s in the bitset.
Example
use hibitset::BitSet; let index: u32 = 12345; let mut bitset = BitSet::new(); bitset.add(index); // layer 1 summarizes multiple indexes per bit, so divide appropriately let slice = bitset.layer1_as_slice(); let bit_index = index as usize / BitSet::LAYER1_GRANULARITY; // map that bit index to a usize in the slice and a bit within that usize let slice_index = bit_index / BitSet::BITS_PER_USIZE; let bit_at_index = bit_index % BitSet::BITS_PER_USIZE; assert_eq!(slice[slice_index], 1 << bit_at_index);
pub const LAYER2_GRANULARITY: usize
How many Index
es are described by as single layer 2 bit, intended for use with
BitSet::layer2_as_slice()
.
BitSet
s are defined in terms of usize
s summarizing usize
s, so this value can be
trivially determined. It is provided here as a constant for clarity.
Example
use hibitset::BitSet; assert_eq!(BitSet::LAYER2_GRANULARITY, BitSet::LAYER1_GRANULARITY * BitSet::BITS_PER_USIZE);
pub fn layer2_as_slice(&self) -> &[usize]
Returns the third layer of the bitset as a slice. Each bit in this slice summarizes a
corresponding usize
from layer1
. If usize
is 64 bits, bit 0 will be set if any
Index
es 0-4095 are set, bit 1 will be set if any Index
es 4096-8191 are set, etc.
The slice's length is not guaranteed, except that it will be at least the length needed to
reflect all the 1
s in the bitset.
Example
use hibitset::BitSet; let index: u32 = 12345; let mut bitset = BitSet::new(); bitset.add(index); // layer 2 summarizes multiple indexes per bit, so divide appropriately let slice = bitset.layer2_as_slice(); let bit_index = index as usize / BitSet::LAYER2_GRANULARITY; // map that bit index to a usize in the slice and a bit within that usize let slice_index = bit_index / BitSet::BITS_PER_USIZE; let bit_at_index = bit_index % BitSet::BITS_PER_USIZE; assert_eq!(slice[slice_index], 1 << bit_at_index);
Trait Implementations
impl<'a, T> BitAnd<T> for &'a BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetAnd<&'a BitSet, T>
The resulting type after applying the &
operator.
fn bitand(self, rhs: T) -> <&'a BitSet as BitAnd<T>>::Output
impl<T> BitAnd<T> for BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetAnd<BitSet, T>
The resulting type after applying the &
operator.
fn bitand(self, rhs: T) -> <BitSet as BitAnd<T>>::Output
impl<'a, B> BitAndAssign<&'a B> for BitSet where
B: BitSetLike,
B: BitSetLike,
fn bitand_assign(&mut self, lhs: &B)
impl<T> BitOr<T> for BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetOr<BitSet, T>
The resulting type after applying the |
operator.
fn bitor(self, rhs: T) -> <BitSet as BitOr<T>>::Output
impl<'a, T> BitOr<T> for &'a BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetOr<&'a BitSet, T>
The resulting type after applying the |
operator.
fn bitor(self, rhs: T) -> <&'a BitSet as BitOr<T>>::Output
impl<'a, B> BitOrAssign<&'a B> for BitSet where
B: BitSetLike,
B: BitSetLike,
fn bitor_assign(&mut self, lhs: &B)
impl BitSetLike for BitSet
fn layer3(&self) -> usize
fn layer2(&self, i: usize) -> usize
fn layer1(&self, i: usize) -> usize
fn layer0(&self, i: usize) -> usize
fn contains(&self, i: u32) -> bool
fn get_from_layer(&self, layer: usize, idx: usize) -> usize
fn is_empty(&self) -> bool
fn iter(self) -> BitIter<Self>ⓘ
impl<T> BitXor<T> for BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetXor<BitSet, T>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: T) -> <BitSet as BitXor<T>>::Output
impl<'a, T> BitXor<T> for &'a BitSet where
T: BitSetLike,
T: BitSetLike,
type Output = BitSetXor<&'a BitSet, T>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: T) -> <&'a BitSet as BitXor<T>>::Output
impl<'a, B> BitXorAssign<&'a B> for BitSet where
B: BitSetLike,
B: BitSetLike,
fn bitxor_assign(&mut self, lhs: &B)
impl Clone for BitSet
fn clone(&self) -> BitSet
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for BitSet
impl Default for BitSet
impl DrainableBitSet for BitSet
fn remove(&mut self, i: u32) -> bool
fn drain(&'a mut self) -> DrainBitIter<'a, Self>ⓘNotable traits for DrainBitIter<'a, T>
impl<'a, T> Iterator for DrainBitIter<'a, T> where
T: DrainableBitSet, type Item = u32;
Notable traits for DrainBitIter<'a, T>
impl<'a, T> Iterator for DrainBitIter<'a, T> where
T: DrainableBitSet, type Item = u32;
impl Eq for BitSet
impl<'a> Extend<&'a u32> for BitSet
fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = &'a u32>,
T: IntoIterator<Item = &'a u32>,
fn extend_one(&mut self, item: A)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]
impl Extend<u32> for BitSet
fn extend<T>(&mut self, iter: T) where
T: IntoIterator<Item = u32>,
T: IntoIterator<Item = u32>,
fn extend_one(&mut self, item: A)
[src]
fn extend_reserve(&mut self, additional: usize)
[src]
impl<'a> FromIterator<&'a u32> for BitSet
fn from_iter<T>(iter: T) -> BitSet where
T: IntoIterator<Item = &'a u32>,
T: IntoIterator<Item = &'a u32>,
impl FromIterator<u32> for BitSet
fn from_iter<T>(iter: T) -> BitSet where
T: IntoIterator<Item = u32>,
T: IntoIterator<Item = u32>,
impl<'a> IntoIterator for &'a BitSet
type Item = <BitIter<&'a BitSet> as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = BitIter<&'a BitSet>
Which kind of iterator are we turning this into?
fn into_iter(self) -> <&'a BitSet as IntoIterator>::IntoIter
impl IntoIterator for BitSet
type Item = <BitIter<BitSet> as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = BitIter<BitSet>
Which kind of iterator are we turning this into?
fn into_iter(self) -> <BitSet as IntoIterator>::IntoIter
impl<'a> Join for &'a BitSet
type Type = u32
Type of joined components.
type Value = ()
Type of joined storages.
type Mask = &'a BitSet
Type of joined bit mask.
unsafe fn open(
self
) -> (<&'a BitSet as Join>::Mask, <&'a BitSet as Join>::Value)
self
) -> (<&'a BitSet as Join>::Mask, <&'a BitSet as Join>::Value)
unsafe fn get(
&mut <&'a BitSet as Join>::Value,
id: u32
) -> <&'a BitSet as Join>::Type
&mut <&'a BitSet as Join>::Value,
id: u32
) -> <&'a BitSet as Join>::Type
fn join(self) -> JoinIter<Self>ⓘ
fn maybe(self) -> MaybeJoin<Self>
fn is_unconstrained() -> bool
impl Join for BitSet
type Type = u32
Type of joined components.
type Value = ()
Type of joined storages.
type Mask = BitSet
Type of joined bit mask.
unsafe fn open(self) -> (<BitSet as Join>::Mask, <BitSet as Join>::Value)
unsafe fn get(&mut <BitSet as Join>::Value, id: u32) -> <BitSet as Join>::Type
fn join(self) -> JoinIter<Self>ⓘ
fn maybe(self) -> MaybeJoin<Self>
fn is_unconstrained() -> bool
impl Not for BitSet
type Output = BitSetNot<BitSet>
The resulting type after applying the !
operator.
fn not(self) -> <BitSet as Not>::Output
impl<'a> Not for &'a BitSet
type Output = BitSetNot<&'a BitSet>
The resulting type after applying the !
operator.
fn not(self) -> <&'a BitSet as Not>::Output
impl PartialEq<BitSet> for BitSet
Auto Trait Implementations
impl RefUnwindSafe for BitSet
impl Send for BitSet
impl Sync for BitSet
impl Unpin for BitSet
impl UnwindSafe for BitSet
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Any for T where
T: Any,
T: Any,
fn get_type_id(&self) -> TypeId
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Event for T where
T: Send + Sync + 'static,
T: Send + Sync + 'static,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Resource for T where
T: Any,
T: Any,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> TryDefault for T where
T: Default,
T: Default,
fn try_default() -> Result<T, String>
fn unwrap_default() -> Self
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,