Bevy ECS

https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/
Admin
Bevy ECS is the Entity Component System from the Bevy game engine, providing a flexible architecture...
Tokens:230,177
Snippets:3,020
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### Trim start matches example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Demonstrates removing a slice of characters from the start of a string.

```rust
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Use Logical OR for Run Conditions

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/trait.Condition.html

Example setup for using the .or() combinator.

```rust
use bevy_ecs::prelude::*;

#[derive(Resource, PartialEq)]
struct A(u32);

#[derive(Resource, PartialEq)]
struct B(u32);
```

--------------------------------

### Execute Commands Immediately

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.RunSystemOnce.html

Example of using run_system_once to execute commands for testing.

```rust
let mut world = World::default();
let entity = world.run_system_once(|mut commands: Commands| {
    commands.spawn_empty().id()
}).unwrap();
```

--------------------------------

### Define label macro usage examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/macro.define_label.html

Examples showing both a standard label definition and one with additional trait methods.

```rust
define_label!(
    /// Documentation of label trait
    MyNewLabelTrait,
    MY_NEW_LABEL_TRAIT_INTERNER
);

define_label!(
    /// Documentation of another label trait
    MyNewExtendedLabelTrait,
    MY_NEW_EXTENDED_LABEL_TRAIT_INTERNER,
    extra_methods: {
        // Extra methods for the trait can be defined here
        fn additional_method(&self) -> i32;
    },
    extra_methods_impl: {
        // Implementation of the extra methods for Interned<dyn MyNewExtendedLabelTrait>
        fn additional_method(&self) -> i32 {
            0
        }
    }
);
```

--------------------------------

### Strip prefix examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Examples of removing a prefix exactly once if it exists.

```rust
assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));
```

--------------------------------

### Run Immediate Queries

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.RunSystemOnce.html

Examples of running queries on a world using closures or functions.

```rust
#[derive(Component)]
struct T(usize);

let mut world = World::default();
world.spawn(T(0));
world.spawn(T(1));
world.spawn(T(1));
let count = world.run_system_once(|query: Query<&T>| {
    query.iter().filter(|t| t.0 == 1).count()
}).unwrap();
```

```rust
#[derive(Component)]
struct T(usize);

fn count(query: Query<&T>) -> usize {
    query.iter().filter(|t| t.0 == 1).count()
}

let mut world = World::default();
world.spawn(T(0));
world.spawn(T(1));
world.spawn(T(1));
let count = world.run_system_once(count).unwrap();
```

--------------------------------

### Trim prefix examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Examples of removing a prefix if present, returning the original string otherwise. Requires the nightly-only feature flag.

```rust
#![feature(trim_prefix_suffix)]

// Prefix present - removes it
assert_eq!("foo:bar".trim_prefix("foo:"), "bar");
assert_eq!("foofoo".trim_prefix("foo"), "foo");

// Prefix absent - returns original string
assert_eq!("foo:bar".trim_prefix("bar"), "foo:bar");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

--------------------------------

### Validate a system with assert_is_system

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/fn.assert_is_system.html

This example demonstrates how to use assert_is_system to verify a system. Note that this specific example will panic due to conflicting mutable access to the same component.

```rust
fn my_system(query1: Query<&mut Transform>, query2: Query<&mut Transform>) {
    // ...
}

assert_is_system(my_system);
```

--------------------------------

### Build System Parameters

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.ParamBuilder.html

Example demonstrating how to use ParamBuilder to build system state and systems.

```rust
fn my_system(res: Res<R>, param: MyParam, query: Query<&A>) {
    // ...
}

let system = (
    // A plain ParamBuilder can build any parameter type.
    ParamBuilder,
    // The `of::<P>()` method returns a `ParamBuilder`
    // typed as `impl SystemParamBuilder<P>`.
    ParamBuilder::of::<MyParam>(),
    // The other factory methods return typed builders
    // for common parameter types.
    ParamBuilder::query::<&A>(),
)
    .build_state(&mut world)
    .build_system(my_system);
```

--------------------------------

### Strip suffix examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Examples of removing a suffix exactly once if it exists.

```rust
assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));
```

--------------------------------

### Box::new Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Basic usage of Box::new to allocate memory on the heap.

```rust
let five = Box::new(5);
```

--------------------------------

### Box::new_uninit Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Constructing a box with uninitialized contents and deferred initialization.

```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

--------------------------------

### Run a simple system in a Schedule

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/struct.Schedule.html

Demonstrates the basic setup of a Schedule and running a single system.

```rust
fn hello_world() { println!("Hello world!") }

fn main() {
    let mut world = World::new();
    let mut schedule = Schedule::default();
    schedule.add_systems(hello_world);

    schedule.run(&mut world);
}
```

--------------------------------

### Trim end matches examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Examples of repeatedly removing matching suffixes from the end of a string.

```rust
assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
```

--------------------------------

### Defining and Accessing Resources

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/resource/trait.Resource.html

Example of deriving Resource and accessing it via system parameters.

```rust
#[derive(Resource)]
struct MyResource { value: u32 }

world.insert_resource(MyResource { value: 42 });

fn read_resource_system(resource: Res<MyResource>) {
    assert_eq!(resource.value, 42);
}

fn write_resource_system(mut resource: ResMut<MyResource>) {
    assert_eq!(resource.value, 42);
    resource.value = 0;
    assert_eq!(resource.value, 0);
}
```

--------------------------------

### Trim suffix examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Examples of removing a suffix if present, returning the original string otherwise. Requires the nightly-only feature flag.

```rust
#![feature(trim_prefix_suffix)]

// Suffix present - removes it
assert_eq!("bar:foo".trim_suffix(":foo"), "bar");
assert_eq!("foofoo".trim_suffix("foo"), "foo");

// Suffix absent - returns original string
assert_eq!("bar:foo".trim_suffix("bar"), "bar:foo");

// Method chaining example
assert_eq!("<https://example.com/>".trim_prefix('<').trim_suffix('>'), "https://example.com/");
```

--------------------------------

### Box::try_new_uninit Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Constructing a box with uninitialized contents and error handling.

```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

--------------------------------

### Using Tuples of SystemInputs

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.SystemInput.html

Example demonstrating how to use a tuple of SystemInput types as a system argument.

```rust
use bevy_ecs::prelude::*;

fn add((InMut(a), In(b)): (InMut<usize>, In<usize>)) {
    *a += b;
}
```

--------------------------------

### Box::try_new_zeroed Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Constructing a box with zeroed memory and error handling.

```rust
#![feature(allocator_api)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```

--------------------------------

### EntityEntryCommands Usage Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.EntityEntryCommands.html

Demonstrates chaining component modification and insertion using EntityEntryCommands.

```rust
#[derive(Component)]
struct Level(u32);

fn level_up_system(mut commands: Commands, player: Res<PlayerEntity>) {
    commands
        .entity(player.entity)
        .entry::<Level>()
        // Modify the component if it exists.
        .and_modify(|mut lvl| lvl.0 += 1)
        // Otherwise, insert a default value.
        .or_insert(Level(0))
        // Return the EntityCommands for the entity.
        .entity()
        // Continue chaining method calls.
        .insert(Name::new("Player"));
}
```

--------------------------------

### get_non_send_mut_by_id

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Gets a mutable !Send resource by its ComponentId.

```APIDOC
## pub fn get_non_send_mut_by_id(&mut self, component_id: ComponentId) -> Option<MutUntyped<'_>> 

### Description
Gets a `!Send` resource to the resource with the id `ComponentId` if it exists. The returned pointer may be used to modify the resource, as long as the mutable borrow of the `World` is still valid.

### Panics
This function will panic if it isn’t called from the same thread that the resource was inserted from.
```

--------------------------------

### Parallel Iteration with Initialization

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/query/struct.QueryParIter.html

Example demonstrating the use of for_each_init to perform parallel operations with thread-local state.

```rust
use bevy_utils::Parallel;
use crate::{bevy_ecs::prelude::Component, bevy_ecs::system::Query};
#[derive(Component)]
struct T;
fn system(query: Query<&T>){
    let mut queue: Parallel<usize> = Parallel::default();
    // queue.borrow_local_mut() will get or create a thread_local queue for each task/thread;
    query.par_iter().for_each_init(|| queue.borrow_local_mut(),|local_queue, item| {
        **local_queue += 1;
     });
     
    // collect value from every thread
    let entity_count: usize = queue.iter_mut().map(|v| *v).sum();
}
```

--------------------------------

### Box::new_zeroed Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Constructing a box with zeroed memory using the nightly-only API.

```rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
```

--------------------------------

### Build systems using SystemParamBuilder

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.SystemParamBuilder.html

Examples demonstrating how to build systems using tuples of builders, including closure-based systems with inferred or explicit types.

```rust
fn some_system(param: MyParam) {}

fn build_system(builder: impl SystemParamBuilder<MyParam>) {
    let mut world = World::new();
    // To build a system, create a tuple of `SystemParamBuilder`s
    // with a builder for each parameter.
    // Note that the builder for a system must be a tuple,
    // even if there is only one parameter.
    (builder,)
        .build_state(&mut world)
        .build_system(some_system);
}

fn build_closure_system_infer(builder: impl SystemParamBuilder<MyParam>) {
    let mut world = World::new();
    // Closures can be used in addition to named functions.
    // If a closure is used, the parameter types must all be inferred
    // from the builders, so you cannot use plain `ParamBuilder`.
    (builder, ParamBuilder::resource())
        .build_state(&mut world)
        .build_system(|param, res| {
            let param: MyParam = param;
            let res: Res<R> = res;
        });
}

fn build_closure_system_explicit(builder: impl SystemParamBuilder<MyParam>) {
    let mut world = World::new();
    // Alternately, you can provide all types in the closure
    // parameter list and call `build_any_system()`.
    (builder, ParamBuilder)
        .build_state(&mut world)
        .build_any_system(|param: MyParam, res: Res<R>| {});
}
```

--------------------------------

### Using DetectChangesMut with ResMut

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/change_detection/trait.DetectChangesMut.html

Example demonstrating how to check for changes and trigger change detection using ResMut.

```rust
use bevy_ecs::prelude::*;

#[derive(Resource)]
struct MyResource(u32);

fn my_system(mut resource: ResMut<MyResource>) {
    if resource.is_changed() {
        println!("My resource was mutated!");
    }

   resource.0 = 42; // triggers change detection via [`DerefMut`]
}
```

--------------------------------

### Using resource_changed_or_removed in a System

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/common_conditions/fn.resource_changed_or_removed.html

Example demonstrating how to use the condition to trigger a system when a resource changes or is removed.

```rust
app.add_systems(
    // `resource_changed_or_removed` will only return true if the
    // given resource was just changed or removed (or added)
    my_system.run_if(
        resource_changed_or_removed::<Counter>
        // By default detecting changes will also trigger if the resource was
        // just added, this won't work with my example so I will add a second
        // condition to make sure the resource wasn't just added
        .and(not(resource_added::<Counter>))
    ),
);

#[derive(Resource, Default)]
struct MyResource;

// If `Counter` exists, increment it, otherwise insert `MyResource`
fn my_system(mut commands: Commands, mut counter: Option<ResMut<Counter>>) {
    if let Some(mut counter) = counter {
        counter.0 += 1;
    } else {
        commands.init_resource::<MyResource>();
    }
}

// `Counter` hasn't been changed so `my_system` won't run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 0);

world.resource_mut::<Counter>().0 = 50;

// `Counter` was just changed so `my_system` will run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 51);

world.remove_resource::<Counter>();

// `Counter` was just removed so `my_system` will run
app.run(&mut world);
assert_eq!(world.contains_resource::<MyResource>(), true);
```

--------------------------------

### Create and consume a QueryState

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/query/struct.QueryBuilder.html

Demonstrates initializing a builder, adding constraints, and building a QueryState to query the world.

```rust
let mut world = World::new();
let entity_a = world.spawn((A, B)).id();
let entity_b = world.spawn((A, C)).id();

// Instantiate the builder using the type signature of the iterator you will consume
let mut query = QueryBuilder::<(Entity, &B)>::new(&mut world)
// Add additional terms through builder methods
    .with::<A>()
    .without::<C>()
    .build();

// Consume the QueryState
let (entity, b) = query.single(&world).unwrap();
```

--------------------------------

### Box::try_new Example

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Allocating memory on the heap with error handling via the allocator API.

```rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;
```

--------------------------------

### Hierarchical spawning with Spawn

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/spawn/struct.Spawn.html

Example of using the Spawn wrapper to create a hierarchy of entities within a World.

```rust
let mut world = World::new();
world.spawn((
    Name::new("Root"),
    Children::spawn((
        Spawn(Name::new("Child1")),
        Spawn((
            Name::new("Child2"),
            Children::spawn(Spawn(Name::new("Grandchild"))),
        ))
    )),
));
```

--------------------------------

### AncestorIter Constructor

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/relationship/struct.AncestorIter.html

Creates a new instance of AncestorIter using a query and a starting entity.

```rust
pub fn new(parent_query: &'w Query<'w, 's, D, F>, entity: Entity) -> Self
```

--------------------------------

### Example of a Failing Read-Only Assertion

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/fn.assert_is_read_only_system.html

This example demonstrates a compilation failure when passing a system that mutably accesses a component to the assertion function.

```rust
fn my_system(query: Query<&mut Transform>) {
    // ...
}

assert_is_read_only_system(my_system);
```

--------------------------------

### Configure system ordering with IntoScheduleConfigs

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/trait.IntoScheduleConfigs.html

Demonstrates how to group systems and define execution order using the .after() method.

```rust
fn handle_input() {}

fn update_camera() {}
fn update_character() {}

app.add_systems(
    Update,
    (
        handle_input,
        (update_camera, update_character).after(handle_input)
    )
);
```

--------------------------------

### get_non_send_resource<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Safely gets a reference to a non-send resource of the given type.

```APIDOC
## pub fn get_non_send_resource<R: 'static>(&self) -> Option<&R>

### Description
Gets a reference to the non-send resource of the given type, if it exists. Returns `None` if it does not exist. Panics if called from a different thread than the one where the resource was inserted.
```

--------------------------------

### Initialize Local with LocalBuilder

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.LocalBuilder.html

Example showing how to use LocalBuilder to set an initial value for a Local system parameter.

```rust
let system = (LocalBuilder(100),)
    .build_state(&mut world)
    .build_system(|local: Local<usize>| {
        assert_eq!(*local, 100);
    });
```

--------------------------------

### non_send_resource_mut<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Gets a mutable reference to a non-send resource of the given type.

```APIDOC
## pub fn non_send_resource_mut<R: 'static>(&mut self) -> Mut<'_, R>

### Description
Gets a mutable reference to the non-send resource of the given type, if it exists. Panics if the resource does not exist or if called from a different thread than the one where the resource was inserted.
```

--------------------------------

### non_send_resource<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Gets an immutable reference to a non-send resource of the given type.

```APIDOC
## pub fn non_send_resource<R: 'static>(&self) -> &R

### Description
Gets an immutable reference to the non-send resource of the given type, if it exists. Panics if the resource does not exist or if called from a different thread than the one where the resource was inserted.
```

--------------------------------

### Configure System Ordering

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/index.html

Demonstrates using .chain() and explicit .after()/.before() dependencies to control system execution order.

```rust
// Configure these systems to run in order using `chain()`.
schedule.add_systems((print_first, print_last).chain());
// Prints "HelloWorld!"
schedule.run(&mut world);

// Configure this system to run in between the other two systems
// using explicit dependencies.
schedule.add_systems(print_mid.after(print_first).before(print_last));
// Prints "Hello, World!"
schedule.run(&mut world);

fn print_first() {
    print!("Hello");
}
fn print_mid() {
    print!(", ");
}
fn print_last() {
    println!("World!");
}
```

--------------------------------

### Run multiple systems with ordering constraints

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/struct.Schedule.html

Shows how to define execution order for multiple systems using before and after constraints.

```rust
fn system_one() { println!("System 1 works!") }
fn system_two() { println!("System 2 works!") }
fn system_three() { println!("System 3 works!") }

fn main() {
    let mut world = World::new();
    let mut schedule = Schedule::default();
    schedule.add_systems((
        system_two,
        system_one.before(system_two),
        system_three.after(system_two),
    ));

    schedule.run(&mut world);
}
```

--------------------------------

### Use StaticSystemParam in Generic Contexts

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.StaticSystemParam.html

Example showing how to use StaticSystemParam to enable generic SystemParam arguments.

```rust
use bevy_ecs::system::{SystemParam, StaticSystemParam};
#[derive(SystemParam)]
struct GenericParam<'w,'s, T: SystemParam + 'static> {
    field: StaticSystemParam<'w, 's, T>,
}
fn do_thing_generically<T: SystemParam + 'static>(t: StaticSystemParam<T>) {}

fn check_always_is_system<T: SystemParam + 'static>(){
    bevy_ecs::system::assert_is_system(do_thing_generically::<T>);
}
```

--------------------------------

### into_query_lens

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/lifetimeless/type.SQuery.html

Consumes the query to get a QueryLens with the same accesses.

```APIDOC
## pub fn into_query_lens(self) -> QueryLens<'w, D>

### Description
Gets a QueryLens with the same accesses as the existing query.
```

--------------------------------

### Run systems and retrieve output

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Illustrates executing multiple registered systems and collecting their return values.

```rust

#[derive(Resource)]
struct PlayerScore(i32);

#[derive(Resource)]
struct OpponentScore(i32);

fn get_player_score(player_score: Res<PlayerScore>) -> i32 {
  player_score.0
}

fn get_opponent_score(opponent_score: Res<OpponentScore>) -> i32 {
  opponent_score.0
}

let mut world = World::default();
world.insert_resource(PlayerScore(3));
world.insert_resource(OpponentScore(2));

let scoring_systems = [
  ("player", world.register_system(get_player_score)),
  ("opponent", world.register_system(get_opponent_score)),
];

for (label, scoring_system) in scoring_systems {
  println!("{label} has score {}", world.run_system(scoring_system).expect("system succeeded"));
}
```

--------------------------------

### Run a system with input

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Demonstrates passing input to a registered system using run_system_with.

```rust
fn increment(In(increment_by): In<u8>, mut counter: Local<u8>) -> u8 {
  *counter += increment_by;
  *counter
}

let mut world = World::default();
let counter_one = world.register_system(increment);
let counter_two = world.register_system(increment);
assert_eq!(world.run_system_with(counter_one, 1).unwrap(), 1);
assert_eq!(world.run_system_with(counter_one, 20).unwrap(), 21);
assert_eq!(world.run_system_with(counter_two, 30).unwrap(), 30);
```

--------------------------------

### get_resource

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/unsafe_world_cell/struct.UnsafeWorldCell.html

Gets a reference to the resource of the given type if it exists.

```APIDOC
## pub unsafe fn get_resource<R: Resource>(self) -> Option<&'w R>

### Description
Gets a reference to the resource of the given type if it exists.

### Safety
It is the caller's responsibility to ensure that the UnsafeWorldCell has permission to access the resource and no mutable reference to the resource exists at the same time.
```

--------------------------------

### resource_mut

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.DeferredWorld.html

Gets a mutable reference to the resource of the given type.

```APIDOC
### pub fn resource_mut<R: Resource>(&mut self) -> Mut<'_, R>

Gets a mutable reference to the resource of the given type. Panics if the resource does not exist.
```

--------------------------------

### run_system_once<T, Out, Marker>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.RunSystemOnce.html

Executes a system immediately and applies deferred parameters.

```APIDOC
## fn run_system_once<T, Out, Marker>(self, system: T) -> Result<Out, RunSystemError>

### Description
Tries to run a system and apply its deferred parameters. This is a provided method that assumes no input is required.

### Parameters
- **system** (T) - The system to execute, must implement IntoSystem<(), Out, Marker>.

### Returns
- **Result<Out, RunSystemError>** - The output of the system or a RunSystemError if execution fails.
```

--------------------------------

### Build ParamSet with tuples and vectors

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.ParamSetBuilder.html

Examples demonstrating how to build a ParamSet using a tuple of builders or a vector of boxed builders.

```rust
let system = (ParamSetBuilder((
    QueryParamBuilder::new(|builder| {
        builder.with::<Enemy>();
    }),
    QueryParamBuilder::new(|builder| {
        builder.with::<Ally>();
    }),
    ParamBuilder,
)),)
    .build_state(&mut world)
    .build_system(buildable_system_with_tuple);

fn buildable_system_with_tuple(
    mut set: ParamSet<(Query<&mut Health>, Query<&mut Health>, &World)>,
) {
    // The first parameter is built from the first builder,
    // so this will iterate over enemies.
    for mut health in set.p0().iter_mut() {}
    // And the second parameter is built from the second builder,
    // so this will iterate over allies.
    for mut health in set.p1().iter_mut() {}
    // Parameters that don't need special building can use `ParamBuilder`.
    let entities = set.p2().entities();
}

let system = (ParamSetBuilder(vec![
    QueryParamBuilder::new_box(|builder| {
        builder.with::<Enemy>();
    }),
    QueryParamBuilder::new_box(|builder| {
        builder.with::<Ally>();
    }),
]),)
    .build_state(&mut world)
    .build_system(buildable_system_with_vec);

fn buildable_system_with_vec(mut set: ParamSet<Vec<Query<&mut Health>>>) {
    // As with tuples, the first parameter is built from the first builder,
    // so this will iterate over enemies.
    for mut health in set.get_mut(0).iter_mut() {}
    // And the second parameter is built from the second builder,
    // so this will iterate over allies.
    for mut health in set.get_mut(1).iter_mut() {}
    // You can iterate over the parameters either by index,
    // or using the `for_each` method.
    set.for_each(|mut query| for mut health in query.iter_mut() {});
}
```

--------------------------------

### Get default SingleThreadedExecutor

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/struct.SingleThreadedExecutor.html

Returns the default value for the executor.

```rust
fn default() -> SingleThreadedExecutor
```

--------------------------------

### Allocate Box with Custom Allocator

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/type.BoxedSystem.html

Examples of using the nightly-only allocator_api to create boxes with specific allocators.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let five = Box::new_in(5, System);
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let five = Box::try_new_in(5, System)?;
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::new_uninit_in(System);
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);
```

```rust
#![feature(allocator_api)]

use std::alloc::System;

let zero = Box::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };
```

--------------------------------

### Get slice length

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/unique_array/struct.UniqueEntityEquivalentArray.html

Returns the number of elements in the slice.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

--------------------------------

### Implement and queue a custom command

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/command/trait.Command.html

Example of implementing a custom command to modify a resource and queuing it within a system.

```rust
// Our world resource
#[derive(Resource, Default)]
struct Counter(u64);

// Our custom command
struct AddToCounter(u64);

impl Command for AddToCounter {
    fn apply(self, world: &mut World) {
        let mut counter = world.get_resource_or_insert_with(Counter::default);
        counter.0 += self.0;
    }
}

fn some_system(mut commands: Commands) {
    commands.queue(AddToCounter(42));
}
```

--------------------------------

### get_non_send_resource_mut<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Safely gets a mutable reference to a non-send resource of the given type.

```APIDOC
## pub fn get_non_send_resource_mut<R: 'static>(&mut self) -> Option<Mut<'_, R>>

### Description
Gets a mutable reference to the non-send resource of the given type, if it exists. Returns `None` if it does not exist. Panics if called from a different thread than the one where the resource was inserted.
```

--------------------------------

### Get empty archetype

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/archetype/struct.Archetypes.html

Retrieves the archetype containing no components.

```rust
pub fn empty(&self) -> &Archetype
```

--------------------------------

### Checking Result Status

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/error/type.Result.html

Examples of checking if a Result is Ok or Err.

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

--------------------------------

### Flattening Nested Results

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/error/type.Result.html

Examples of flattening nested Result types.

```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

```rust
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```

--------------------------------

### Using QueryLens in Reusable Functions

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.Query.html

Example of a function signature accepting a QueryLens and accessing the underlying query data.

```rust
fn reusable_function(mut lens: QueryLens<&A>) {
    assert_eq!(lens.query().single().unwrap().0, 10);
}
```

--------------------------------

### Check slice prefix

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/unique_array/struct.UniqueEntityEquivalentArray.html

Verifies if a slice starts with a specific sequence.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

--------------------------------

### Spawn entities using SpawnIter

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/spawn/struct.SpawnIter.html

Example showing how to use SpawnIter within a spawn call to create multiple child entities.

```rust
let mut world = World::new();
world.spawn((
    Name::new("Root"),
    Children::spawn((
        Spawn(Name::new("Child1")),
        SpawnIter(["Child2", "Child3"].into_iter().map(Name::new)),
    )),
));
```

--------------------------------

### get_resource_mut

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.DeferredWorld.html

Gets a mutable reference to the resource of the given type if it exists.

```APIDOC
### pub fn get_resource_mut<R: Resource>(&mut self) -> Option<Mut<'_, R>>

Gets a mutable reference to the resource of the given type if it exists, otherwise returns None.
```

--------------------------------

### Using any_with_component in a System

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/common_conditions/fn.any_with_component.html

Demonstrates how to use any_with_component as a run condition for a system.

```rust
app.add_systems(
    my_system.run_if(any_with_component::<MyComponent>),
);

#[derive(Component)]
struct MyComponent;

fn my_system(mut counter: ResMut<Counter>) {
    counter.0 += 1;
}

// No entities exist yet with a `MyComponent` component so `my_system` won't run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 0);

world.spawn(MyComponent);

// An entities with `MyComponent` now exists so `my_system` will run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 1);
```

--------------------------------

### Get value from HashMap

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/hash_map/struct.EntityHashMap.html

Retrieves a reference to a value associated with a key.

```rust
use hashbrown::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

--------------------------------

### run_system_once_with<T, In, Out, Marker>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.RunSystemOnce.html

Executes a system with specific input and applies deferred parameters.

```APIDOC
## fn run_system_once_with<T, In, Out, Marker>(self, system: T, input: SystemIn<'_, T::System>) -> Result<Out, RunSystemError>

### Description
Tries to run a system with given input and apply deferred parameters. This method is not efficient and is intended for testing or diagnostics.

### Parameters
- **system** (T) - The system to execute, must implement IntoSystem<In, Out, Marker>.
- **input** (SystemIn<'_, T::System>) - The input to pass to the system.

### Returns
- **Result<Out, RunSystemError>** - The output of the system or a RunSystemError if execution fails.
```

--------------------------------

### get_resource_or_init<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Gets a mutable reference to a resource of type R if it exists, otherwise initializes it using its FromWorld implementation.

```APIDOC
## pub fn get_resource_or_init<R: Resource + FromWorld>(&mut self) -> Mut<'_, R>

### Description
Gets a mutable reference to the resource of type R if it exists, otherwise initializes the resource by calling its `FromWorld` implementation.
```

--------------------------------

### Get the hasher of a HashSet

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/hash_set/struct.EntityHashSet.html

Retrieve a reference to the set's BuildHasher.

```rust
use hashbrown::HashSet;
use hashbrown::DefaultHashBuilder;

let hasher = DefaultHashBuilder::default();
let set: HashSet<i32> = HashSet::with_hasher(hasher);
let hasher: &DefaultHashBuilder = set.hasher();
```

--------------------------------

### Implement and use Deferred mutations

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/struct.Deferred.html

Example demonstrating how to implement SystemBuffer for a resource and use Deferred to trigger mutations in parallel systems.

```rust
// Tracks whether or not there is a threat the player should be aware of.
#[derive(Resource, Default)]
pub struct Alarm(bool);

#[derive(Component)]
pub struct Settlement {
    // ...
}

// A threat from inside the settlement.
#[derive(Component)]
pub struct Criminal;

// A threat from outside the settlement.
#[derive(Component)]
pub struct Monster;


use bevy_ecs::system::{Deferred, SystemBuffer, SystemMeta};

// Uses deferred mutations to allow signaling the alarm from multiple systems in parallel.
#[derive(Resource, Default)]
struct AlarmFlag(bool);

impl AlarmFlag {
    /// Sounds the alarm the next time buffers are applied via ApplyDeferred.
    pub fn flag(&mut self) {
        self.0 = true;
    }
}

impl SystemBuffer for AlarmFlag {
    // When `AlarmFlag` is used in a system, this function will get
    // called the next time buffers are applied via ApplyDeferred.
    fn apply(&mut self, system_meta: &SystemMeta, world: &mut World) {
        if self.0 {
            world.resource_mut::<Alarm>().0 = true;
            self.0 = false;
        }
    }
}

// Sound the alarm if there are any criminals who pose a threat.
fn alert_criminal(
    settlement: Single<&Settlement>,
    criminals: Query<&Criminal>,
    mut alarm: Deferred<AlarmFlag>
) {
    for criminal in &criminals {
        // Only sound the alarm if the criminal is a threat.
        // For this example, assume that this check is expensive to run.
        // Since the majority of this system's run-time is dominated
        // by calling `is_threat()`, we defer sounding the alarm to
        // allow this system to run in parallel with other alarm systems.
        if criminal.is_threat(*settlement) {
            alarm.flag();
        }
    }
}

// Sound the alarm if there is a monster.
fn alert_monster(
    monsters: Query<&Monster>,
    mut alarm: ResMut<Alarm>
) {
    if monsters.iter().next().is_some() {
        // Since this system does nothing except for sounding the alarm,
        // it would be pointless to defer it, so we sound the alarm directly.
        alarm.0 = true;
    }
}

let mut world = World::new();
world.init_resource::<Alarm>();
world.spawn(Settlement {
    // ...
});

let mut schedule = Schedule::default();
// These two systems have no conflicts and will run in parallel.
schedule.add_systems((alert_criminal, alert_monster));

// There are no criminals or monsters, so the alarm is not sounded.
schedule.run(&mut world);
assert_eq!(world.resource::<Alarm>().0, false);

// Spawn a monster, which will cause the alarm to be sounded.
let m_id = world.spawn(Monster).id();
schedule.run(&mut world);
assert_eq!(world.resource::<Alarm>().0, true);

// Remove the monster and reset the alarm.
world.entity_mut(m_id).despawn();
world.resource_mut::<Alarm>().0 = false;

// Spawn a criminal, which will cause the alarm to be sounded.
world.spawn(Criminal);
schedule.run(&mut world);
assert_eq!(world.resource::<Alarm>().0, true);
```

--------------------------------

### Register and run a system with Commands

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/lifetimeless/type.SCommands.html

Registers a system to obtain a SystemId, which can then be used to execute the system repeatedly. Storing the ID in a Local resource prevents redundant registrations.

```rust
#[derive(Resource)]
struct Counter(i32);

fn register_system(
    mut commands: Commands,
    mut local_system: Local<Option<SystemId>>,
) {
    if let Some(system) = *local_system {
        commands.run_system(system);
    } else {
        *local_system = Some(commands.register_system(increment_counter));
    }
}

fn increment_counter(mut value: ResMut<Counter>) {
    value.0 += 1;
}
```

--------------------------------

### Get length of EntityHashSet

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/hash_set/struct.EntityHashSet.html

Retrieve the number of elements currently in the set.

```rust
let mut map = HashSet::new();

assert_eq!(map.len(), 0);

map.insert("foo");

assert_eq!(map.len(), 1);
```

--------------------------------

### Get or initialize resource via FromWorld

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Retrieves a mutable reference to a resource or initializes it using its FromWorld implementation.

```rust
#[derive(Resource)]
struct Foo(i32);

impl Default for Foo {
    fn default() -> Self {
        Self(15)
    }
}

#[derive(Resource)]
struct MyResource(i32);

impl FromWorld for MyResource {
    fn from_world(world: &mut World) -> Self {
        let foo = world.get_resource_or_init::<Foo>();
        Self(foo.0 * 2)
    }
}

let my_res = world.get_resource_or_init::<MyResource>();
assert_eq!(my_res.0, 30);
```

--------------------------------

### Using resource_exists_and_changed in a System

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/common_conditions/fn.resource_exists_and_changed.html

Example demonstrating how to apply the run condition to a system, including handling the initial addition case.

```rust
app.add_systems(
    // `resource_exists_and_changed` will only return true if the
    // given resource exists and was just changed (or added)
    my_system.run_if(
        resource_exists_and_changed::<Counter>
        // By default detecting changes will also trigger if the resource was
        // just added, this won't work with my example so I will add a second
        // condition to make sure the resource wasn't just added
        .and(not(resource_added::<Counter>))
    ),
);

fn my_system(mut counter: ResMut<Counter>) {
    counter.0 += 1;
}

// `Counter` doesn't exist so `my_system` won't run
app.run(&mut world);
world.init_resource::<Counter>();

// `Counter` hasn't been changed so `my_system` won't run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 0);

world.resource_mut::<Counter>().0 = 50;

// `Counter` was just changed so `my_system` will run
app.run(&mut world);
assert_eq!(world.resource::<Counter>().0, 51);
```

--------------------------------

### Convert a function into a system

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/trait.IntoSystem.html

Demonstrates how to manually convert a system function into a system using the into_system method.

```rust
use bevy_ecs::prelude::*;

fn my_system_function(a_usize_local: Local<usize>) {}

let system = IntoSystem::into_system(my_system_function);
```

--------------------------------

### Children Implementation of RelationshipTarget

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/relationship/trait.RelationshipTarget.html

Example implementation of the RelationshipTarget trait for the Children component.

```rust
impl RelationshipTarget for Children
const LINKED_SPAWN: bool = true
type Relationship = ChildOf
type Collection = Vec<Entity>
```

--------------------------------

### Get or insert resource with closure

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Retrieves a mutable reference to a resource or inserts a new one using a provided closure if it does not exist.

```rust
#[derive(Resource)]
struct MyResource(i32);

let my_res = world.get_resource_or_insert_with(|| MyResource(10));
assert_eq!(my_res.0, 10);
```

--------------------------------

### Run a system with change detection

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Shows how systems can detect changes in resources between executions.

```rust
#[derive(Resource, Default)]
struct ChangeDetector;

let mut world = World::default();
world.init_resource::<ChangeDetector>();
let detector = world.register_system(|change_detector: ResMut<ChangeDetector>| {
    if change_detector.is_changed() {
        println!("Something happened!");
    } else {
        println!("Nothing happened.");
    }
});

// Resources are changed when they are first added
let _ = world.run_system(detector); // -> Something happened!
let _ = world.run_system(detector); // -> Nothing happened.
world.resource_mut::<ChangeDetector>().set_changed();
let _ = world.run_system(detector); // -> Something happened!
```

--------------------------------

### Transposing Result and Option

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/error/type.Result.html

Example of transposing a Result of an Option into an Option of a Result.

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;

let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

--------------------------------

### get_resource_or_insert_with<R>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Gets a mutable reference to a resource of type R if it exists, otherwise inserts the resource using the provided function.

```APIDOC
## pub fn get_resource_or_insert_with<R: Resource>( &mut self, func: impl FnOnce() -> R, ) -> Mut<'_, R>

### Description
Gets a mutable reference to the resource of type R if it exists, otherwise inserts the resource using the result of calling `func`.

### Parameters
- **func** (impl FnOnce() -> R) - Required - A function that returns the resource to insert if it does not exist.
```

--------------------------------

### Trim start whitespace in Rust

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Removes leading whitespace from a string slice.

```rust
let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());
```

--------------------------------

### Use Logical NAND for Run Conditions

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/trait.Condition.html

Demonstrates using .nand() and equivalent logic with not and and.

```rust
use bevy::prelude::*;

#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlayerState {
    Alive,
    Dead,
}

#[derive(States, Debug, Clone, PartialEq, Eq, Hash)]
pub enum EnemyState {
    Alive,
    Dead,
}

app.add_systems(
    // The game_over_credits system will only execute if either the `in_state(PlayerState::Alive)`
    // run condition or `in_state(EnemyState::Alive)` run condition evaluates to `false`.
    game_over_credits.run_if(
        in_state(PlayerState::Alive).nand(in_state(EnemyState::Alive))
    ),
);
```

```rust
app.add_systems(
    game_over_credits.run_if(
        not(in_state(PlayerState::Alive).and(in_state(EnemyState::Alive)))
    ),
);
```

--------------------------------

### Initialize a Resource with Commands

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/system/lifetimeless/type.SCommands.html

Uses the FromWorld trait to initialize a resource. If the resource already exists, no action is taken.

```rust
#[derive(Resource, Default)]
struct Scoreboard {
    current_score: u32,
    high_score: u32,
}

fn initialize_scoreboard(mut commands: Commands) {
    commands.init_resource::<Scoreboard>();
}
```

--------------------------------

### Match patterns with indices

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Returns an iterator over disjoint matches and their starting indices.

```rust
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // only the first `aba`
```

--------------------------------

### run_system_with<I, O>

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.World.html

Executes a registered chained system with a provided input.

```APIDOC
## run_system_with<I, O>

### Description
Runs a stored chained system by its `SystemId` while providing an input value.

### Parameters
- **id** (SystemId<I, O>) - The ID of the system to execute.
- **input** (I::Inner<'_>) - The input value to pass to the system.

### Returns
- **Result<O, RegisteredSystemError<I, O>>** - The output of the system or an error.
```

--------------------------------

### Check if string starts with pattern

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/name/struct.Name.html

Checks if a pattern matches the prefix of the string.

```rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Get component reference

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/world/struct.OccupiedEntry.html

Retrieve an immutable reference to the component stored in the entry.

```rust
#[derive(Component, Default, Clone, Copy, Debug, PartialEq)]
struct Comp(u32);

let mut entity = world.spawn(Comp(5));

if let Entry::Occupied(o) = entity.entry::<Comp>() {
    assert_eq!(o.get().0, 5);
}
```

--------------------------------

### Access raw pointer

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/unique_slice/struct.UniqueEntityEquivalentSlice.html

Method to get a mutable pointer to the underlying buffer.

```rust
pub const fn as_mut_ptr(&mut self) -> *mut T
```

--------------------------------

### Box::from_raw Examples

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/schedule/type.BoxedCondition.html

Constructing a box from a raw pointer, either from a previous Box::into_raw or manual allocation.

```rust
let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };
```

```rust
use std::alloc::{alloc, Layout};

unsafe {
    let ptr = alloc(Layout::new::<i32>()) as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw(ptr);
}
```

--------------------------------

### Get last element

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/unique_array/struct.UniqueEntityEquivalentArray.html

Returns the last element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());
```

--------------------------------

### Get first element

Source: https://docs.rs/bevy_ecs/0.16.1/bevy_ecs/entity/unique_array/struct.UniqueEntityEquivalentArray.html

Returns the first element of the slice, or None if it is empty.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```
Tokens:
Raw