Trait oxygengine_core::ecs::hibitset::BitSetLike[−]

pub trait BitSetLike {
    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>ⓘ
Notable traits for BitIter<T>
impl<T> Iterator for BitIter<T> where
    T: BitSetLike,     type Item = u32;
 { ... }
}
Expand description

A generic interface for BitSetLike-like types.

Every BitSetLike is hierarchical, meaning that there are multiple levels that branch out in a tree like structure.

Layer0 each bit represents one Index of the set Layer1 each bit represents one usize of Layer0, and will be set only if the word below it is not zero. Layer2 has the same arrangement but with Layer1, and Layer3 with Layer2.

This arrangement allows for rapid jumps across the key-space.

Required methods

Return a usize where each bit represents if any word in layer2 has been set.

Return the usize from the array of usizes that indicates if any bit has been set in layer1

Return the usize from the array of usizes that indicates if any bit has been set in layer0

Return a usize that maps to the direct 1:1 association with each index of the set

Allows checking if set bit is contained in the bit set.

Provided methods

Gets the usize corresponding to layer and index.

The layer should be in the range [0, 3]

Returns true if this BitSetLike contains nothing, and false otherwise.

Create an iterator that will scan over the keyspace

Trait Implementations

Type of joined components.

Type of joined storages.

Type of joined bit mask.

Open this join by returning the mask and the storages. Read more

Get a joined component value by a given index. Read more

Create a joined iterator over the contents.

Returns a Join-able structure that yields all indices, returning None for all missing elements and Some(T) for found elements. Read more

If this Join typically returns all indices in the mask, then iterating over only it or combined with other joins that are also dangerous will cause the JoinIter/ParJoin to go through all indices which is usually not what is wanted and will kill performance. Read more

Implementations on Foreign Types

Implementors