pub struct EntityMut<'w> { /* private fields */ }
Expand description
Provides mutable access to a single entity and all of its components.
Contrast with EntityWorldMut
, which allows adding and removing components,
despawning the entity, and provides mutable access to the entire world.
Because of this, EntityWorldMut
cannot coexist with any other world accesses.
§Examples
Disjoint mutable access.
fn disjoint_system(
query1: Query<EntityMut, With<A>>,
query2: Query<EntityMut, Without<A>>,
) {
// ...
}
Implementations§
Source§impl<'w> EntityMut<'w>
impl<'w> EntityMut<'w>
Sourcepub fn reborrow(&mut self) -> EntityMut<'_>
pub fn reborrow(&mut self) -> EntityMut<'_>
Returns a new instance with a shorter lifetime.
This is useful if you have &mut EntityMut
, but you need EntityMut
.
Sourcepub fn into_readonly(self) -> EntityRef<'w>
pub fn into_readonly(self) -> EntityRef<'w>
Consumes self
and returns read-only access to all of the entity’s
components, with the world 'w
lifetime.
Sourcepub fn as_readonly(&self) -> EntityRef<'_>
pub fn as_readonly(&self) -> EntityRef<'_>
Gets read-only access to all of the entity’s components.
Sourcepub fn location(&self) -> EntityLocation
pub fn location(&self) -> EntityLocation
Gets metadata indicating the location where the current entity is stored.
Sourcepub fn archetype(&self) -> &Archetype
pub fn archetype(&self) -> &Archetype
Returns the archetype that the current entity belongs to.
Sourcepub fn contains<T: Component>(&self) -> bool
pub fn contains<T: Component>(&self) -> bool
Returns true
if the current entity has a component of type T
.
Otherwise, this returns false
.
§Notes
If you do not know the concrete type of a component, consider using
Self::contains_id
or Self::contains_type_id
.
Sourcepub fn contains_id(&self, component_id: ComponentId) -> bool
pub fn contains_id(&self, component_id: ComponentId) -> bool
Returns true
if the current entity has a component identified by component_id
.
Otherwise, this returns false.
§Notes
- If you know the concrete type of the component, you should prefer
Self::contains
. - If you know the component’s
TypeId
but not itsComponentId
, consider usingSelf::contains_type_id
.
Sourcepub fn contains_type_id(&self, type_id: TypeId) -> bool
pub fn contains_type_id(&self, type_id: TypeId) -> bool
Returns true
if the current entity has a component with the type identified by type_id
.
Otherwise, this returns false.
§Notes
- If you know the concrete type of the component, you should prefer
Self::contains
. - If you have a
ComponentId
instead of aTypeId
, consider usingSelf::contains_id
.
Sourcepub fn get<T: Component>(&self) -> Option<&T>
pub fn get<T: Component>(&self) -> Option<&T>
Gets access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
Sourcepub fn components<Q: ReadOnlyQueryData>(&self) -> Q::Item<'_>
pub fn components<Q: ReadOnlyQueryData>(&self) -> Q::Item<'_>
Returns read-only components for the current entity that match the query Q
.
§Panics
If the entity does not have the components required by the query Q
.
Sourcepub fn get_components<Q: ReadOnlyQueryData>(&self) -> Option<Q::Item<'_>>
pub fn get_components<Q: ReadOnlyQueryData>(&self) -> Option<Q::Item<'_>>
Returns read-only components for the current entity that match the query Q
,
or None
if the entity does not have the components required by the query Q
.
Sourcepub fn into_borrow<T: Component>(self) -> Option<&'w T>
pub fn into_borrow<T: Component>(self) -> Option<&'w T>
Consumes self
and gets access to the component of type T
with the
world 'w
lifetime for the current entity.
Returns None
if the entity does not have a component of type T
.
Sourcepub fn get_ref<T: Component>(&self) -> Option<Ref<'_, T>>
pub fn get_ref<T: Component>(&self) -> Option<Ref<'_, T>>
Gets access to the component of type T
for the current entity,
including change detection information as a Ref
.
Returns None
if the entity does not have a component of type T
.
Sourcepub fn into_ref<T: Component>(self) -> Option<Ref<'w, T>>
pub fn into_ref<T: Component>(self) -> Option<Ref<'w, T>>
Consumes self
and gets access to the component of type T
with world
'w
lifetime for the current entity, including change detection information
as a [Ref<'w>
].
Returns None
if the entity does not have a component of type T
.
Sourcepub fn get_mut<T: Component<Mutability = Mutable>>(
&mut self,
) -> Option<Mut<'_, T>>
pub fn get_mut<T: Component<Mutability = Mutable>>( &mut self, ) -> Option<Mut<'_, T>>
Gets mutable access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
Sourcepub unsafe fn get_mut_assume_mutable<T: Component>(
&mut self,
) -> Option<Mut<'_, T>>
pub unsafe fn get_mut_assume_mutable<T: Component>( &mut self, ) -> Option<Mut<'_, T>>
Gets mutable access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
§Safety
T
must be a mutable component
Sourcepub fn into_mut<T: Component<Mutability = Mutable>>(self) -> Option<Mut<'w, T>>
pub fn into_mut<T: Component<Mutability = Mutable>>(self) -> Option<Mut<'w, T>>
Consumes self and gets mutable access to the component of type T
with the world 'w
lifetime for the current entity.
Returns None
if the entity does not have a component of type T
.
Sourcepub unsafe fn into_mut_assume_mutable<T: Component>(self) -> Option<Mut<'w, T>>
pub unsafe fn into_mut_assume_mutable<T: Component>(self) -> Option<Mut<'w, T>>
Gets mutable access to the component of type T
for the current entity.
Returns None
if the entity does not have a component of type T
.
§Safety
T
must be a mutable component
Sourcepub fn get_change_ticks<T: Component>(&self) -> Option<ComponentTicks>
pub fn get_change_ticks<T: Component>(&self) -> Option<ComponentTicks>
Retrieves the change ticks for the given component. This can be useful for implementing change detection in custom runtimes.
Sourcepub fn get_change_ticks_by_id(
&self,
component_id: ComponentId,
) -> Option<ComponentTicks>
pub fn get_change_ticks_by_id( &self, component_id: ComponentId, ) -> Option<ComponentTicks>
Retrieves the change ticks for the given ComponentId
. This can be useful for implementing change
detection in custom runtimes.
You should prefer to use the typed API EntityWorldMut::get_change_ticks
where possible and only
use this in cases where the actual component types are not known at
compile time.
Sourcepub fn get_by_id<F: DynamicComponentFetch>(
&self,
component_ids: F,
) -> Result<F::Ref<'_>, EntityComponentError>
pub fn get_by_id<F: DynamicComponentFetch>( &self, component_ids: F, ) -> Result<F::Ref<'_>, EntityComponentError>
Returns untyped read-only reference(s) to component(s) for the
current entity, based on the given ComponentId
s.
You should prefer to use the typed API EntityMut::get
where
possible and only use this in cases where the actual component types
are not known at compile time.
Unlike EntityMut::get
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
Returns EntityComponentError::MissingComponent
if the entity does
not have a component.
§Examples
For examples on how to use this method, see EntityRef::get_by_id
.
Sourcepub fn into_borrow_by_id<F: DynamicComponentFetch>(
self,
component_ids: F,
) -> Result<F::Ref<'w>, EntityComponentError>
pub fn into_borrow_by_id<F: DynamicComponentFetch>( self, component_ids: F, ) -> Result<F::Ref<'w>, EntityComponentError>
Consumes self
and returns untyped read-only reference(s) to
component(s) with lifetime 'w
for the current entity, based on the
given ComponentId
s.
You should prefer to use the typed API EntityMut::into_borrow
where possible and only use this in cases where the actual component
types are not known at compile time.
Unlike EntityMut::into_borrow
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
Returns EntityComponentError::MissingComponent
if the entity does
not have a component.
§Examples
For examples on how to use this method, see EntityRef::get_by_id
.
Sourcepub fn get_mut_by_id<F: DynamicComponentFetch>(
&mut self,
component_ids: F,
) -> Result<F::Mut<'_>, EntityComponentError>
pub fn get_mut_by_id<F: DynamicComponentFetch>( &mut self, component_ids: F, ) -> Result<F::Mut<'_>, EntityComponentError>
Returns untyped mutable reference(s) to component(s) for
the current entity, based on the given ComponentId
s.
You should prefer to use the typed API EntityMut::get_mut
where
possible and only use this in cases where the actual component types
are not known at compile time.
Unlike EntityMut::get_mut
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Examples
§Single ComponentId
let entity = world.spawn(Foo(42)).id();
// Grab the component ID for `Foo` in whatever way you like.
let component_id = world.register_component::<Foo>();
// Then, get the component by ID.
let mut entity_mut = world.entity_mut(entity);
let mut ptr = entity_mut.get_mut_by_id(component_id)
§Array of ComponentId
s
let entity = world.spawn((X(42), Y(10))).id();
// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();
// Then, get the components by ID. You'll receive a same-sized array.
let mut entity_mut = world.entity_mut(entity);
let Ok([mut x_ptr, mut y_ptr]) = entity_mut.get_mut_by_id([x_id, y_id]) else {
// Up to you to handle if a component is missing from the entity.
};
§Slice of ComponentId
s
let entity = world.spawn((X(42), Y(10))).id();
// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();
// Then, get the components by ID. You'll receive a vec of ptrs.
let mut entity_mut = world.entity_mut(entity);
let ptrs = entity_mut.get_mut_by_id(&[x_id, y_id] as &[ComponentId])
§HashSet
of ComponentId
s
let entity = world.spawn((X(42), Y(10))).id();
// Grab the component IDs for `X` and `Y` in whatever way you like.
let x_id = world.register_component::<X>();
let y_id = world.register_component::<Y>();
// Then, get the components by ID. You'll receive a `HashMap` of ptrs.
let mut entity_mut = world.entity_mut(entity);
let mut ptrs = entity_mut.get_mut_by_id(&HashSet::from_iter([x_id, y_id]))
Sourcepub unsafe fn get_mut_assume_mutable_by_id<F: DynamicComponentFetch>(
&mut self,
component_ids: F,
) -> Result<F::Mut<'_>, EntityComponentError>
pub unsafe fn get_mut_assume_mutable_by_id<F: DynamicComponentFetch>( &mut self, component_ids: F, ) -> Result<F::Mut<'_>, EntityComponentError>
Returns untyped mutable reference(s) to component(s) for
the current entity, based on the given ComponentId
s.
Assumes the given ComponentId
s refer to mutable components.
You should prefer to use the typed API EntityMut::get_mut_assume_mutable
where
possible and only use this in cases where the actual component types
are not known at compile time.
Unlike EntityMut::get_mut_assume_mutable
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Safety
It is the callers responsibility to ensure that
- the provided
ComponentId
s must refer to mutable components.
Sourcepub unsafe fn get_mut_by_id_unchecked<F: DynamicComponentFetch>(
&self,
component_ids: F,
) -> Result<F::Mut<'_>, EntityComponentError>
pub unsafe fn get_mut_by_id_unchecked<F: DynamicComponentFetch>( &self, component_ids: F, ) -> Result<F::Mut<'_>, EntityComponentError>
Returns untyped mutable reference to component for
the current entity, based on the given ComponentId
.
Unlike EntityMut::get_mut_by_id
, this method borrows &self instead of
&mut self, allowing the caller to access multiple components simultaneously.
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Safety
It is the callers responsibility to ensure that
- the
UnsafeEntityCell
has permission to access the component mutably - no other references to the component exist at the same time
Sourcepub unsafe fn get_mut_assume_mutable_by_id_unchecked<F: DynamicComponentFetch>(
&self,
component_ids: F,
) -> Result<F::Mut<'_>, EntityComponentError>
pub unsafe fn get_mut_assume_mutable_by_id_unchecked<F: DynamicComponentFetch>( &self, component_ids: F, ) -> Result<F::Mut<'_>, EntityComponentError>
Returns untyped mutable reference to component for
the current entity, based on the given ComponentId
.
Assumes the given ComponentId
s refer to mutable components.
Unlike EntityMut::get_mut_assume_mutable_by_id
, this method borrows &self instead of
&mut self, allowing the caller to access multiple components simultaneously.
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Safety
It is the callers responsibility to ensure that
- the
UnsafeEntityCell
has permission to access the component mutably - no other references to the component exist at the same time
- the provided
ComponentId
s must refer to mutable components.
Sourcepub fn into_mut_by_id<F: DynamicComponentFetch>(
self,
component_ids: F,
) -> Result<F::Mut<'w>, EntityComponentError>
pub fn into_mut_by_id<F: DynamicComponentFetch>( self, component_ids: F, ) -> Result<F::Mut<'w>, EntityComponentError>
Consumes self
and returns untyped mutable reference(s)
to component(s) with lifetime 'w
for the current entity, based on the
given ComponentId
s.
You should prefer to use the typed API EntityMut::into_mut
where
possible and only use this in cases where the actual component types
are not known at compile time.
Unlike EntityMut::into_mut
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Examples
For examples on how to use this method, see EntityMut::get_mut_by_id
.
Sourcepub unsafe fn into_mut_assume_mutable_by_id<F: DynamicComponentFetch>(
self,
component_ids: F,
) -> Result<F::Mut<'w>, EntityComponentError>
pub unsafe fn into_mut_assume_mutable_by_id<F: DynamicComponentFetch>( self, component_ids: F, ) -> Result<F::Mut<'w>, EntityComponentError>
Consumes self
and returns untyped mutable reference(s)
to component(s) with lifetime 'w
for the current entity, based on the
given ComponentId
s.
Assumes the given ComponentId
s refer to mutable components.
You should prefer to use the typed API EntityMut::into_mut_assume_mutable
where
possible and only use this in cases where the actual component types
are not known at compile time.
Unlike EntityMut::into_mut_assume_mutable
, this returns untyped reference(s) to
component(s), and it’s the job of the caller to ensure the correct
type(s) are dereferenced (if necessary).
§Errors
- Returns
EntityComponentError::MissingComponent
if the entity does not have a component. - Returns
EntityComponentError::AliasedMutability
if a component is requested multiple times.
§Safety
It is the callers responsibility to ensure that
- the provided
ComponentId
s must refer to mutable components.
Sourcepub fn spawned_by(&self) -> MaybeLocation
pub fn spawned_by(&self) -> MaybeLocation
Returns the source code location from which this entity has been spawned.
Trait Implementations§
Source§impl ContainsEntity for EntityMut<'_>
impl ContainsEntity for EntityMut<'_>
Source§impl<'a> From<&'a EntityMut<'_>> for FilteredEntityRef<'a>
impl<'a> From<&'a EntityMut<'_>> for FilteredEntityRef<'a>
Source§impl<'a> From<&'a mut EntityMut<'_>> for FilteredEntityMut<'a>
impl<'a> From<&'a mut EntityMut<'_>> for FilteredEntityMut<'a>
Source§impl<'a> From<&'a mut EntityWorldMut<'_>> for EntityMut<'a>
impl<'a> From<&'a mut EntityWorldMut<'_>> for EntityMut<'a>
Source§fn from(entity: &'a mut EntityWorldMut<'_>) -> Self
fn from(entity: &'a mut EntityWorldMut<'_>) -> Self
Source§impl<'a> From<EntityMut<'a>> for FilteredEntityMut<'a>
impl<'a> From<EntityMut<'a>> for FilteredEntityMut<'a>
Source§impl<'a> From<EntityMut<'a>> for FilteredEntityRef<'a>
impl<'a> From<EntityMut<'a>> for FilteredEntityRef<'a>
Source§impl<'w> From<EntityWorldMut<'w>> for EntityMut<'w>
impl<'w> From<EntityWorldMut<'w>> for EntityMut<'w>
Source§fn from(entity: EntityWorldMut<'w>) -> Self
fn from(entity: EntityWorldMut<'w>) -> Self
Source§impl Ord for EntityMut<'_>
impl Ord for EntityMut<'_>
Source§impl PartialOrd for EntityMut<'_>
impl PartialOrd for EntityMut<'_>
Source§impl<'a> QueryData for EntityMut<'a>
SAFETY: access of EntityRef
is a subset of EntityMut
impl<'a> QueryData for EntityMut<'a>
SAFETY: access of EntityRef
is a subset of EntityMut
Source§const IS_READ_ONLY: bool = false
const IS_READ_ONLY: bool = false
Source§type ReadOnly = EntityRef<'a>
type ReadOnly = EntityRef<'a>
QueryData
, which satisfies the ReadOnlyQueryData
trait.Source§type Item<'w> = EntityMut<'w>
type Item<'w> = EntityMut<'w>
WorldQuery
This will be the data retrieved by the query,
and is visible to the end user when calling e.g. Query<Self>::get
.Source§fn shrink<'wlong: 'wshort, 'wshort>(
item: Self::Item<'wlong>,
) -> Self::Item<'wshort>
fn shrink<'wlong: 'wshort, 'wshort>( item: Self::Item<'wlong>, ) -> Self::Item<'wshort>
Source§unsafe fn fetch<'w>(
world: &mut Self::Fetch<'w>,
entity: Entity,
_table_row: TableRow,
) -> Self::Item<'w>
unsafe fn fetch<'w>( world: &mut Self::Fetch<'w>, entity: Entity, _table_row: TableRow, ) -> Self::Item<'w>
Self::Item
for either the given entity
in the current Table
,
or for the given entity
in the current Archetype
. This must always be called after
WorldQuery::set_table
with a table_row
in the range of the current Table
or after
WorldQuery::set_archetype
with an entity
in the current archetype.
Accesses components registered in WorldQuery::update_component_access
. Read moreSource§impl<'a> TryFrom<&'a mut FilteredEntityMut<'_>> for EntityMut<'a>
impl<'a> TryFrom<&'a mut FilteredEntityMut<'_>> for EntityMut<'a>
Source§type Error = TryFromFilteredError
type Error = TryFromFilteredError
Source§impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityMut<'a>
impl<'a> TryFrom<FilteredEntityMut<'a>> for EntityMut<'a>
Source§type Error = TryFromFilteredError
type Error = TryFromFilteredError
Source§impl<'a> WorldQuery for EntityMut<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
impl<'a> WorldQuery for EntityMut<'a>
SAFETY: The accesses of Self::ReadOnly
are a subset of the accesses of Self
Source§const IS_DENSE: bool = true
const IS_DENSE: bool = true
Source§type Fetch<'w> = UnsafeWorldCell<'w>
type Fetch<'w> = UnsafeWorldCell<'w>
WorldQuery
to compute Self::Item
for each entity.Source§type State = ()
type State = ()
Self::Fetch
. This will be cached inside QueryState
,
so it is best to move as much data / computation here as possible to reduce the cost of
constructing Self::Fetch
.Source§fn shrink_fetch<'wlong: 'wshort, 'wshort>(
fetch: Self::Fetch<'wlong>,
) -> Self::Fetch<'wshort>
fn shrink_fetch<'wlong: 'wshort, 'wshort>( fetch: Self::Fetch<'wlong>, ) -> Self::Fetch<'wshort>
Source§unsafe fn init_fetch<'w>(
world: UnsafeWorldCell<'w>,
_state: &Self::State,
_last_run: Tick,
_this_run: Tick,
) -> Self::Fetch<'w>
unsafe fn init_fetch<'w>( world: UnsafeWorldCell<'w>, _state: &Self::State, _last_run: Tick, _this_run: Tick, ) -> Self::Fetch<'w>
Self::Fetch
,
by combining data from the World
with the cached Self::State
.
Readonly accesses resources registered in WorldQuery::update_component_access
. Read moreSource§unsafe fn set_archetype<'w>(
_fetch: &mut Self::Fetch<'w>,
_state: &Self::State,
_archetype: &'w Archetype,
_table: &Table,
)
unsafe fn set_archetype<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _archetype: &'w Archetype, _table: &Table, )
Archetype
. This will always be called on
archetypes that match this WorldQuery
. Read moreSource§unsafe fn set_table<'w>(
_fetch: &mut Self::Fetch<'w>,
_state: &Self::State,
_table: &'w Table,
)
unsafe fn set_table<'w>( _fetch: &mut Self::Fetch<'w>, _state: &Self::State, _table: &'w Table, )
Table
. This will always be called on tables
that match this WorldQuery
. Read moreSource§fn update_component_access(
_state: &Self::State,
access: &mut FilteredAccess<ComponentId>,
)
fn update_component_access( _state: &Self::State, access: &mut FilteredAccess<ComponentId>, )
Source§fn init_state(_world: &mut World)
fn init_state(_world: &mut World)
State
for this WorldQuery
type.Source§fn matches_component_set(
_state: &Self::State,
_set_contains_id: &impl Fn(ComponentId) -> bool,
) -> bool
fn matches_component_set( _state: &Self::State, _set_contains_id: &impl Fn(ComponentId) -> bool, ) -> bool
Source§fn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)
fn set_access(_state: &mut Self::State, _access: &FilteredAccess<ComponentId>)
FilteredEntityRef
or FilteredEntityMut
. Read moreimpl EntityEquivalent for EntityMut<'_>
impl Eq for EntityMut<'_>
Auto Trait Implementations§
impl<'w> Freeze for EntityMut<'w>
impl<'w> !RefUnwindSafe for EntityMut<'w>
impl<'w> Send for EntityMut<'w>
impl<'w> Sync for EntityMut<'w>
impl<'w> Unpin for EntityMut<'w>
impl<'w> !UnwindSafe for EntityMut<'w>
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
Source§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
Source§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
, which can then be
downcast
into Box<dyn ConcreteType>
where ConcreteType
implements Trait
.Source§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
, which can then be further
downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.Source§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.Source§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.Source§impl<T> DowncastSend for T
impl<T> DowncastSend for T
Source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
Source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.