Struct rin::ecs::ReadOption

pub struct ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>,  { /* fields omitted */ }

Operator that matches every entity no matter if it has the component or not with read only access to that component

It returns an option that will be None if the entity doesn’t have this component

for (pos, vel) in entities.iter_for::<(ReadOption<Position>, Read<Velocity>)>(){
    if let Some(pos) = pos {
        // ...
    }
}

Will select all entities that optionally have Position and have a Velocity component pos will be None for those that don’t have Position

Methods from Deref<Target = Option<<<T as Component>::Storage as Storage<'a, T>>::Get>>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]

pub const fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

#[must_use = "if you intended to assert that this doesn't have a value, consider \ `.and_then(|| panic!(\"`Option` had a value when expected `None`\"))` instead"]

pub const fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

#[must_use]

pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

🔬 This is a nightly-only experimental API. (option_result_contains)

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

pub const fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub const fn iter(&self) -> Iter<'_, T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

pub fn as_deref(&self) -> Option<&<T as Deref>::Target>

Converts from Option<T> (or &Option<T>) to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Examples

let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));

let x: Option<String> = None;
assert_eq!(x.as_deref(), None);

Trait Implementations

impl<'a, T> DataAccesses for ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

pub fn reads() -> Vec<TypeId, Global>

pub fn writes() -> Vec<TypeId, Global>

impl<'a, T> Deref for ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Target = Option<<<T as Component>::Storage as Storage<'a, T>>::Get>

The resulting type after dereferencing.

pub fn deref(
    &self
) -> &Option<<<T as Component>::Storage as Storage<'a, T>>::Get>

Dereferences the value.

impl<'a, T> FromComponent<'a, Option<<<T as Component>::Storage as Storage<'a, T>>::Get>> for ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

pub fn from_component(
    component: Option<<<T as Component>::Storage as Storage<'a, T>>::Get>
) -> ReadOption<'a, T>

impl<'a, T> UnorderedData<'a> for ReadOption<'a, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>, 

type Iter = IterOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

type IterMut = IterOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

type Components = T

type ComponentsRef = Option<<<T as Component>::Storage as Storage<'a, T>>::Get>

type Storage = StorageOption<'a, T, <T as Component>::Storage, ReadGuardRef<'a, <T as Component>::Storage>>

pub fn query_mask<E>(entities: &E) -> Bitmask where
    E: EntitiesStorage, 

pub fn into_iter<E>(
    entities: &'a E
) -> <ReadOption<'a, T> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn into_iter_mut<E>(
    entities: &'a E
) -> <ReadOption<'a, T> as UnorderedData<'a>>::Iter where
    E: EntitiesStorage, 

pub fn storage<E>(
    entities: &'a E
) -> Option<<ReadOption<'a, T> as UnorderedData<'a>>::Storage> where
    E: EntitiesStorage, 

impl<'_, '_, T> SafeIter<'_> for ReadOption<'_, T> where
    T: Component,
    <T as Component>::Storage: for<'s> Storage<'s, T>,