bevy_reflect/impls/std/collections/
hash_map.rs1use bevy_reflect_derive::impl_type_path;
2
3use crate::impls::macros::impl_reflect_for_hashmap;
4#[cfg(feature = "functions")]
5use crate::{
6 from_reflect::FromReflect, type_info::MaybeTyped, type_path::TypePath,
7 type_registry::GetTypeRegistration,
8};
9#[cfg(feature = "functions")]
10use core::hash::{BuildHasher, Hash};
11
12const _: () =
{
impl<K, V, S> crate::map::Map for ::std::collections::HashMap<K, V, S>
where K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync {
fn get(&self, key: &dyn crate::reflect::PartialReflect)
-> Option<&dyn crate::reflect::PartialReflect> {
key.try_downcast_ref::<K>().and_then(|key|
Self::get(self,
key)).map(|value|
value as &dyn crate::reflect::PartialReflect)
}
fn get_mut(&mut self, key: &dyn crate::reflect::PartialReflect)
-> Option<&mut dyn crate::reflect::PartialReflect> {
key.try_downcast_ref::<K>().and_then(move |key|
Self::get_mut(self,
key)).map(|value|
value as &mut dyn crate::reflect::PartialReflect)
}
fn len(&self) -> usize { Self::len(self) }
fn iter(&self)
->
bevy_platform::prelude::Box<dyn Iterator<Item =
(&dyn crate::reflect::PartialReflect,
&dyn crate::reflect::PartialReflect)> + '_> {
bevy_platform::prelude::Box::new(self.iter().map(|(k, v)|
(k as &dyn crate::reflect::PartialReflect,
v as &dyn crate::reflect::PartialReflect)))
}
fn drain(&mut self)
->
bevy_platform::prelude::Vec<(bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>,
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)> {
self.drain().map(|(key, value)|
{
(bevy_platform::prelude::Box::new(key) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>,
bevy_platform::prelude::Box::new(value) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)
}).collect()
}
fn retain(&mut self,
f:
&mut dyn FnMut(&dyn crate::reflect::PartialReflect,
&mut dyn crate::reflect::PartialReflect) -> bool) {
self.retain(move |key, value| f(key, value));
}
fn to_dynamic_map(&self) -> crate::map::DynamicMap {
let mut dynamic_map = crate::map::DynamicMap::default();
dynamic_map.set_represented_type(crate::reflect::PartialReflect::get_represented_type_info(self));
for (k, v) in self {
let key =
K::from_reflect(k).unwrap_or_else(||
{
{
::core::panicking::panic_fmt(format_args!("Attempted to clone invalid key of type {0}.",
k.reflect_type_path()));
}
});
dynamic_map.insert_boxed(bevy_platform::prelude::Box::new(key),
v.to_dynamic());
}
dynamic_map
}
fn insert_boxed(&mut self,
key:
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>,
value:
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)
->
Option<bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>> {
let key =
K::take_from_reflect(key).unwrap_or_else(|key|
{
{
::core::panicking::panic_fmt(format_args!("Attempted to insert invalid key of type {0}.",
key.reflect_type_path()));
}
});
let value =
V::take_from_reflect(value).unwrap_or_else(|value|
{
{
::core::panicking::panic_fmt(format_args!("Attempted to insert invalid value of type {0}.",
value.reflect_type_path()));
}
});
self.insert(key,
value).map(|old_value|
bevy_platform::prelude::Box::new(old_value) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)
}
fn remove(&mut self, key: &dyn crate::reflect::PartialReflect)
->
Option<bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>> {
let mut from_reflect = None;
key.try_downcast_ref::<K>().or_else(||
{
from_reflect = K::from_reflect(key);
from_reflect.as_ref()
}).and_then(|key|
self.remove(key)).map(|value|
bevy_platform::prelude::Box::new(value) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)
}
}
impl<K, V, S> crate::reflect::PartialReflect for
::std::collections::HashMap<K, V, S> where
K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync {
fn get_represented_type_info(&self)
-> Option<&'static crate::type_info::TypeInfo> {
Some(<Self as crate::type_info::Typed>::type_info())
}
#[inline]
fn into_partial_reflect(self: bevy_platform::prelude::Box<Self>)
->
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect> {
self
}
fn as_partial_reflect(&self)
-> &dyn crate::reflect::PartialReflect {
self
}
fn as_partial_reflect_mut(&mut self)
-> &mut dyn crate::reflect::PartialReflect {
self
}
fn try_into_reflect(self: bevy_platform::prelude::Box<Self>)
->
Result<bevy_platform::prelude::Box<dyn crate::reflect::Reflect>,
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>> {
Ok(self)
}
fn try_as_reflect(&self) -> Option<&dyn crate::reflect::Reflect> {
Some(self)
}
fn try_as_reflect_mut(&mut self)
-> Option<&mut dyn crate::reflect::Reflect> {
Some(self)
}
fn reflect_kind(&self) -> crate::kind::ReflectKind {
crate::kind::ReflectKind::Map
}
fn reflect_ref(&self) -> crate::kind::ReflectRef<'_> {
crate::kind::ReflectRef::Map(self)
}
fn reflect_mut(&mut self) -> crate::kind::ReflectMut<'_> {
crate::kind::ReflectMut::Map(self)
}
fn reflect_owned(self: bevy_platform::prelude::Box<Self>)
-> crate::kind::ReflectOwned {
crate::kind::ReflectOwned::Map(self)
}
fn reflect_clone(&self)
->
Result<bevy_platform::prelude::Box<dyn crate::reflect::Reflect>,
crate::error::ReflectCloneError> {
let mut map =
Self::with_capacity_and_hasher(self.len(), S::default());
for (key, value) in self.iter() {
let key = key.reflect_clone_and_take()?;
let value = value.reflect_clone_and_take()?;
map.insert(key, value);
}
Ok(bevy_platform::prelude::Box::new(map))
}
fn reflect_partial_eq(&self,
value: &dyn crate::reflect::PartialReflect) -> Option<bool> {
crate::map::map_partial_eq(self, value)
}
fn apply(&mut self, value: &dyn crate::reflect::PartialReflect) {
crate::map::map_apply(self, value);
}
fn try_apply(&mut self,
value: &dyn crate::reflect::PartialReflect)
-> Result<(), crate::reflect::ApplyError> {
crate::map::map_try_apply(self, value)
}
}
impl<K, V, S> crate::Reflect for ::std::collections::HashMap<K, V, S>
where K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync {
fn into_any(self: bevy_platform::prelude::Box<Self>)
-> bevy_platform::prelude::Box<dyn ::core::any::Any> {
self
}
fn as_any(&self) -> &dyn ::core::any::Any { self }
fn as_any_mut(&mut self) -> &mut dyn ::core::any::Any { self }
fn into_reflect(self: bevy_platform::prelude::Box<Self>)
-> bevy_platform::prelude::Box<dyn crate::Reflect> {
self
}
fn as_reflect(&self) -> &dyn crate::Reflect { self }
fn as_reflect_mut(&mut self) -> &mut dyn crate::Reflect { self }
fn set(&mut self,
value: bevy_platform::prelude::Box<dyn crate::Reflect>)
->
Result<(),
bevy_platform::prelude::Box<dyn crate::Reflect>> {
*self = <dyn crate::Reflect>::take(value)?;
Ok(())
}
}
impl<K, V, S> crate::type_info::Typed for
::std::collections::HashMap<K, V, S> where
K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync {
fn type_info() -> &'static crate::type_info::TypeInfo {
static CELL: crate::utility::GenericTypeInfoCell =
crate::utility::GenericTypeInfoCell::new();
CELL.get_or_insert::<Self,
_>(||
{
crate::type_info::TypeInfo::Map(crate::map::MapInfo::new::<Self,
K,
V>().with_generics(crate::generics::Generics::from_iter([crate::generics::TypeParamInfo::new::<K>("K"),
crate::generics::TypeParamInfo::new::<V>("V")])))
})
}
}
impl<K, V, S> crate::type_registry::GetTypeRegistration for
::std::collections::HashMap<K, V, S> where
K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync + Default {
fn get_type_registration()
-> crate::type_registry::TypeRegistration {
let mut registration =
crate::type_registry::TypeRegistration::of::<Self>();
registration.insert::<crate::type_registry::ReflectFromPtr>(crate::type_registry::FromType::<Self>::from_type());
registration.insert::<crate::from_reflect::ReflectFromReflect>(crate::type_registry::FromType::<Self>::from_type());
registration
}
fn register_type_dependencies(registry:
&mut crate::type_registry::TypeRegistry) {
registry.register::<K>();
registry.register::<V>();
}
}
impl<K, V, S> crate::from_reflect::FromReflect for
::std::collections::HashMap<K, V, S> where
K: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration + Eq + core::hash::Hash,
V: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration,
S: crate::type_path::TypePath + core::hash::BuildHasher +
Default + Send + Sync {
fn from_reflect(reflect: &dyn crate::reflect::PartialReflect)
-> Option<Self> {
let ref_map = reflect.reflect_ref().as_map().ok()?;
let mut new_map =
Self::with_capacity_and_hasher(ref_map.len(), S::default());
for (key, value) in ref_map.iter() {
let new_key = K::from_reflect(key)?;
let new_value = V::from_reflect(value)?;
new_map.insert(new_key, new_value);
}
Some(new_map)
}
}
};impl_reflect_for_hashmap!(::std::collections::HashMap<K, V, S>);
13const _: () =
{
#[allow(deprecated, reason =
"derives on a deprecated type shouldn't be considered a usage")]
impl bevy_reflect::TypePath for
::std::collections::hash_map::RandomState where {
fn type_path() -> &'static str {
"std::collections::hash_map::RandomState"
}
fn short_type_path() -> &'static str { "RandomState" }
fn type_ident() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("RandomState")
}
fn crate_name() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("std")
}
fn module_path() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("std::collections::hash_map")
}
}
};impl_type_path!(::std::collections::hash_map::RandomState);
14const _: () =
{
#[allow(deprecated, reason =
"derives on a deprecated type shouldn't be considered a usage")]
impl<K, V, S> bevy_reflect::TypePath for
::std::collections::HashMap<K, V, S> where
::std::collections::HashMap<K, V, S>: ::core::any::Any +
::core::marker::Send + ::core::marker::Sync,
K: bevy_reflect::TypePath, V: bevy_reflect::TypePath,
S: bevy_reflect::TypePath {
fn type_path() -> &'static str {
static CELL: bevy_reflect::utility::GenericTypePathCell =
bevy_reflect::utility::GenericTypePathCell::new();
CELL.get_or_insert::<Self,
_>(||
{
::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(bevy_reflect::__macro_exports::alloc_utils::ToString::to_string("std::collections::HashMap<"),
&::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(bevy_reflect::__macro_exports::alloc_utils::ToString::to_string(<K
as bevy_reflect::TypePath>::type_path()), ", "),
<V as bevy_reflect::TypePath>::type_path()), ", "),
<S as bevy_reflect::TypePath>::type_path())), ">")
})
}
fn short_type_path() -> &'static str {
static CELL: bevy_reflect::utility::GenericTypePathCell =
bevy_reflect::utility::GenericTypePathCell::new();
CELL.get_or_insert::<Self,
_>(||
{
::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(bevy_reflect::__macro_exports::alloc_utils::ToString::to_string("HashMap<"),
&::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(::core::ops::Add::<&str>::add(bevy_reflect::__macro_exports::alloc_utils::ToString::to_string(<K
as bevy_reflect::TypePath>::short_type_path()), ", "),
<V as bevy_reflect::TypePath>::short_type_path()), ", "),
<S as bevy_reflect::TypePath>::short_type_path())), ">")
})
}
fn type_ident() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("HashMap")
}
fn crate_name() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("std")
}
fn module_path() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("std::collections")
}
}
};impl_type_path!(::std::collections::HashMap<K, V, S>);
15
16#[cfg(feature = "functions")]
17impl<K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash,
V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
S: TypePath + BuildHasher + Default + Send + Sync>
crate::func::args::GetOwnership for ::std::collections::HashMap<K, V, S>
{}
impl<K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash,
V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
S: TypePath + BuildHasher + Default + Send + Sync>
crate::func::args::FromArg for ::std::collections::HashMap<K, V, S> {
type This<'from_arg> = ::std::collections::HashMap<K, V, S>;
fn from_arg(arg: crate::func::args::Arg<'_>)
-> Result<Self::This<'_>, crate::func::args::ArgError> {
arg.take_owned()
}
}
impl<K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash,
V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
S: TypePath + BuildHasher + Default + Send + Sync> crate::func::IntoReturn
for ::std::collections::HashMap<K, V, S> {
fn into_return<'into_return>(self) -> crate::func::Return<'into_return>
where Self: 'into_return {
crate::func::Return::Owned(bevy_platform::prelude::Box::new(self))
}
}crate::func::macros::impl_function_traits!(::std::collections::HashMap<K, V, S>;
18 <
19 K: FromReflect + MaybeTyped + TypePath + GetTypeRegistration + Eq + Hash,
20 V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
21 S: TypePath + BuildHasher + Default + Send + Sync
22 >
23);
24
25#[cfg(test)]
26mod tests {
27 use crate::Reflect;
28 use static_assertions::assert_impl_all;
29
30 #[test]
31 fn should_reflect_hashmaps() {
32 assert_impl_all!(std::collections::HashMap<u32, f32>: Reflect);
33 }
34}