Struct legion::query::And

pub struct And<T> { /* fields omitted */ }

A filter which requires all filters within T match.

Trait Implementations

impl<A, B, C, D, E, F, G, H> BitAnd<Passthrough> for And<(A, B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<B, C, D, E, F, G, H> BitAnd<Passthrough> for And<(B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<C, D, E, F, G, H> BitAnd<Passthrough> for And<(C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<D, E, F, G, H> BitAnd<Passthrough> for And<(D, E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<E, F, G, H> BitAnd<Passthrough> for And<(E, F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<F, G, H> BitAnd<Passthrough> for And<(F, G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<G, H> BitAnd<Passthrough> for And<(G, H)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<H> BitAnd<Passthrough> for And<(H,)>

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, _: Passthrough) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(A, B, C, D, E, F, G, H)>

type Output = And<(A, B, C, D, E, F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<B, C, D, E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(B, C, D, E, F, G, H)>

type Output = And<(B, C, D, E, F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<C, D, E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(C, D, E, F, G, H)>

type Output = And<(C, D, E, F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<D, E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(D, E, F, G, H)>

type Output = And<(D, E, F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<E, F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(E, F, G, H)>

type Output = And<(E, F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<F, G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(F, G, H)>

type Output = And<(F, G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<G, H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(G, H)>

type Output = And<(G, H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<H, Rhs: ActiveFilter> BitAnd<Rhs> for And<(H,)>

type Output = And<(H, Rhs)>

The resulting type after applying the & operator.

fn bitand(self, rhs: Rhs) -> Self::Output

Performs the & operation.

impl<A, B, C, D, E, F, G, H> BitOr<Passthrough> for And<(A, B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<B, C, D, E, F, G, H> BitOr<Passthrough> for And<(B, C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<C, D, E, F, G, H> BitOr<Passthrough> for And<(C, D, E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<D, E, F, G, H> BitOr<Passthrough> for And<(D, E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<E, F, G, H> BitOr<Passthrough> for And<(E, F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<F, G, H> BitOr<Passthrough> for And<(F, G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<G, H> BitOr<Passthrough> for And<(G, H)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<H> BitOr<Passthrough> for And<(H,)>

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, _: Passthrough) -> Self::Output

Performs the | operation.

impl<A, B, C, D, E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(A, B, C, D, E, F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<B, C, D, E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(B, C, D, E, F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<C, D, E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(C, D, E, F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<D, E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(D, E, F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<E, F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(E, F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<F, G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(F, G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<G, H, Rhs: ActiveFilter> BitOr<Rhs> for And<(G, H)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<H, Rhs: ActiveFilter> BitOr<Rhs> for And<(H,)>

type Output = Or<(Self, Rhs)>

The resulting type after applying the | operator.

fn bitor(self, rhs: Rhs) -> Self::Output

Performs the | operation.

impl<T: Clone> Clone for And<T>

fn clone(&self) -> And<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for And<T>

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

Formats the value using the given formatter.

impl<A: Default, B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default> Default for And<(A, B, C, D, E, F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<B: Default, C: Default, D: Default, E: Default, F: Default, G: Default, H: Default> Default for And<(B, C, D, E, F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<C: Default, D: Default, E: Default, F: Default, G: Default, H: Default> Default for And<(C, D, E, F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<D: Default, E: Default, F: Default, G: Default, H: Default> Default for And<(D, E, F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Default, F: Default, G: Default, H: Default> Default for And<(E, F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<F: Default, G: Default, H: Default> Default for And<(F, G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<G: Default, H: Default> Default for And<(G, H)>

fn default() -> Self

Returns the “default value” for a type.

impl<H: Default> Default for And<(H,)>

fn default() -> Self

Returns the “default value” for a type.

impl<A: DynamicFilter, B: DynamicFilter, C: DynamicFilter, D: DynamicFilter, E: DynamicFilter, F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(A, B, C, D, E, F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<B: DynamicFilter, C: DynamicFilter, D: DynamicFilter, E: DynamicFilter, F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(B, C, D, E, F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<C: DynamicFilter, D: DynamicFilter, E: DynamicFilter, F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(C, D, E, F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<D: DynamicFilter, E: DynamicFilter, F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(D, E, F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<E: DynamicFilter, F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(E, F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<F: DynamicFilter, G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(F, G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<G: DynamicFilter, H: DynamicFilter> DynamicFilter for And<(G, H)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<H: DynamicFilter> DynamicFilter for And<(H,)>

fn prepare(&mut self, world: WorldId)

Prepares the filter to run.

fn matches_archetype<Fet: Fetch>(&mut self, fetch: &Fet) -> FilterResult

Calculates the filter’s result for the given archetype data.

impl<A: GroupMatcher, B: GroupMatcher, C: GroupMatcher, D: GroupMatcher, E: GroupMatcher, F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(A, B, C, D, E, F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<B: GroupMatcher, C: GroupMatcher, D: GroupMatcher, E: GroupMatcher, F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(B, C, D, E, F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<C: GroupMatcher, D: GroupMatcher, E: GroupMatcher, F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(C, D, E, F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<D: GroupMatcher, E: GroupMatcher, F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(D, E, F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<E: GroupMatcher, F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(E, F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<F: GroupMatcher, G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(F, G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<G: GroupMatcher, H: GroupMatcher> GroupMatcher for And<(G, H)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<H: GroupMatcher> GroupMatcher for And<(H,)>

fn can_match_group() -> bool

Returns true if the filter may potentially match a group.

fn group_components() -> Vec<ComponentTypeId>

Returns the components that are required to be present in a group.

impl<A: LayoutFilter, B: LayoutFilter, C: LayoutFilter, D: LayoutFilter, E: LayoutFilter, F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(A, B, C, D, E, F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<B: LayoutFilter, C: LayoutFilter, D: LayoutFilter, E: LayoutFilter, F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(B, C, D, E, F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<C: LayoutFilter, D: LayoutFilter, E: LayoutFilter, F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(C, D, E, F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<D: LayoutFilter, E: LayoutFilter, F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(D, E, F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<E: LayoutFilter, F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(E, F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<F: LayoutFilter, G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(F, G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<G: LayoutFilter, H: LayoutFilter> LayoutFilter for And<(G, H)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<H: LayoutFilter> LayoutFilter for And<(H,)>

fn matches_layout(&self, components: &[ComponentTypeId]) -> FilterResult

Calculates the filter’s result for the given entity layout.

impl<A, B, C, D, E, F, G, H> Not for And<(A, B, C, D, E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<B, C, D, E, F, G, H> Not for And<(B, C, D, E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<C, D, E, F, G, H> Not for And<(C, D, E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<D, E, F, G, H> Not for And<(D, E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<E, F, G, H> Not for And<(E, F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<F, G, H> Not for And<(F, G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<G, H> Not for And<(G, H)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<H> Not for And<(H,)>

type Output = Not<Self>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.