Struct oxygengine_core::ecs::hibitset::BitSetXor

pub struct BitSetXor<A, B>(pub A, pub B)
 where
    A: BitSetLike,
    B: BitSetLike;

BitSetXor takes two BitSetLike items, and merges the masks returning a new virtual set, which represents an merged of the two original sets.

Trait Implementations

impl<A, B, T> BitAnd<T> for BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetAnd<BitSetXor<A, B>, T>

The resulting type after applying the & operator.

pub fn bitand(self, rhs: T) -> <BitSetXor<A, B> as BitAnd<T>>::Output

Performs the & operation.

impl<'a, A, B, T> BitAnd<T> for &'a BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetAnd<&'a BitSetXor<A, B>, T>

The resulting type after applying the & operator.

pub fn bitand(self, rhs: T) -> <&'a BitSetXor<A, B> as BitAnd<T>>::Output

Performs the & operation.

impl<'a, A, B, T> BitOr<T> for &'a BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetOr<&'a BitSetXor<A, B>, T>

The resulting type after applying the | operator.

pub fn bitor(self, rhs: T) -> <&'a BitSetXor<A, B> as BitOr<T>>::Output

Performs the | operation.

impl<A, B, T> BitOr<T> for BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetOr<BitSetXor<A, B>, T>

The resulting type after applying the | operator.

pub fn bitor(self, rhs: T) -> <BitSetXor<A, B> as BitOr<T>>::Output

Performs the | operation.

impl<A, B> BitSetLike for BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

pub fn layer3(&self) -> usize

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

pub fn layer2(&self, id: usize) -> usize

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

pub fn layer1(&self, id: usize) -> usize

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

pub fn layer0(&self, id: usize) -> usize

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

pub fn contains(&self, i: u32) -> bool

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

fn get_from_layer(&self, layer: usize, idx: usize) -> usize

Gets the usize corresponding to layer and index.

fn is_empty(&self) -> bool

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

fn iter(self) -> BitIter<Self>

Create an iterator that will scan over the keyspace

impl<'a, A, B, T> BitXor<T> for &'a BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetXor<&'a BitSetXor<A, B>, T>

The resulting type after applying the ^ operator.

pub fn bitxor(self, rhs: T) -> <&'a BitSetXor<A, B> as BitXor<T>>::Output

Performs the ^ operation.

impl<A, B, T> BitXor<T> for BitSetXor<A, B> where
    T: BitSetLike,
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetXor<BitSetXor<A, B>, T>

The resulting type after applying the ^ operator.

pub fn bitxor(self, rhs: T) -> <BitSetXor<A, B> as BitXor<T>>::Output

Performs the ^ operation.

impl<A, B> Clone for BitSetXor<A, B> where
    A: Clone + BitSetLike,
    B: Clone + BitSetLike, 

pub fn clone(&self) -> BitSetXor<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, B> Debug for BitSetXor<A, B> where
    A: Debug + BitSetLike,
    B: Debug + BitSetLike, 

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

Formats the value using the given formatter.

impl<'a, A, B> IntoIterator for &'a BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Item = <BitIter<&'a BitSetXor<A, B>> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = BitIter<&'a BitSetXor<A, B>>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'a BitSetXor<A, B> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<A, B> IntoIterator for BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Item = <BitIter<BitSetXor<A, B>> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = BitIter<BitSetXor<A, B>>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <BitSetXor<A, B> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<A, B> Join for BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Type = u32

Type of joined components.

type Value = ()

Type of joined storages.

type Mask = BitSetXor<A, B>

Type of joined bit mask.

pub unsafe fn open(
    self
) -> (<BitSetXor<A, B> as Join>::Mask, <BitSetXor<A, B> as Join>::Value)

Open this join by returning the mask and the storages.

pub unsafe fn get(
    &mut <BitSetXor<A, B> as Join>::Value,
    id: u32
) -> <BitSetXor<A, B> as Join>::Type

Get a joined component value by a given index.

fn join(self) -> JoinIter<Self>

Create a joined iterator over the contents.

fn maybe(self) -> MaybeJoin<Self>

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

fn is_unconstrained() -> bool

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.

impl<A, B> Not for BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetNot<BitSetXor<A, B>>

The resulting type after applying the ! operator.

pub fn not(self) -> <BitSetXor<A, B> as Not>::Output

Performs the unary ! operation.

impl<'a, A, B> Not for &'a BitSetXor<A, B> where
    A: BitSetLike,
    B: BitSetLike, 

type Output = BitSetNot<&'a BitSetXor<A, B>>

The resulting type after applying the ! operator.

pub fn not(self) -> <&'a BitSetXor<A, B> as Not>::Output

Performs the unary ! operation.