Struct rin::ecs::WriteOption [−][src]
pub struct WriteOption<'a, T> { /* fields omitted */ }
Operator that matches every entity no matter if it has the component or not with read and write 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_mut::<(WriteOption<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<&'a mut T>>
#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]pub const fn is_some(&self) -> bool
1.0.0 (const: 1.48.0)[src]
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
1.0.0 (const: 1.48.0)[src]
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>,
[src]
U: PartialEq<T>,
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>
1.0.0 (const: 1.48.0)[src]
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_mut(&mut self) -> Option<&mut T>
1.0.0[src]
Converts from &mut Option<T>
to Option<&mut T>
.
Examples
let mut x = Some(2); match x.as_mut() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42));
pub fn as_pin_ref(self: Pin<&Option<T>>) -> Option<Pin<&T>>
1.33.0[src]
pub fn as_pin_mut(self: Pin<&mut Option<T>>) -> Option<Pin<&mut T>>
1.33.0[src]
pub const fn iter(&self) -> Iter<'_, T>
1.0.0[src]
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 iter_mut(&mut self) -> IterMut<'_, T>
1.0.0[src]
Returns a mutable iterator over the possibly contained value.
Examples
let mut x = Some(4); match x.iter_mut().next() { Some(v) => *v = 42, None => {}, } assert_eq!(x, Some(42)); let mut x: Option<u32> = None; assert_eq!(x.iter_mut().next(), None);
pub fn insert(&mut self, value: T) -> &mut T
1.53.0[src]
Inserts value
into the option then returns a mutable reference to it.
If the option already contains a value, the old value is dropped.
See also Option::get_or_insert
, which doesn’t update the value if
the option already contains Some
.
Example
let mut opt = None; let val = opt.insert(1); assert_eq!(*val, 1); assert_eq!(opt.unwrap(), 1); let val = opt.insert(2); assert_eq!(*val, 2); *val = 3; assert_eq!(opt.unwrap(), 3);
pub fn get_or_insert(&mut self, value: T) -> &mut T
1.20.0[src]
Inserts value
into the option if it is None
, then
returns a mutable reference to the contained value.
See also Option::insert
, which updates the value even if
the option already contains Some
.
Examples
let mut x = None; { let y: &mut u32 = x.get_or_insert(5); assert_eq!(y, &5); *y = 7; } assert_eq!(x, Some(7));
pub fn get_or_insert_default(&mut self) -> &mut T where
T: Default,
[src]
T: Default,
option_get_or_insert_default
)Inserts the default value into the option if it is None
, then
returns a mutable reference to the contained value.
Examples
#![feature(option_get_or_insert_default)] let mut x = None; { let y: &mut u32 = x.get_or_insert_default(); assert_eq!(y, &0); *y = 7; } assert_eq!(x, Some(7));
pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut T where
F: FnOnce() -> T,
1.20.0[src]
F: FnOnce() -> T,
Inserts a value computed from f
into the option if it is None
,
then returns a mutable reference to the contained value.
Examples
let mut x = None; { let y: &mut u32 = x.get_or_insert_with(|| 5); assert_eq!(y, &5); *y = 7; } assert_eq!(x, Some(7));
pub fn take(&mut self) -> Option<T>
1.0.0[src]
Takes the value out of the option, leaving a None
in its place.
Examples
let mut x = Some(2); let y = x.take(); assert_eq!(x, None); assert_eq!(y, Some(2)); let mut x: Option<u32> = None; let y = x.take(); assert_eq!(x, None); assert_eq!(y, None);
pub fn replace(&mut self, value: T) -> Option<T>
1.31.0[src]
Replaces the actual value in the option by the value given in parameter,
returning the old value if present,
leaving a Some
in its place without deinitializing either one.
Examples
let mut x = Some(2); let old = x.replace(5); assert_eq!(x, Some(5)); assert_eq!(old, Some(2)); let mut x = None; let old = x.replace(3); assert_eq!(x, Some(3)); assert_eq!(old, None);
pub fn as_deref(&self) -> Option<&<T as Deref>::Target>
1.40.0[src]
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);
pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>
1.40.0[src]
Converts from Option<T>
(or &mut Option<T>
) to Option<&mut T::Target>
.
Leaves the original Option
in-place, creating a new one containing a mutable reference to
the inner type’s Deref::Target
type.
Examples
let mut x: Option<String> = Some("hey".to_owned()); assert_eq!(x.as_deref_mut().map(|x| { x.make_ascii_uppercase(); x }), Some("HEY".to_owned().as_mut_str()));
Trait Implementations
impl<'a, T> DataAccesses for WriteOption<'a, T> where
T: Component,
<T as Component>::Storage: for<'s> Storage<'s, T>,
[src]
impl<'a, T> DataAccesses for WriteOption<'a, T> where
T: Component,
<T as Component>::Storage: for<'s> Storage<'s, T>,
[src]impl<'a, T> Deref for WriteOption<'a, T> where
T: Component,
[src]
impl<'a, T> Deref for WriteOption<'a, T> where
T: Component,
[src]impl<'a, T> DerefMut for WriteOption<'a, T> where
T: Component,
[src]
impl<'a, T> DerefMut for WriteOption<'a, T> where
T: Component,
[src]impl<'a, T> FromComponent<'a, Option<&'a mut T>> for WriteOption<'a, T> where
T: Component,
[src]
impl<'a, T> FromComponent<'a, Option<&'a mut T>> for WriteOption<'a, T> where
T: Component,
[src]pub fn from_component(component: Option<&'a mut T>) -> WriteOption<'a, T>
[src]
impl<'a, T> UnorderedData<'a> for WriteOption<'a, T> where
T: Component,
<T as Component>::Storage: for<'s> Storage<'s, T>,
[src]
impl<'a, T> UnorderedData<'a> for WriteOption<'a, T> where
T: Component,
<T as Component>::Storage: for<'s> Storage<'s, T>,
[src]type Iter = IterOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>
type IterMut = IterOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>
type Components = T
type ComponentsRef = Option<<<T as Component>::Storage as Storage<'a, T>>::GetMut>
type Storage = StorageOptionMut<'a, T, WriteGuardRef<'a, <T as Component>::Storage, <T as Component>::MutStorageCacheGuard>>
pub fn query_mask<E>(entities: &E) -> Bitmask where
E: EntitiesStorage,
[src]
E: EntitiesStorage,
pub fn into_iter<E>(
entities: &'a E
) -> <WriteOption<'a, T> as UnorderedData<'a>>::Iter where
E: EntitiesStorage,
[src]
entities: &'a E
) -> <WriteOption<'a, T> as UnorderedData<'a>>::Iter where
E: EntitiesStorage,
pub fn into_iter_mut<E>(
entities: &'a E
) -> <WriteOption<'a, T> as UnorderedData<'a>>::Iter where
E: EntitiesStorage,
[src]
entities: &'a E
) -> <WriteOption<'a, T> as UnorderedData<'a>>::Iter where
E: EntitiesStorage,
pub fn storage<E>(
entities: &'a E
) -> Option<<WriteOption<'a, T> as UnorderedData<'a>>::Storage> where
E: EntitiesStorage,
[src]
entities: &'a E
) -> Option<<WriteOption<'a, T> as UnorderedData<'a>>::Storage> where
E: EntitiesStorage,
impl<'_, '_, T> SafeIter<'_> for WriteOption<'_, T>
[src]
Auto Trait Implementations
impl<'a, T> RefUnwindSafe for WriteOption<'a, T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<'a, T> Send for WriteOption<'a, T> where
T: Send,
T: Send,
impl<'a, T> Sync for WriteOption<'a, T> where
T: Sync,
T: Sync,
impl<'a, T> Unpin for WriteOption<'a, T>
impl<'a, T> !UnwindSafe for WriteOption<'a, T>
Blanket Implementations
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]
impl<T> DowncastSync for T where
T: Any + Send + Sync,
[src]impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]pub fn to_subset(&self) -> Option<SS>
[src]
pub fn is_in_subset(&self) -> bool
[src]
pub fn to_subset_unchecked(&self) -> SS
[src]
pub fn from_subset(element: &SS) -> SP
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]