Struct I 

pub struct I(pub Entity);

Tuple Fields

0: Entity

Trait Implementations

impl AsEntity for I

fn as_entity(&self) -> Entity

fn try_get_cmp<'a, C: 'static>( &self, ) -> Option<OwningRef<OwningRef<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, Ref<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>, C>>

where Self: Sized,

fn try_get_cmp_mut<'a, C: 'static>( &self, ) -> Option<OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, RefMut<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>>, C>>

where Self: Sized,

fn get_cmp<'a, C: 'static>( &self, ) -> OwningRef<OwningRef<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, Ref<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>, C>

where Self: Sized,

fn get_cmp_mut<'a, C: 'static>( &self, ) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, RefMut<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>>, C>

where Self: Sized,

fn get_cmp_mut_or<'a, C: 'static>( &self, f: impl FnOnce() -> C, ) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, RefMut<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>>, C>

where Self: Sized,

fn get_cmp_mut_or_default<'a, C: 'static + Default>( &self, ) -> OwningRefMut<StorageGuard<'a, C, OwningRefMut<OwningHandle<Rc<RefCell<Box<dyn DynStorage + 'static>>>, RefMut<'a, Box<dyn DynStorage>>>, SimpleStorage<C>>>, C>

where Self: Sized,

fn remove_cmp<C: 'static>(&self)

where Self: Sized,

fn find_in_ancestors<Q: Query>(&self) -> Vec<Q::Fetch>

fn try_find_first_in_ancestors<Q: Query>(&self) -> Option<Q::Fetch>

fn find_first_in_ancestors<Q: Query>(&self) -> Q::Fetch

fn find_in_descendants<Q: Query>(&self) -> Vec<Q::Fetch>

fn find_in_children<Q: Query>(&self) -> Vec<Q::Fetch>

fn try_find_first_in_descendants<Q: Query>(&self) -> Option<Q::Fetch>

fn try_find_first_in_children<Q: Query>(&self) -> Option<Q::Fetch>

fn find_first_in_descendants<Q: Query>(&self) -> Q::Fetch

fn find_first_in_children<Q: Query>(&self) -> Q::Fetch

fn has_cmp<C: 'static>(&self) -> bool

where Self: Sized,

fn remove(&self)

fn is_dead(&self) -> bool

fn add_component<T: 'static>(&self, component: T)

fn component<T: 'static>(self, component: T) -> Self

where Self: Sized,

impl Clone for I

fn clone(&self) -> I

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for I

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Element for I

fn add_child(&self, child: impl Element)

fn child(self, child: impl Element) -> Self

fn add_children<Item: Element>(&self, children: impl IntoIterator<Item = Item>)

fn children<Item: Element>( self, children: impl IntoIterator<Item = Item>, ) -> Self

fn leave_parent(self)

fn add_child_at(&self, at_id: usize, child: impl Element)

fn add_child_signal<S, E>(&self, signal: S)

where E: Element, S: Signal<Item = E> + 'static,

fn child_signal<S, E>(self, signal: S) -> Self

where E: Element, S: Signal<Item = E> + 'static,

fn set_class_tagged<Tag: Hash + 'static>( &self, tag: Tag, style: impl Into<Style>, )

fn set_class_typed<Type: 'static>(&self, style: Style)

fn set_class(&self, style: impl Into<Style>)

fn add_class(&self, style: impl Into<Style>)

fn class(self, style: impl Into<Style>) -> Self

fn class_tagged<Tag: Hash + 'static>( self, tag: Tag, style: impl Into<Style>, ) -> Self

fn class_typed<Type: 'static>(self, style: Style) -> Self

fn set_class_signal<S, I>(&self, signal: S)

where I: Into<Style>, S: Signal<Item = I> + 'static,

fn class_signal<S, I>(self, signal: S) -> Self

where I: Into<Style>, S: Signal<Item = I> + 'static,

fn set_class_typed_signal<Type, S, I>(&self, signal: S)

where Type: 'static, I: Into<Style>, S: Signal<Item = I> + 'static,

fn class_typed_signal<Type, S, I>(self, signal: S) -> Self

where Type: 'static, I: Into<Style>, S: Signal<Item = I> + 'static,

fn set_class_tagged_signal<Tag, S, I>(&self, tag: Tag, signal: S)

where Tag: Hash + Copy + 'static, I: Into<Style>, S: Signal<Item = I> + 'static,

fn class_tagged_signal<Tag, S, I>(self, tag: Tag, signal: S) -> Self

where Tag: Hash + Copy + 'static, I: Into<Style>, S: Signal<Item = I> + 'static,

fn set_attr<'k, 'v>( &self, key: impl Into<Cow<'k, str>>, value: impl Into<Cow<'v, str>>, )

fn attr<'k, 'v>( self, key: impl Into<Cow<'k, str>>, value: impl Into<Cow<'v, str>>, ) -> Self

fn set_bool_attr<'k>(&self, key: impl Into<Cow<'k, str>>, value: bool)

fn bool_attr<'k>(self, key: impl Into<Cow<'k, str>>, value: bool) -> Self

fn remove_attr<'k>(&self, key: impl Into<Cow<'k, str>>)

fn set_attr_signal<'k, 'v, S, K, V>(&self, signal: S)

where K: Into<Cow<'k, str>>, V: Into<Cow<'v, str>>, S: Signal<Item = (K, V)> + 'static,

fn attr_signal<'k, 'v, S, K, V>(self, x: S) -> Self

where K: Into<Cow<'k, str>>, V: Into<Cow<'v, str>>, S: Signal<Item = (K, V)> + 'static,

fn set_bool_attr_signal<'k, S, K>(&self, attr: K, signal: S)

where K: Into<Cow<'k, str>>, S: Signal<Item = bool> + 'static,

fn bool_attr_signal<'k, S, K>(self, attr: K, x: S) -> Self

where K: Into<Cow<'k, str>>, S: Signal<Item = bool> + 'static,

fn set_text<'a>(&self, text: impl Into<Cow<'a, str>>)

fn text<'a>(self, x: impl Into<Cow<'a, str>>) -> Self

fn set_text_signal<'a, S, I>(&self, signal: S)

where I: Into<Cow<'a, str>>, S: Signal<Item = I> + 'static,

fn text_signal<'a, S, I>(self, x: S) -> Self

where I: Into<Cow<'a, str>>, S: Signal<Item = I> + 'static,

fn set_style(&self, style: impl AppendProperty)

fn style(self, style: impl AppendProperty) -> Self

fn remove_style(&self)

fn set_style_signal<S, I>(&self, signal: S)

where I: AppendProperty, S: Signal<Item = I> + 'static,

fn style_signal<S, I>(self, signal: S) -> Self

where I: AppendProperty, S: Signal<Item = I> + 'static,

fn mark<T: 'static>(self) -> Self

fn unmark<T: 'static>(self) -> Self

fn mark_signal<T: 'static, S>(self, signal: S) -> Self

where S: Signal<Item = bool> + 'static,

fn with_component<T: 'static>(self, f: impl FnOnce(&Self) -> T) -> Self

fn replace_with<T: Element>(&self, other: T) -> T

fn with(self, f: impl FnOnce(&Self)) -> Self

fn erase(&self) -> SomeElement

impl Hash for I

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for I

fn eq(&self, other: &I) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for I

impl Eq for I

impl StructuralPartialEq for I