bevy_reflect/impls/alloc/collections/
vec_deque.rs1use bevy_reflect_derive::impl_type_path;
2
3use crate::impls::macros::impl_reflect_for_veclike;
4#[cfg(feature = "functions")]
5use crate::{
6 from_reflect::FromReflect, type_info::MaybeTyped, type_path::TypePath,
7 type_registry::GetTypeRegistration,
8};
9
10const _: () =
{
impl<T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration> crate::list::List for
::alloc::collections::VecDeque<T> {
#[inline]
fn get(&self, index: usize)
-> Option<&dyn crate::reflect::PartialReflect> {
<::alloc::collections::VecDeque<T>>::get(self,
index).map(|value|
value as &dyn crate::reflect::PartialReflect)
}
#[inline]
fn get_mut(&mut self, index: usize)
-> Option<&mut dyn crate::reflect::PartialReflect> {
<::alloc::collections::VecDeque<T>>::get_mut(self,
index).map(|value|
value as &mut dyn crate::reflect::PartialReflect)
}
fn insert(&mut self, index: usize,
value:
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>) {
let value =
value.try_take::<T>().unwrap_or_else(|value|
{
T::from_reflect(&*value).unwrap_or_else(||
{
{
::core::panicking::panic_fmt(format_args!("Attempted to insert invalid value of type {0}.",
value.reflect_type_path()));
}
})
});
::alloc::collections::VecDeque::insert(self, index, value);
}
fn remove(&mut self, index: usize)
->
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect> {
bevy_platform::prelude::Box::new(::alloc::collections::VecDeque::remove(self,
index))
}
fn push(&mut self,
value:
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>) {
let value =
T::take_from_reflect(value).unwrap_or_else(|value|
{
{
::core::panicking::panic_fmt(format_args!("Attempted to push invalid value of type {0}.",
value.reflect_type_path()));
}
});
::alloc::collections::VecDeque::push_back(self, value);
}
fn pop(&mut self)
->
Option<bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>> {
::alloc::collections::VecDeque::pop_back(self).map(|value|
bevy_platform::prelude::Box::new(value) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>)
}
#[inline]
fn len(&self) -> usize {
<::alloc::collections::VecDeque<T>>::len(self)
}
#[inline]
fn iter(&self) -> crate::list::ListIter<'_> {
crate::list::ListIter::new(self)
}
#[inline]
fn drain(&mut self)
->
alloc::vec::Vec<bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>> {
self.drain(..).map(|value|
bevy_platform::prelude::Box::new(value) as
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect>).collect()
}
}
impl<T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration>
crate::reflect::PartialReflect for
::alloc::collections::VecDeque<T> {
#[inline]
fn get_represented_type_info(&self)
-> Option<&'static crate::type_info::TypeInfo> {
Some(<Self as crate::type_info::Typed>::type_info())
}
fn into_partial_reflect(self: bevy_platform::prelude::Box<Self>)
->
bevy_platform::prelude::Box<dyn crate::reflect::PartialReflect> {
self
}
#[inline]
fn as_partial_reflect(&self)
-> &dyn crate::reflect::PartialReflect {
self
}
#[inline]
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::List
}
fn reflect_ref(&self) -> crate::kind::ReflectRef<'_> {
crate::kind::ReflectRef::List(self)
}
fn reflect_mut(&mut self) -> crate::kind::ReflectMut<'_> {
crate::kind::ReflectMut::List(self)
}
fn reflect_owned(self: bevy_platform::prelude::Box<Self>)
-> crate::kind::ReflectOwned {
crate::kind::ReflectOwned::List(self)
}
fn reflect_clone(&self)
->
Result<bevy_platform::prelude::Box<dyn crate::reflect::Reflect>,
crate::error::ReflectCloneError> {
Ok(bevy_platform::prelude::Box::new(self.iter().map(|value|
value.reflect_clone_and_take()).collect::<Result<Self,
crate::error::ReflectCloneError>>()?))
}
fn reflect_hash(&self) -> Option<u64> {
crate::list::list_hash(self)
}
fn reflect_partial_eq(&self,
value: &dyn crate::reflect::PartialReflect) -> Option<bool> {
crate::list::list_partial_eq(self, value)
}
fn reflect_partial_cmp(&self,
value: &dyn crate::reflect::PartialReflect)
-> Option<::core::cmp::Ordering> {
crate::list::list_partial_cmp(self, value)
}
fn apply(&mut self, value: &dyn crate::reflect::PartialReflect) {
crate::list::list_apply(self, value);
}
fn try_apply(&mut self,
value: &dyn crate::reflect::PartialReflect)
-> Result<(), crate::reflect::ApplyError> {
crate::list::list_try_apply(self, value)
}
}
impl<T> crate::Reflect for ::alloc::collections::VecDeque<T> where
T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration {
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<T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration> crate::type_info::Typed
for ::alloc::collections::VecDeque<T> {
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::List(crate::list::ListInfo::new::<Self,
T>().with_generics(crate::generics::Generics::from_iter([crate::generics::TypeParamInfo::new::<T>("T")])))
})
}
}
impl<T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration>
crate::type_registry::GetTypeRegistration for
::alloc::collections::VecDeque<T> {
fn get_type_registration()
-> crate::type_registry::TypeRegistration {
let mut registration =
crate::type_registry::TypeRegistration::of::<::alloc::collections::VecDeque<T>>();
registration.insert::<crate::type_registry::ReflectFromPtr>(crate::type_registry::FromType::<::alloc::collections::VecDeque<T>>::from_type());
registration.insert::<crate::from_reflect::ReflectFromReflect>(crate::type_registry::FromType::<::alloc::collections::VecDeque<T>>::from_type());
registration
}
fn register_type_dependencies(registry:
&mut crate::type_registry::TypeRegistry) {
registry.register::<T>();
}
}
impl<T: crate::from_reflect::FromReflect +
crate::type_info::MaybeTyped + crate::type_path::TypePath +
crate::type_registry::GetTypeRegistration>
crate::from_reflect::FromReflect for
::alloc::collections::VecDeque<T> {
fn from_reflect(reflect: &dyn crate::reflect::PartialReflect)
-> Option<Self> {
let ref_list = reflect.reflect_ref().as_list().ok()?;
let mut new_list = Self::with_capacity(ref_list.len());
for field in ref_list.iter() {
::alloc::collections::VecDeque::push_back(&mut new_list,
T::from_reflect(field)?);
}
Some(new_list)
}
}
};impl_reflect_for_veclike!(
11 ::alloc::collections::VecDeque<T>,
12 ::alloc::collections::VecDeque::insert,
13 ::alloc::collections::VecDeque::remove,
14 ::alloc::collections::VecDeque::push_back,
15 ::alloc::collections::VecDeque::pop_back,
16 ::alloc::collections::VecDeque::<T>
17);
18const _: () =
{
#[allow(deprecated, reason =
"derives on a deprecated type shouldn't be considered a usage")]
impl<T> bevy_reflect::TypePath for ::alloc::collections::VecDeque<T>
where ::alloc::collections::VecDeque<T>: ::core::any::Any +
::core::marker::Send + ::core::marker::Sync,
T: 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("alloc::collections::VecDeque<"),
<T 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("VecDeque<"),
<T as bevy_reflect::TypePath>::short_type_path()), ">")
})
}
fn type_ident() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("VecDeque")
}
fn crate_name() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("alloc")
}
fn module_path() -> ::core::option::Option<&'static str> {
::core::option::Option::Some("alloc::collections")
}
}
};impl_type_path!(::alloc::collections::VecDeque<T>);
19#[cfg(feature = "functions")]
20impl<T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration>
crate::func::args::GetOwnership for ::alloc::collections::VecDeque<T> {}
impl<T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration>
crate::func::args::FromArg for ::alloc::collections::VecDeque<T> {
type This<'from_arg> = ::alloc::collections::VecDeque<T>;
fn from_arg(arg: crate::func::args::Arg<'_>)
-> Result<Self::This<'_>, crate::func::args::ArgError> {
arg.take_owned()
}
}
impl<T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration>
crate::func::IntoReturn for ::alloc::collections::VecDeque<T> {
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!(::alloc::collections::VecDeque<T>; <T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration>);