Struct ReflectQueryable 

pub struct ReflectQueryable(/* private fields */);

A reflect trait extending ReflectComponent with query methods.

ReflectComponent doesn’t have methods to get

Implementations

impl ReflectQueryable

pub const fn get(&self) -> &ReflectQueryableFns

Return the function pointers implementing the ReflectQueryable methods.

pub fn reflect_ref<'a>( &self, entity: EntityRef<'a>, ) -> Option<Ref<'a, dyn Reflect>>

Gets the value of this Component type from the entity as a reflected reference, with tick data in Ref.

impl ReflectQueryable

Get a single entity with the reflected queryable Component.

pub fn get_single<'a>( &self, world: &'a mut World, ) -> Result<&'a dyn Reflect, QuerySingleError>

Get a single &dyn Reflect of the underyling Component from World, failing if there isn’t exactly one Entity matching this description.

Consider using ReflectQueryable::query followed by .next() if you want to get a value even if there is more than one Entity with the underlying Component.

Errors

This will return an Err if:

• There is no Entity with the underyling Component in world.
• There is more than one Entity with the underyling Component in world.

pub fn get_single_ref<'a>( &self, world: &'a mut World, ) -> Result<Ref<'a, dyn Reflect>, QuerySingleError>

Get a single Ref<dyn Reflect> of the underyling Component from World, failing if there isn’t exactly one Entity matching this description.

Consider using ReflectQueryable::query_ref followed by .next() if you want to get a value even if there is more than one Entity with the underlying Component.

Errors

This will return an Err if:

• There is no Entity with the underyling Component in world.
• There is more than one Entity with the underyling Component in world.

pub fn get_single_mut<'a>( &self, world: &'a mut World, ) -> Result<Mut<'a, dyn Reflect>, QuerySingleError>

Get a single Mut<dyn Reflect> of the underyling Component from World, failing if there isn’t exactly one Entity matching this description.

Consider using ReflectQueryable::query_mut followed by .next() if you want to get a value even if there is more than one Entity with the underlying Component.

Errors

This will return an Err if:

• There is no Entity with the underyling Component in world.
• There is more than one Entity with the underyling Component in world.

pub fn get_single_entity( &self, world: &mut World, ) -> Result<Entity, QuerySingleError>

Get a single Entity of the underyling Component from World, failing if there isn’t exactly one Entity matching this description.

Consider using ReflectQueryable::query_entities followed by .next() if you want to get a value even if there is more than one Entity with the underlying Component.

Errors

This will return an Err if:

• There is no Entity with the underyling Component in world.
• There is more than one Entity with the underyling Component in world.

impl ReflectQueryable

Query all entities with the reflected queryable Component.

pub fn query(&self, world: &mut World) -> Querydyn

Get a Querydyn to iterate over all &dyn Reflect with the underlying Component from world.

Use ReflectQueryable::get_single for a version that returns a single element directly.

Example

use std::any::TypeId;
use bevy::prelude::{Reflect, ReflectComponent, Component, World};
use bevy::reflect::TypeRegistryInternal as TypeRegistry;
use cuicui_reflect_query::ReflectQueryable;

#[derive(Component, Reflect, Default)]
#[reflect(Component, Queryable)]
struct Zoobazee {
    bee: u32,
    baboo: String,
}
fn reflect_query(world: &mut World, registry: &TypeRegistry) {
    let type_data = registry
        .get_type_data::<ReflectQueryable>(TypeId::of::<Zoobazee>())
        .unwrap();

    let mut query = type_data.query(world);

    for element in query.iter(world) {
        println!("{element:?}");
    }
}

pub fn query_entities(&self, world: &mut World) -> EntityQuerydyn

Get a EntityQuerydyn to iterate over all Entity with the underlying Component from world.

Use ReflectQueryable::get_single_entity for a version that returns a single element directly.

Example

use std::any::TypeId;
use bevy::prelude::{Reflect, ReflectComponent, Component, World};
use bevy::reflect::TypeRegistryInternal as TypeRegistry;
use cuicui_reflect_query::ReflectQueryable;

#[derive(Component, Reflect, Default)]
#[reflect(Component, Queryable)]
struct Zoobazee {
    bee: u32,
    baboo: String,
}
fn reflect_query(world: &mut World, registry: &TypeRegistry) {
    let type_data = registry
        .get_type_data::<ReflectQueryable>(TypeId::of::<Zoobazee>())
        .unwrap();

    let mut query = type_data.query_entities(world);

    for element in query.iter(world) {
        println!("{element:?}");
    }
}

pub fn query_ref(&self, world: &mut World) -> RefQuerydyn

Get a RefQuerydyn to iterate over all Ref<dyn Reflect> with the underlying Component from world.

Use ReflectQueryable::get_single_ref for a version that returns a single element directly.

Example

use std::any::TypeId;
use bevy::prelude::{Reflect, ReflectComponent, Component, World};
use bevy::reflect::TypeRegistryInternal as TypeRegistry;
use cuicui_reflect_query::ReflectQueryable;

#[derive(Component, Reflect, Default)]
#[reflect(Component, Queryable)]
struct Zoobazee {
    bee: u32,
    baboo: String,
}
fn reflect_query(world: &mut World, registry: &TypeRegistry) {
    let type_data = registry
        .get_type_data::<ReflectQueryable>(TypeId::of::<Zoobazee>())
        .unwrap();

    let mut query = type_data.query_ref(world);

    for element in query.iter(world) {
        println!("{element:?}");
    }
}

pub fn query_mut(&self, world: &mut World) -> MutQuerydyn

Get a MutQuerydyn to iterate over all Mut<dyn Reflect> with the underlying Component from world.

Use ReflectQueryable::get_single_mut for a version that returns a single element directly.

Example

use std::any::TypeId;
use bevy::prelude::{Reflect, ReflectComponent, Component, World};
use bevy::reflect::TypeRegistryInternal as TypeRegistry;
use cuicui_reflect_query::ReflectQueryable;

#[derive(Component, Reflect, Default)]
#[reflect(Component, Queryable)]
struct Zoobazee {
    bee: u32,
    baboo: String,
}
fn reflect_query(world: &mut World, registry: &TypeRegistry) {
    let type_data = registry
        .get_type_data::<ReflectQueryable>(TypeId::of::<Zoobazee>())
        .unwrap();

    let mut query = type_data.query_mut(world);

    for element in query.iter(world) {
        println!("{element:?}");
    }
}

Trait Implementations

impl Clone for ReflectQueryable

fn clone(&self) -> ReflectQueryable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Component + Reflect> FromType<C> for ReflectQueryable

fn from_type() -> Self