Trait apecs::IsBundle

pub trait IsBundle: Sized {
    type EntryBundle: IsBundle;
    type MutBundle: IsBundle;

    fn unordered_types() -> SmallVec<[TypeId; 4]>;
    fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>;
    fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>;
    fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>;
    fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle;
    fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self;

    fn ordered_types() -> Result<SmallVec<[TypeId; 4]>> { ... }
    fn empty_any_bundle() -> Result<AnyBundle> { ... }
    fn try_into_any_bundle(self) -> Result<AnyBundle> { ... }
}

Provides runtime type info about bundles and more.

Required Associated Types

type EntryBundle: IsBundle

A bundle where each of this bundle’s types are wrapped in Entry.

type MutBundle: IsBundle

A bundle where each of this bundle’s types are prefixed with &’static mut.

Required Methods

fn unordered_types() -> SmallVec<[TypeId; 4]>

Produces a list of types of a bundle, ordered by their position in the tuple.

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

Produces an unordered list of empty AnyVecs to store components, with the given capacity.

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

Produces a list of AnyVecs of length 1, each containing its corresponding component. The list is ordered by each component’s position in the tuple.

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

Provided Methods

fn ordered_types() -> Result<SmallVec<[TypeId; 4]>>

Produces a list of types in a bundle, ordered ascending.

Errors if the bundle contains duplicate types.

fn empty_any_bundle() -> Result<AnyBundle>

fn try_into_any_bundle(self) -> Result<AnyBundle>

Converts the tuple into a type-erased AnyBundle.

Errs

Errs if the tuple contains duplicate types.

Implementations on Foreign Types

impl<A: Send + Sync + 'static> IsBundle for (A,)

type EntryBundle = (Entry<A>,)

type MutBundle = (&'static mut A,)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B> IsBundle for (A, B)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>)

type MutBundle = (&'static mut A, &'static mut B)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C> IsBundle for (A, B, C)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D> IsBundle for (A, B, C, D)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E> IsBundle for (A, B, C, D, E)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F> IsBundle for (A, B, C, D, E, F)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G> IsBundle for (A, B, C, D, E, F, G)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G, H> IsBundle for (A, B, C, D, E, F, G, H)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,
    H: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>, Entry<H>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G, &'static mut H)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G, H, I> IsBundle for (A, B, C, D, E, F, G, H, I)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,
    H: Send + Sync + 'static,
    I: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>, Entry<H>, Entry<I>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G, &'static mut H, &'static mut I)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G, H, I, J> IsBundle for (A, B, C, D, E, F, G, H, I, J)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,
    H: Send + Sync + 'static,
    I: Send + Sync + 'static,
    J: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>, Entry<H>, Entry<I>, Entry<J>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G, &'static mut H, &'static mut I, &'static mut J)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K> IsBundle for (A, B, C, D, E, F, G, H, I, J, K)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,
    H: Send + Sync + 'static,
    I: Send + Sync + 'static,
    J: Send + Sync + 'static,
    K: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>, Entry<H>, Entry<I>, Entry<J>, Entry<K>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G, &'static mut H, &'static mut I, &'static mut J, &'static mut K)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

impl<A, B, C, D, E, F, G, H, I, J, K, L> IsBundle for (A, B, C, D, E, F, G, H, I, J, K, L)where
    A: Send + Sync + 'static,
    B: Send + Sync + 'static,
    C: Send + Sync + 'static,
    D: Send + Sync + 'static,
    E: Send + Sync + 'static,
    F: Send + Sync + 'static,
    G: Send + Sync + 'static,
    H: Send + Sync + 'static,
    I: Send + Sync + 'static,
    J: Send + Sync + 'static,
    K: Send + Sync + 'static,
    L: Send + Sync + 'static,

type EntryBundle = (Entry<A>, Entry<B>, Entry<C>, Entry<D>, Entry<E>, Entry<F>, Entry<G>, Entry<H>, Entry<I>, Entry<J>, Entry<K>, Entry<L>)

type MutBundle = (&'static mut A, &'static mut B, &'static mut C, &'static mut D, &'static mut E, &'static mut F, &'static mut G, &'static mut H, &'static mut I, &'static mut J, &'static mut K, &'static mut L)

fn unordered_types() -> SmallVec<[TypeId; 4]>

fn empty_vecs() -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn try_from_any_bundle(bundle: AnyBundle) -> Result<Self>

fn into_vecs(self) -> SmallVec<[AnyVec<dyn Send + Sync + 'static>; 4]>

fn into_entry_bundle(self, entity_id: usize) -> Self::EntryBundle

fn from_entry_bundle(entry_bundle: Self::EntryBundle) -> Self

Implementors