Leptos Bevy Canvas

https://docs.rs/leptos-bevy-canvas/
Admin
Leptos Bevy Canvas is a Rust crate that embeds an idiomatic Bevy app inside your Leptos app with...
Tokens:166,789
Snippets:1,037
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Element Offset for Unaligned Element

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Demonstrates `element_offset` returning `None` when an element reference is not aligned with the start of an element in the slice. This occurs when the reference points to an intermediate position within a flattened slice.

```rust
let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### Basic Vec initialization and assertion

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Demonstrates basic vector creation and assertion of its length.

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

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

### Get Element Offset in Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns the index of an element reference within a slice. Returns `None` if the element reference is not aligned with the start of an element. This method uses pointer arithmetic and does not compare elements.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));
```

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

### Implement CloneToUninit (Nightly)

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ExportLeptosMessageSet.html

Nightly-only experimental API for cloning data into uninitialized memory.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8);
```

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

### System Set Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ExportLeptosMessageSet.html

Methods for configuring the order and conditions of system sets.

```APIDOC
## ScheduleConfigs<T>

### Description
Provides methods to configure how a collection of systems is scheduled.

### Methods

#### `before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

#### `after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

#### `before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
Run before all systems in `set`.

#### `after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
Run after all systems in `set`.

#### `distributive_run_if<M>(self, condition: impl SystemCondition<M> + Clone) -> ScheduleConfigs<T>`
Add a run condition to each contained system.

#### `run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>`
Run the systems only if the `SystemCondition` is `true`.

#### `ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

#### `ambiguous_with_all(self) -> ScheduleConfigs<T>`
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

#### `chain(self) -> ScheduleConfigs<T>`
Treat this collection as a sequence of systems.

#### `chain_ignore_deferred(self) -> ScheduleConfigs<T>`
Treat this collection as a sequence of systems.
```

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

### Get Type ID of Any Trait Object

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageReceiver.html

Gets the `TypeId` of the trait object. This is a fundamental operation for dynamic dispatch and type introspection.

```rust
fn type_id(&self) -> TypeId>
```

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

### Remove and Get Last Element of Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `split_off_last` to remove the last element from an immutable slice and get a reference to it. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');
```

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

### Insertion with partition_point

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Demonstrates how to use `partition_point` to efficiently insert an element into a sorted vector while maintaining order.

```APIDOC
## Insertion with partition_point

### Description
If you want to insert an item to a sorted vector, while maintaining sort order, consider using `partition_point`.

### Method
N/A (method on Vec)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

### Response
N/A (modifies Vec in place)

### Response Example
N/A
```

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

### Remove and Get First Element of Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `split_off_first` to remove the first element from an immutable slice and get a reference to it. Returns `None` if the slice is empty.

```rust
let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');
```

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

### System Set Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncQuerySet.html

Methods for configuring the execution order and conditions of system sets.

```APIDOC
## System Set Configurations

### `after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

### `before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run before all systems in `set`.

### `after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`.

### `distributive_run_if<M>(self, condition: impl SystemCondition<M> + Clone) -> ScheduleConfigs<T>`

Add a run condition to each contained system.

### `run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>`

Run the systems only if the `SystemCondition` is `true`.

### `ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

### `ambiguous_with_all(self) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

### `chain(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.

### `chain_ignore_deferred(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.
```

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

### Get Disjoint Mutable References by Index

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `get_disjoint_unchecked_mut` to get mutable references to multiple elements or sub-slices at specified indices without bounds checking. This is an unsafe operation.

```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);
```

```rust
unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);
```

```rust
unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(x, &[1, 11, 111]);
```

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

### Convert Into Schedule Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncQuerySet.html

Converts into `ScheduleConfigs` or adds systems to a specified set.

```rust
fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>
```

```rust
fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>
```

```rust
fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>
```

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

### Implement Clone for SyncSignalResourceSet

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncSignalResourceSet.html

Provides methods for cloning SyncSignalResourceSet instances. `clone` creates a duplicate, and `clone_from` performs copy-assignment.

```rust
fn clone(&self) -> SyncSignalResourceSet
```

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

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

### Remove and Get Last Mutable Element of Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `split_off_last_mut` to remove the last element from a mutable slice and get a mutable reference to it. Returns `None` if the slice is empty.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'d');
```

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

### Inserting into a Sorted Vector with Partition Point

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Shows how to use `partition_point` to find the correct insertion index in a sorted vector to maintain order. This can be more efficient than `binary_search` followed by an insert.

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

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

### Remove and Get First Mutable Element of Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `split_off_first_mut` to remove the first element from a mutable slice and get a mutable reference to it. Returns `None` if the slice is empty.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');
```

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

### System Set Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncSignalResourceSet.html

Provides methods for configuring system sets within a schedule, allowing for the organization and management of systems.

```APIDOC
## System Set Configurations

### Description
This section covers the configuration of system sets, enabling systems to be grouped and managed within a schedule.

### Implementations
- **`impl<S> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S where S: SystemSet`**
  - `fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>`: Converts the system set into `ScheduleConfigs`.
  - `fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>`: Adds systems to a specified set.
```

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

### Safely Get Disjoint Mutable References by Index

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `get_disjoint_mut` to safely get mutable references to multiple elements or sub-slices at specified indices. It returns a `Result` to handle out-of-bounds or overlapping indices.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

// Example of successful retrieval
let result = slice.get_disjoint_mut([0..1, 2..3]);
if let Ok([first_part, second_part]) = result {
    assert_eq!(first_part, &['a']);
    assert_eq!(second_part, &['c']);
}
```

```rust
// Example of an error due to overlapping indices
let result = slice.get_disjoint_mut([0..2, 1..3]);
assert!(result.is_err());
```

```rust
// Example of an error due to out-of-bounds index
let result = slice.get_disjoint_mut([0..1, 5..6]);
assert!(result.is_err());
```

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

### Get a raw pointer to the vector's buffer

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `as_ptr` to get a raw pointer to the vector's buffer. The caller must ensure the vector outlives the pointer and that the memory is not mutated through this pointer.

```rust
let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}
```

```rust
unsafe {
    let mut v = vec![0, 1, 2];
    let ptr1 = v.as_ptr();
    let _ = ptr1.read();
    let ptr2 = v.as_mut_ptr().offset(2);
    ptr2.write(2);
    // Notably, the write to `ptr2` did *not* invalidate `ptr1`
    // because it mutated a different element:
    let _ = ptr1.read();
}
```

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

### Convert into ScheduleConfigs

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ExportLeptosMessageSet.html

Converts the current system set into a `ScheduleConfigs`.

```rust
fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>
```

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

### Split Slice from Third Element

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Use `split_off_mut` with a range starting from a specific index to split a mutable slice. The first part contains elements before the range, and the second part contains elements from the start of the range onwards.

```rust
let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);
```

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

### System Scheduling Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportLeptosMessageSet.html

These methods allow for fine-grained control over system execution order and conditions within the Bevy engine.

```APIDOC
## System Scheduling Methods

### `before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

### `after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

### `before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run before all systems in `set`.

### `after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`.

### `distributive_run_if<M>(self, condition: impl SystemCondition<M> + Clone) -> ScheduleConfigs<T>`

Add a run condition to each contained system.

### `run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>`

Run the systems only if the `SystemCondition` is `true`.

### `ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

### `ambiguous_with_all(self) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

### `chain(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.

### `chain_ignore_deferred(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.
```

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

### Resource Implementation

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Marks a type as a resource, typically used in frameworks like Bevy for managing application state. Requires Send, Sync, and 'static bounds.

```rust
impl<M: Message> Resource for ImportedMessageIds<M>
where Self: Send + Sync + 'static,
```

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

### strip_prefix

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

```APIDOC
## pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>

### Description
Returns a subslice with the prefix removed. If the slice starts with `prefix`, returns the subslice after the prefix, wrapped in `Some`. If `prefix` is empty, simply returns the original slice. If `prefix` is equal to the original slice, returns an empty slice. If the slice does not start with `prefix`, returns `None`.

### Method
`strip_prefix`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));
```

### Response
#### Success Response (200)
An `Option` containing the subslice after the prefix if it exists, otherwise `None`.

#### Response Example
```
Some(&[40, 30])
Some(&[30])
Some(&[])
None
```
```

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

### Initialize Vec Elements via NonNull Pointer

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Uses the nightly-only `as_non_null` API to get a `NonNull` pointer for initializing vector elements. This API has specific aliasing guarantees. Requires `unsafe` block and nightly Rust.

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

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### Iterate Over Slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns an iterator over the slice, yielding all items from start to end.

```APIDOC
## GET /slice/iter

### Description
Returns an iterator over the slice. The iterator yields all items from start to end.

### Method
GET

### Endpoint
/slice/iter

### Query Parameters
- **slice** (array) - Required - The slice to iterate over.

### Response
#### Success Response (200)
- **iterator** (object) - An iterator object that can be used to retrieve elements.

### Response Example
```json
{
  "iterator": "<iterator_representation>"
}
```

*Note: The actual representation of the iterator in a JSON response would depend on the specific implementation. This example uses a placeholder.*
```

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

### Implement PartialEq for SyncSignalResourceSet

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncSignalResourceSet.html

Defines equality comparison for SyncSignalResourceSet. `eq` tests for equality, and `ne` tests for inequality.

```rust
fn eq(&self, other: &SyncSignalResourceSet) -> bool
```

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

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

### Run Systems Before a Set

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ExportLeptosMessageSet.html

Use `before` to ensure systems in `self` run before all systems in `set`. Deferred operations in `self` are visible to `set`.

```rust
fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>
```

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

### HasSender Trait

Source: https://docs.rs/leptos-bevy-canvas/latest/src/leptos_bevy_canvas/traits.rs.html

The HasSender trait provides a method to get a reference to a crossbeam_channel::Sender.

```APIDOC
## Trait: HasSender<T>

### Description
Provides read-only access to a `crossbeam_channel::Sender`.

### Methods
- `tx(&self) -> &Sender<T>`: Returns a reference to the sender.

### Example
```rust
use crossbeam_channel::Sender;

pub trait HasSender<T> {
    fn tx(&self) -> &Sender<T>;
}
```
```

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

### starts_with

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns `true` if `needle` is a prefix of the slice or equal to the slice.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.

### Method
`starts_with`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```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]));

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

### Response
#### Success Response (200)
`true` if the slice starts with the `needle`, `false` otherwise.

#### Response Example
```
true
false
```
```

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

### HasReceiver Trait

Source: https://docs.rs/leptos-bevy-canvas/latest/src/leptos_bevy_canvas/traits.rs.html

The HasReceiver trait provides a method to get a reference to a crossbeam_channel::Receiver.

```APIDOC
## Trait: HasReceiver<T>

### Description
Provides read-only access to a `crossbeam_channel::Receiver`.

### Methods
- `rx(&self) -> &Receiver<T>`: Returns a reference to the receiver.

### Example
```rust
use crossbeam_channel::Receiver;

pub trait HasReceiver<T> {
    fn rx(&self) -> &Receiver<T>;
}
```
```

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

### Embed Bevy App in Leptos with Message Passing

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/index.html

Demonstrates embedding a Bevy app within a Leptos component and setting up two-way message passing. Use this to send data from Leptos to Bevy and initialize Bevy systems.

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

#[derive(Message)]
pub struct TextMessage {
    pub text: String,
}

#[component]
pub fn App() -> impl IntoView {
    // This initializes a sender for the Leptos app and
    // a receiver for the Bevy app
    let (text_message_sender, bevy_text_receiver) = message_l2b::<TextMessage>();

    let on_input = move |evt| {
        // send the message over to Bevy
        text_message_sender
            .send(TextMessage { text: event_target_value(&evt) })
            .ok();
    };

    view! {
        <input type="text" on:input=on_input />

        <BevyCanvas
            init=move || {
                // Pass the receiver into the Bevy app initialization
                init_bevy_app(bevy_text_receiver)
            }

            {..}
            width="300"
            height="500"
        />
    }
}

// In Bevy it ends up just as a normal message
pub fn set_text(
    mut message_reader: MessageReader<TextMessage>,
) {
    for message in message_reader.read() {
        // do something with the message
    }
}

// This initializes a normal Bevy app
fn init_bevy_app( text_receiver: BevyMessageReceiver<TextMessage>) -> App {
    let mut app = App::new();
    app
        .add_plugins(
            DefaultPlugins.set(WindowPlugin {
                primary_window: Some(Window {
                    // "#bevy_canvas" is the default and can be
                    // changed in the <BevyCanvas> component
                    canvas: Some("#bevy_canvas".into()),
                    ..default()
                }),
                ..default()
            }),
        )
        // import the message here into Bevy
        .import_message_from_leptos(text_receiver)
        .add_systems(Update, set_text);

    app
}
```

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

### Get Sender from BevyMessageDuplex

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageDuplex.html

Provides immutable access to the sender channel within BevyMessageDuplex.

```rust
fn tx(&self) -> &Sender<T>
```

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

### as_rchunks

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Splits a slice into a slice of N-element arrays starting from the end, and a remainder slice.

```APIDOC
## pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])

### Description
Splits the slice into a slice of `N`-element arrays, starting at the end of the slice, and a remainder slice with length strictly less than `N`.

### Method
GET

### Endpoint
N/A (Method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks::<2>();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

### Response
#### Success Response (200)
Tuple containing two slices: `(&[T], &[[T; N]])`

#### Response Example
```json
{
  "remainder": [...],
  "chunks": [[...], [...]]
}
```

### Panics
Panics if `N` is zero.
```

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

### Convert to System Set

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncQuerySet.html

Implement `IntoSystemSet` to allow types to be converted into associated `SystemSet` types, facilitating system organization and scheduling.

```rust
type Set = S
```

```rust
fn into_system_set(self) -> <S as IntoSystemSet<()>>::Set
```

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

### System Scheduling Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncSignalResourceSet.html

These functions allow for fine-grained control over system execution order and conditions within a Bevy schedule.

```APIDOC
## System Scheduling Functions

### `before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

### `after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

### `before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run before all systems in `set`.

### `after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Run after all systems in `set`.

### `distributive_run_if<M>(self, condition: impl SystemCondition<M> + Clone) -> ScheduleConfigs<T>`

Add a run condition to each contained system.

### `run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>`

Run the systems only if the `SystemCondition` is `true`.

### `ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

### `ambiguous_with_all(self) -> ScheduleConfigs<T>`

Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

### `chain(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.

### `chain_ignore_deferred(self) -> ScheduleConfigs<T>`

Treat this collection as a sequence of systems.
```

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

### Iterate Over Slice Elements

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns an iterator that yields all items from the start to the end of the slice.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### Schedule Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportLeptosMessageSet.html

Functions for configuring system sets within schedules.

```APIDOC
## Schedule Configurations

### `impl<S> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S where S: SystemSet`

#### `fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>`
Convert into a `ScheduleConfigs`.

#### `fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>`
Add these systems to the provided `set`.
```

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

### get

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns a reference to an element or subslice depending on the type of index. Returns None if out of bounds.

```APIDOC
## GET /slice/get

### Description
Returns a reference to an element or subslice depending on the type of index.
  * If given a position, returns a reference to the element at that position or `None` if out of bounds.
  * If given a range, returns the subslice corresponding to that range, or `None` if out of bounds.

### Method
GET

### Endpoint
`/slice/get`

### Parameters
#### Query Parameters
- **index** (usize or Range<usize>) - Required - The index or range to access.

### Response
#### Success Response (200)
- **element_or_subslice** (&<I as SliceIndex<[T]>>::Output) - A reference to the element or subslice.

#### Response Example
```json
{
  "element_or_subslice": 40
}
```
OR
```json
{
  "element_or_subslice": [10, 40]
}
```
```

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

### Vector Slice Access

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Provides methods to get immutable and mutable slices of the entire vector.

```APIDOC
## Vector Slice Access

### Description
These methods provide access to the underlying data of the vector as slices.

### Methods
#### `as_slice`
Extracts an immutable slice containing the entire vector.

#### `as_mut_slice`
Extracts a mutable slice of the entire vector.

### Request Example
```rust
// as_slice example
use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();

// as_mut_slice example
use std::io::{self, Read};
let mut buffer = vec![0; 3];
io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();
```
```

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

### Schedule Configurations

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ExportLeptosMessageSet.html

Functions for configuring system sets within schedules.

```APIDOC
## impl<S> IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S

### Description
Provides methods for converting a system set into schedule configurations.

### Method
`fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>`

### Endpoint
N/A

### Parameters
- **self** (S) - Required - The system set to convert.

### Response
- **ScheduleConfigs<Interned<dyn SystemSet>>** - The schedule configurations.

### Method
`fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>`

### Endpoint
N/A

### Parameters
- **self** (S) - Required - The system set to configure.
- **set** (impl SystemSet) - Required - The target system set.

### Response
- **ScheduleConfigs<T>** - The updated schedule configurations.
```

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

### Convert to OptionGetter

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.RwSignalSynced.html

Converts a clonable, sendable, and static `S` type with a `Get` value of `Option<T>` into an `OptionGetter<T>`.

```rust
fn into_option_getter(self) -> OptionGetter<T>
```

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

### Sync Signal Resource

Source: https://docs.rs/leptos-bevy-canvas/latest/src/leptos_bevy_canvas/systems.rs.html

System for synchronizing a Bevy resource with a Leptos signal.

```APIDOC
## POST /api/sync/resource

### Description
Synchronizes a Bevy resource with a Leptos signal.

### Method
POST

### Endpoint
/api/sync/resource

### Parameters
#### Query Parameters
- **resource** (ResMut<R>) - Required - The Bevy resource to synchronize.
- **sync** (Res<D>) - Required - The Leptos signal resource (receiver and sender).

### Request Body
This endpoint does not have a request body.

### Response
This endpoint does not return a specific response body, but updates the Bevy resource and sends it to the Leptos signal.

#### Response Example
(No specific response body)
```

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

### Sync Leptos Signal with Resource

Source: https://docs.rs/leptos-bevy-canvas/latest/src/leptos_bevy_canvas/app_extension.rs.html

Adds resource syncing between Bevy and Leptos.

```APIDOC
## POST /app/sync_leptos_signal_with_resource

### Description
Adds resource syncing between Bevy and Leptos.

### Method
POST

### Endpoint
/app/sync_leptos_signal_with_resource

### Parameters
#### Query Parameters
- **bevy_duplex** (D) - Required - The Bevy resource receiver/sender.

### Request Body
This endpoint does not have a request body.

### Response
#### Success Response (200)
- **Self** (App) - Returns a mutable reference to the App.

#### Response Example
```json
{
  "message": "App updated successfully"
}
```
```

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

### Get Definition Location

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.LeptosMessageDuplex.html

Returns the location at which the signal was defined. This is usually `None` in release mode.

```rust
fn defined_at(&self) -> Option<&'static Location<'static>>
```

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

### Create BevyMessageDuplex Instance

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageDuplex.html

Constructs a new BevyMessageDuplex with provided receiver and sender channels.

```rust
pub fn new(rx: Receiver<M>, tx: Sender<M>) -> Self
```

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

### Unsafe Getters

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Provides unsafe methods to get references to elements or subslices without bounds checking.

```APIDOC
## GET /slice/unchecked

### Description
Returns a reference to an element or subslice, without doing bounds checking.

### Method
GET

### Endpoint
`/slice/unchecked/{index}`

### Parameters
#### Path Parameters
- **index** (I) - Required - The index or range to access.

### Safety
Calling this method with an out-of-bounds index is undefined behavior.

### Request Example
```rust
let x = &[1, 2, 4];
unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}
```

## GET /slice/unchecked_mut

### Description
Returns a mutable reference to an element or subslice, without doing bounds checking.

### Method
GET

### Endpoint
`/slice/unchecked_mut/{index}`

### Parameters
#### Path Parameters
- **index** (I) - Required - The index or range to access.

### Safety
Calling this method with an out-of-bounds index is undefined behavior.

### Request Example
```rust
let x = &mut [1, 2, 4];
unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);
```
```

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

### Treat Systems as a Sequence

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.SyncQuerySet.html

Use `chain` to process a collection of systems sequentially, ensuring they execute in the order they appear.

```rust
fn chain(self) -> ScheduleConfigs<T>
```

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

### Iterate and Mutate Slice Elements

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns an iterator that allows modifying each value in the slice from start to end.

```rust
let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);
```

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

### Message Passing Utilities

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/index.html

Utilities for enabling bidirectional communication between Leptos and Bevy applications.

```APIDOC
## Message Passing Functions

### `message_l2b`

#### Description
Creates a pair of a `LeptosMessageSender` and a `BevyMessageReceiver` for sending messages from Leptos to Bevy.

#### Function Signature
`pub fn message_l2b() -> (LeptosMessageSender, BevyMessageReceiver)`

### `message_b2l`

#### Description
Creates a pair of a `LeptosMessageReceiver` and a `BevyMessageSender` for sending messages from Bevy to Leptos.

#### Function Signature
`pub fn message_b2l() -> (LeptosMessageReceiver, BevyMessageSender)`

### `message_duplex`

#### Description
Combines the functionality of `message_l2b` and `message_b2l` to send and receive messages in both directions.

#### Function Signature
`pub fn message_duplex() -> (LeptosMessageDuplex, BevyMessageDuplex)`

### Types
- **`LeptosMessageSender`**: Used to send messages to the Bevy app.
- **`LeptosMessageReceiver`**: Used to receive messages from the Bevy app.
- **`BevyMessageSender`**: Used to send messages to the Leptos app.
- **`BevyMessageReceiver`**: Used to receive messages from the Leptos app.
- **`LeptosMessageDuplex`**: Combines `LeptosMessageSender` and `LeptosMessageReceiver`.
- **`BevyMessageDuplex`**: Combines `BevyMessageSender` and `BevyMessageReceiver`.
```

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

### Get &dyn Any from &T

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageSender.html

Converts `&Trait` to `&Any`. This is necessary because Rust cannot generate `&Any`'s vtable from `&Trait`'s. Requires `T: Downcast`.

```rust
fn as_any(&self) -> &(dyn Any + 'static))
```

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

### Instantiate LeptosMessageDuplex

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.LeptosMessageDuplex.html

Constructs a new LeptosMessageDuplex instance. Requires a Receiver, a RwSignal for optional message reception, and a Sender.

```rust
pub fn new( rx: Receiver<M>,
 rx_signal: RwSignal<Option<M>>,
 tx: Sender<M>,
) -> Self
```

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

### Get Receiver from BevyMessageReceiver

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageReceiver.html

Retrieves a reference to the underlying Receiver channel from a BevyMessageReceiver. This allows access to incoming messages.

```rust
fn rx(&self) -> &Receiver<T>
```

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

### Get the length of a slice

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

The `len` method returns the number of elements in a slice. This is a fundamental operation for understanding the size of the data.

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

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

### try_shrink_to_fit (Experimental)

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Tries to shrink the capacity of the vector as much as possible. This is a nightly-only experimental API. Returns an error if the allocator fails to shrink the allocation, but the vector remains safe to use.

```APIDOC
## POST /vec/try_shrink_to_fit

### Description
🔬 This is a nightly-only experimental API. (`vec_fallible_shrink`)
Tries to shrink the capacity of the vector as much as possible. The behavior of this method depends on the allocator, which may either shrink the vector in-place or reallocate. The resulting vector might still have some excess capacity.

### Method
POST

### Endpoint
/vec/try_shrink_to_fit

### Parameters
(No parameters specified for this operation)

### Request Body
(No request body specified for this operation)

### Response
#### Success Response (200)
- **None** - Indicates successful attempt to shrink capacity.

#### Error Response (e.g., 500)
- **TryReserveError** - Returned if the allocator fails to shrink the allocation.

### Request Example
```rust
#![feature(vec_fallible_shrink)]

let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);
// Assume this is an API call to try_shrink_to_fit
// api_client.post("/vec/try_shrink_to_fit").expect("Allocator failed to shrink");
assert!(vec.capacity() >= 3);
```

### Response Example
(Success: Empty body or confirmation message. Error: Details of TryReserveError)
```

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

### Get Sender from BevyMessageSender

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyMessageSender.html

Retrieves an immutable reference to the underlying `Sender` channel within the BevyMessageSender. This is part of the HasSender trait.

```rust
fn tx(&self) -> &Sender<T)>
```

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

### Initialize Vec Elements via Raw Pointer

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Demonstrates initializing vector elements using raw pointer writes after allocating capacity. Requires `unsafe` block. Ensure the vector outlives the pointer.

```rust
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        *x_ptr.add(i) = i as i32;
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### rchunks_mut

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns a mutable iterator over chunks of a specified size, starting from the end of the slice. The last chunk may be smaller.

```APIDOC
## pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are mutable slices, and do not overlap.

### Method
`rchunks_mut`

### Endpoint
N/A (Method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
- **chunk_size** (usize) - Required - The desired size of each chunk.

#### Request Body
None

### Request Example
```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

### Response
#### Success Response (200)
A mutable iterator yielding mutable slices of length `chunk_size` (or less for the last chunk).

#### Response Example
```rust
// Iterator yielding &mut [T]
```

##### §Panics
Panics if `chunk_size` is zero.
```

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

### TryFrom and TryInto Conversion

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/prelude/struct.BevyCanvasProps.html

Implementations for attempting conversions between types that may fail.

```APIDOC
## TryFrom<U> for T

### Description
Attempts to perform a conversion from type `U` to type `T`.

### Method
`try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

#### Response Example
N/A
```

```APIDOC
## TryInto<U> for T

### Description
Attempts to perform a conversion from type `T` to type `U`.

### Method
`try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

#### Response Example
N/A
```

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

### Iterate Over Slice Mutably

Source: https://docs.rs/leptos-bevy-canvas/latest/leptos_bevy_canvas/systems/struct.ImportedMessageIds.html

Returns an iterator that allows modifying each value in the slice. The iterator yields all items from start to end.

```APIDOC
## GET /slice/iter_mut

### Description
Returns an iterator that allows modifying each value. The iterator yields all items from start to end.

### Method
GET

### Endpoint
/slice/iter_mut

### Query Parameters
- **slice** (array) - Required - The mutable slice to iterate over.

### Response
#### Success Response (200)
- **iterator** (object) - A mutable iterator object that can be used to modify elements.

### Response Example
```json
{
  "iterator": "<mutable_iterator_representation>"
}
```

*Note: The actual representation of the mutable iterator in a JSON response would depend on the specific implementation. This example uses a placeholder.*
```
Tokens:
Raw