Struct apecs::Read

pub struct Read<T: IsResource, G: Gen<T> = SomeDefault> { /* private fields */ }

Immutably borrowed resource that may be created by default.

Read and Write are the main way systems interact with resources. When fetched The wrapped type T will automatically be created b default. If fetched as Write<T, NoDefault> the fetch will err if the resource doesn’t already exist.

After a successful fetch, the resource will be automatically sent back to the world on drop.

Read has two type parameters:

• T - The type of the resource.
• G - The method by which the resource can be generated if it doesn’t exist. By default this is SomeDefault, which denotes creating the resource using its default instance. Another option is NoDefault which fails to generate the resource.

use apecs::*;

let mut world = World::default();
{
    let default_number = world.fetch::<Read<u32>>();
    assert_eq!(Some(0), default_number.map(|n| *n).ok());
}
{
    let no_number = world.fetch::<Read<f32, NoDefault>>();
    assert!(no_number.is_err());
}

Implementations

impl<T: IsResource, G: Gen<T>> Read<T, G>

pub fn inner(&self) -> &T

An explicit method of getting a reference to the inner type without Deref.

Trait Implementations

impl<'a, T: IsResource, G: Gen<T> + IsResource> CanFetch for Read<T, G>

fn borrows() -> Vec<Borrow>

fn construct(loan_mngr: &mut LoanManager<'_>) -> Result<Self>

Attempt to construct Self with the given LoanManager.

fn plugin() -> Plugin

Return a plugin containing the systems and sub-resources required to create and use the type.

impl<'a, T: IsResource, G: Gen<T>> Deref for Read<T, G>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T: Send + Sync + 'static, G: Gen<T>> IntoIterator for &'a Read<T, G>where
    &'a T: IntoIterator,

type Item = <<&'a T as IntoIterator>::IntoIter as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, S: Send + Sync + 'static, G: Gen<S>> IntoParallelIterator for &'a Read<S, G>where
    &'a S: IntoParallelIterator,

type Iter = <&'a S as IntoParallelIterator>::Iter

The parallel iterator type that will be created.

type Item = <&'a S as IntoParallelIterator>::Item

The type of item that the parallel iterator will produce.

fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.