Embassy Executor

https://docs.embassy.dev/embassy-executor/git/cortex-m/
Admin
Embassy Executor is an async/await executor designed for embedded usage with no heap allocation,...
Tokens:39,676
Snippets:504
Trust Score:8.2
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start the InterruptExecutor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

Starts the InterruptExecutor, initializes it, and enables the associated interrupt. It returns a SendSpawner for spawning tasks. The interrupt handler must be manually implemented to call `on_interrupt()`. The interrupt priority must be set before calling this method.

```rust
pub fn start(&'static self, irq: impl InterruptNumber) -> SendSpawner
```

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

### SpawnToken Usage Example

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SpawnToken.html

Illustrates how to use SpawnToken. After obtaining a SpawnToken by calling a task function, it must be spawned into an executor using Spawner::spawn().

```rust
async fn my_task() { ... }

let token = my_task(); // Obtain a SpawnToken
// spawner.spawn(token); // Spawn the task into an executor
```

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

### Executor::run

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html?search=

Starts the executor and runs tasks. It takes an initialization closure that receives a Spawner to set up initial tasks. This function never returns.

```APIDOC
## Executor::run

### Description
Runs the executor, executing tasks spawned by the `init` closure. This function takes mutable static ownership of the executor and never returns.

### Method
`run(&'static mut self, init: impl FnOnce(Spawner)) -> !`

### Parameters
#### Path Parameters
- `self` (`&'static mut self`): A mutable static reference to the Executor instance.
- `init` (`impl FnOnce(Spawner)`): A closure that takes a `Spawner` and is used to spawn the initial tasks. This closure is called once.

### Returns
This function never returns (!).
```

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

### Executor::run() - Run Executor with Initialization

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html

Starts the executor and runs tasks. It takes an initialization closure that receives a Spawner to set up initial tasks. This function never returns.

```rust
pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> !
```

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

### InterruptExecutor::start

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html

Starts the InterruptExecutor, initializing it and enabling the associated interrupt. Tasks can be spawned on this executor using the returned SendSpawner.

```APIDOC
## `InterruptExecutor::start()`

### Description
Starts the executor, enabling the interrupt and returning a `SendSpawner` for spawning tasks.

### Method
`start(&'static self, irq: impl InterruptNumber)`

### Parameters
#### Path Parameters
- **irq** (impl InterruptNumber) - Required - The interrupt number to associate with this executor.

### Requirements
- You must write the interrupt handler yourself and call `on_interrupt()` from it.
- This method enables the interrupt; do not enable it yourself.
- Set the interrupt priority *before* calling this method.

### Returns
A `SendSpawner` that can be used to spawn tasks on this executor.
```

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

### InterruptExecutor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

Creates a new instance of InterruptExecutor that has not yet been started. This allows for initialization before starting the interrupt handling.

```APIDOC
## `InterruptExecutor::new()`

### Description
Creates a new, not started `InterruptExecutor`.

### Returns
A new `InterruptExecutor` instance.

### Example
```rust
let executor = InterruptExecutor::new();
```
```

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

### InterruptExecutor::start

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

Starts the InterruptExecutor, initializing it, enabling the specified interrupt, and returning a SendSpawner for task management. The interrupt handler must be manually implemented to call `on_interrupt`.

```APIDOC
## `InterruptExecutor::start()`

### Description
Starts the executor, enabling the interrupt and returning a `SendSpawner`. The executor runs in the background via the interrupt. You must implement the interrupt handler to call `on_interrupt()`.

### Parameters
* `irq`: An implementation of `InterruptNumber` specifying the interrupt to use.

### Requirements
* The interrupt priority must be set before calling this method.
* You must write the interrupt handler yourself and ensure it calls `on_interrupt()`.
* This method enables (unmasks) the interrupt; do not do it yourself.

### Returns
A `SendSpawner` that can be used to spawn tasks on this executor.

### Example
```rust
// Assuming 'MyInterrupt' is an implementation of InterruptNumber
let spawner = executor.start(MyInterrupt);
```
```

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

### Get Task Deadline

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=

Retrieves the deadline for the task, represented as a `u64` tick count.

```rust
pub fn deadline(&self) -> u64
```

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

### Getting a Spawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html?search=

Retrieves a `Spawner` instance for this executor, which can be used to spawn new tasks. Multiple `Spawner` instances can be obtained and copied.

```rust
pub fn spawner(&'static self) -> Spawner
```

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

### task_from_waker

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/fn.task_from_waker.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get a task pointer from a waker. This can be used as an optimization in wait queues to store task pointers (1 word) instead of full Wakers (2 words). This saves a bit of RAM and helps avoid dynamic dispatch. You can use the returned task pointer to wake the task with `wake_task`.

```APIDOC
## Function task_from_waker

### Description
Get a task pointer from a waker. This can be used as an optimization in wait queues to store task pointers (1 word) instead of full Wakers (2 words). This saves a bit of RAM and helps avoid dynamic dispatch. You can use the returned task pointer to wake the task with `wake_task`.

### Panics
Panics if the waker is not created by the Embassy executor.

### Signature
`pub fn task_from_waker(waker: &Waker) -> TaskRef`
```

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

### Get Spawner for Current Executor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Spawner.html

Obtains a Spawner for the current Embassy executor. This method is async to access the current async context and returns instantly. It is unsafe and discouraged, with alternatives like passing the initial Spawner as an argument or using SendSpawner.

```rust
pub unsafe fn for_current_executor() -> impl Future<Output = Self>
```

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

### Get SendSpawner for InterruptExecutor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

Retrieves a SendSpawner for the InterruptExecutor. This can be used to spawn tasks onto the executor. This function will panic if called on an executor that has not yet been started.

```rust
pub fn spawner(&'static self) -> SendSpawner
```

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

### Executor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html

Creates a new instance of the Executor. This is the entry point for setting up the executor.

```APIDOC
## Executor::new

### Description
Creates a new Executor instance.

### Method
`new()`

### Returns
- `Self`: A new instance of the Executor.
```

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

### InterruptExecutor::spawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

Retrieves a SendSpawner for an already started InterruptExecutor. Panics if called before the executor has been started.

```APIDOC
## `InterruptExecutor::spawner()`

### Description
Gets a `SendSpawner` for this executor. This MUST only be called on an executor that has already been started.

### Preconditions
* The executor must have been started using `start()`.

### Returns
A `SendSpawner` that can be used to spawn tasks on this executor.

### Panics
* Panics if called on an executor that has not yet been started.

### Example
```rust
let spawner = interrupt_executor.spawner();
```
```

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

### Executor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html?search=

Creates a new instance of the Executor. This is the entry point for setting up the executor.

```APIDOC
## Executor::new

### Description
Creates a new Executor instance.

### Method
`new()`

### Returns
- `Self`: A new Executor instance.
```

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

### Executor::new() - Create Executor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html

Instantiates a new Executor. This is the entry point for setting up the executor.

```rust
pub fn new() -> Self
```

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

### SendSpawner::for_current_executor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html?search=std%3A%3Avec

Get a Spawner for the current executor. This function is `async` just to get access to the current async context. It returns instantly, it does not block/yield. Panics if the current executor is not an Embassy executor.

```APIDOC
## impl SendSpawner

### pub fn for_current_executor() -> impl Future<Output = Self>

Get a Spawner for the current executor.
This function is `async` just to get access to the current async context. It returns instantly, it does not block/yield.

##### Panics

Panics if the current executor is not an Embassy executor.
```

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

### Metadata::deadline

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=

Gets the deadline for the task associated with this metadata.

```APIDOC
## Metadata::deadline

### Description
Get this task’s deadline.

### Method
`fn`

### Endpoint
N/A (SDK method)

### Returns
- `u64` - The deadline of the task in ticks.
```

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

### TaskStorage::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskStorage.html

Creates a new TaskStorage instance, initialized in a not-spawned state.

```APIDOC
## TaskStorage::new

### Description
Creates a new TaskStorage, in not-spawned state.

### Method
`new()`

### Parameters
None

### Response
- Returns a new `TaskStorage` instance.
```

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

### Metadata::priority

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=

Gets the priority of the task associated with this metadata.

```APIDOC
## Metadata::priority

### Description
Get this task’s priority.

### Method
`fn`

### Endpoint
N/A (SDK method)

### Returns
- `u8` - The priority of the task.
```

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

### TaskPool::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskPool.html

Creates a new TaskPool. All tasks within the pool are initialized in a non-spawned state.

```APIDOC
## TaskPool::new

### Description
Creates a new TaskPool, with all tasks in non-spawned state.

### Method

```rust
pub const fn new() -> Self
```
```

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

### Get Task Priority

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=

Returns the priority of the task associated with this metadata.

```rust
pub fn priority(&self) -> u8
```

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

### AvailableTask::initialize

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html

Initializes the TaskStorage with a given future, preparing it to be spawned.

```APIDOC
## AvailableTask::initialize

### Description
Initialize the `TaskStorage` to run the given future.

### Method
`pub fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>`

### Parameters
* `self` (AvailableTask<F>): The AvailableTask instance.
* `future` (impl FnOnce() -> F): A closure that returns the future to be run.
```

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

### Getting Executor ID

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html?search=

Returns a unique identifier for this `Executor` instance.

```rust
pub fn id(&'static self) -> usize
```

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

### Implementing a Custom Executor Wrapper

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/index.html?search=

Wrap the `raw::Executor` in a custom `Executor` struct to define the main loop for a custom platform. The `run` method initializes tasks and enters an infinite loop that polls the executor and waits for notifications.

```rust
pub struct Executor {
    inner: raw::Executor,
    not_send: PhantomData<*mut ()>,
}

impl Executor {
    pub fn new() -> Self {
        Self {
            inner: raw::Executor::new(my_rtos::task_get_current() as _),
            not_send: PhantomData,
        }
    }

    pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
        init(self.inner.spawner());

        loop {
            unsafe { self.inner.poll() }
            my_rtos::task_wait_for_notification();
        }
    }
}
```

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

### Get Executor ID

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Spawner.html

Returns the unique ID of the Executor associated with this Spawner.

```rust
pub fn executor_id(&self) -> usize
```

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

### AvailableTask::initialize

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=

Initializes the TaskStorage to run the given future. This consumes the AvailableTask.

```APIDOC
## AvailableTask::initialize

### Description
Initialize the `TaskStorage` to run the given future.
This function consumes the `AvailableTask` and returns a `SpawnToken` for the spawned future.

### Method
`pub fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>`

### Parameters
#### Path Parameters
- `self` (AvailableTask<F>) - Required - The available task to initialize.
- `future` (impl FnOnce() -> F) - Required - A closure that returns the future to be spawned.

### Response
#### Success Response (SpawnToken<F>)
- Returns a `SpawnToken` that can be used to manage the spawned future.

### Example
```rust
let task_storage = TaskStorage::<MyFuture>::new();
if let Some(available_task) = AvailableTask::claim(&task_storage) {
    let spawn_token = available_task.initialize(|| async { /* your future logic */ });
    // Use spawn_token to manage the spawned task
}
```
```

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

### InterruptExecutor::spawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html

Retrieves a SendSpawner for an already started InterruptExecutor, allowing tasks to be spawned on it.

```APIDOC
## `InterruptExecutor::spawner()`

### Description
Get a `SendSpawner` for this executor. This MUST only be called on an executor that has already been started.

### Method
`spawner(&'static self) -> SendSpawner`

### Panics
This function will panic if called on an executor that has not yet been started.

### Returns
A `SendSpawner` for the executor.
```

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

### AvailableTask::initialize

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the TaskStorage to run a given future. Returns a SpawnToken for the spawned task.

```APIDOC
## AvailableTask::initialize

### Description
Initialize the `TaskStorage` to run the given future. This method returns a `SpawnToken<F>` which can be used to manage the spawned task.

### Method
`pub fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>`

### Parameters
* `self` - The `AvailableTask` instance.
* `future` - A closure that returns the future `F` to be spawned.
```

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

### InterruptExecutor::on_interrupt

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

The interrupt callback function for the InterruptExecutor. This MUST be called exclusively from the interrupt handler after the executor has been started.

```APIDOC
## `InterruptExecutor::on_interrupt()`

### Description
Executor interrupt callback. This function should be called from the interrupt handler.

### Safety
* You MUST call this from the interrupt handler, and from nowhere else.
* You must not call this before calling `start()`.

### Example
```rust
// In your interrupt handler:
#[interrupt]
fn MY_INTERRUPT_HANDLER() {
    // ... interrupt logic ...
    interrupt_executor.on_interrupt();
    // ... more interrupt logic ...
}
```
```

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

### Executor Initialization

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html?search=

Creates a new raw executor. The provided `context` will be passed to the pender function when the executor needs to be polled.

```rust
pub fn new(context: *mut ()) -> Self
```

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

### Executor::run

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Executor.html

Runs the executor, taking an initialization closure that spawns the initial tasks. This function never returns.

```APIDOC
## Executor::run

### Description
Runs the executor with a given initialization closure. The closure receives a `Spawner` to spawn initial tasks. After the closure returns, the executor begins executing tasks. This function is designed to run indefinitely.

### Method
`run(&'static mut self, init: impl FnOnce(Spawner)) -> !`

### Parameters
#### Path Parameters
- `self` (`&'static mut self`): A mutable static reference to the Executor instance.
- `init` (`impl FnOnce(Spawner)`): A closure that takes a `Spawner` and is responsible for spawning the initial tasks.

### Returns
This function never returns.
```

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

### Get Task ID

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html

Returns the unique identifier for the task. This ID can be used with rtos-trace for task name matching.

```rust
pub fn id(&self) -> u32
```

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

### TaskPool::spawn() Method

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskPool.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to spawn a new task into the TaskPool. It iterates through the pool to find the first available storage slot. If no slots are free, it returns SpawnError::Busy.

```rust
pub fn spawn( &'static self, future: impl FnOnce() -> F, ) -> Result<SpawnToken<impl Sized>, SpawnError>
```

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

### Get Executor Reference

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html

Retrieves a reference to the Executor that the task is running on. This method is unsafe and requires careful usage.

```rust
pub unsafe fn executor(self) -> Option<&'static Executor>
```

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

### TaskRef Implementations

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html?search=

Details on the implementations and traits for TaskRef, including Clone, Debug, PartialEq, Send, and Sync.

```APIDOC
### `impl Clone for TaskRef`

#### `clone(&self) -> TaskRef`
Returns a duplicate of the value.

#### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl Debug for TaskRef`

#### `fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `impl PartialEq for TaskRef`

#### `eq(&self, other: &TaskRef) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.

#### `ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

### `impl Copy for TaskRef`

### `impl Send for TaskRef`
where &'static TaskHeader: Send

### `impl StructuralPartialEq for TaskRef`

### `impl Sync for TaskRef`
where &'static TaskHeader: Sync
```

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

### Initialize AvailableTask with a Future

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=

Initializes the TaskStorage with a given future and returns a SpawnToken. This prepares the task to be spawned.

```rust
pub fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>
```

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

### InterruptExecutor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html

Creates a new instance of InterruptExecutor that has not yet been started. This executor is designed to run tasks in interrupt mode.

```APIDOC
## `InterruptExecutor::new()`

### Description
Creates a new, not started `InterruptExecutor`.

### Method
`new()`

### Returns
A new `InterruptExecutor` instance.
```

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

### Get Current Task Metadata

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=

Retrieves the metadata for the currently executing task. This is an async function that returns instantly and does not block.

```rust
pub fn for_current_task() -> impl Future<Output = &'static Self>
```

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

### InterruptExecutor interrupt callback

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=

The unsafe interrupt callback function for the InterruptExecutor. This MUST be called exclusively from the interrupt handler after the executor has been started.

```rust
pub unsafe fn on_interrupt(&'static self)
```

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

### SpawnToken Metadata Method

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SpawnToken.html

Provides access to the metadata of the SpawnToken. Metadata fields can be set before spawning the task.

```rust
pub fn metadata(&self) -> &Metadata
```

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

### TaskPool::new() Constructor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskPool.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new TaskPool instance. All tasks within the pool are initialized in a non-spawned state.

```rust
pub const fn new() -> Self
```

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

### TaskRef Methods

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html?search=u32+-%3E+bool

This section details the methods available on the TaskRef struct, allowing users to interact with task references.

```APIDOC
## pub unsafe fn executor(self) -> Option<&'static Executor>

### Description
Returns a reference to the executor that the task is currently running on.

### Method
`executor`

### Parameters
None

### Returns
An `Option` containing a static reference to the `Executor` if the task is running on one, otherwise `None`.

## pub unsafe fn timer_queue_item(self) -> &'static mut TimerQueueItem

### Description
Returns a mutable reference to the timer queue item associated with the task.

### Safety
This function must only be called in the context of the integrated timer queue.

### Method
`timer_queue_item`

### Parameters
None

### Returns
A mutable static reference to the `TimerQueueItem`.

## pub fn id(&self) -> u32

### Description
Returns the task ID. This can be used in combination with rtos-trace to match task names with IDs.

### Method
`id`

### Parameters
None

### Returns
The task ID as a `u32`.
```

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

### Get Timer Queue Item

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html

Returns a mutable reference to the TimerQueueItem associated with the task. This is unsafe and must only be called within the context of the integrated timer queue.

```rust
pub unsafe fn timer_queue_item(self) -> &'static mut TimerQueueItem
```

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

### Format Implementation for SpawnError (defmt)

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/enum.SpawnError.html

Shows the `format` method for the `Format` trait, specific to the `defmt` crate feature, for writing the defmt representation of SpawnError.

```rust
fn format(&self, f: Formatter<'_>)
Writes the defmt representation of `self` to `fmt`.
```

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

### TaskStorage Blanket Implementations - TryFrom

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskStorage.html?search=

Illustrates the `TryFrom` trait implementation for `TaskStorage`, providing a fallible conversion mechanism.

```rust
impl<T, U> TryFrom<U> for T
where U: Into<T>,
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

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

### Executor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html?search=u32+-%3E+bool

Creates a new raw Executor instance. The provided context will be passed to the pender function when the executor needs to signal that work is available. This is a low-level constructor, and users are generally encouraged to use higher-level executor abstractions if possible.

```APIDOC
## Executor::new

### Description
Creates a new raw executor.

When the executor has work to do, it will call the pender function and pass `context` to it.

### Parameters
* **context** (*mut ()) - A raw pointer to a context that will be passed to the pender function.

### Returns
* Self - A new instance of the Executor.
```

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

### Get Spawner for Current Executor

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html

Obtain a SendSpawner for the currently running Embassy executor. This function is async only to access the current async context and returns immediately. It will panic if not called within an Embassy executor context.

```rust
pub async fn for_current_executor() -> impl Future<Output = Self>
```

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

### Executor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new raw executor instance. The provided context will be passed to the pender function when the executor has work to do.

```APIDOC
## Executor::new

### Description
Creates a new executor. When the executor has work to do, it will call the pender function and pass `context` to it.

### Method
`Executor::new(context: *mut ()) -> Self`

### Parameters
* **context** (*mut ()) - A pointer to arbitrary data to be passed to the pender function.
```

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

### Executor::new

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html

Creates a new raw executor instance. It requires a pender function to be provided, which the executor will call when it has work to do. The `context` argument is passed to the pender.

```APIDOC
## Executor::new

### Description
Creates a new executor. When the executor has work to do, it will call the pender function and pass `context` to it.

### Method
`pub fn new(context: *mut ()) -> Self`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Returns a new `Executor` instance.

#### Response Example
None
```

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

### Get TaskRef from Waker

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/fn.task_from_waker.html

Retrieves a task pointer from a waker. This can be used to optimize wait queues by storing task pointers instead of full Wakers, saving RAM and avoiding dynamic dispatch. The returned task pointer can be used to wake the task with `wake_task`. Panics if the waker is not created by the Embassy executor.

```rust
pub fn task_from_waker(waker: &Waker) -> TaskRef
```

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

### TaskRef Methods

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html

This section details the methods available on the TaskRef struct, allowing users to interact with tasks managed by the embassy-executor.

```APIDOC
## TaskRef

### Description
Represents a reference to a task within the embassy-executor, essentially a `&'static TaskStorage<F>` with the future type erased.

### Methods

#### `executor(self) -> Option<&'static Executor>`

##### Description
Returns a reference to the executor that the task is currently running on.

##### Safety
This method is unsafe and requires careful usage.

#### `timer_queue_item(self) -> &'static mut TimerQueueItem`

##### Description
Returns a mutable reference to the timer queue item associated with the task.

##### Safety
This function must only be called in the context of the integrated timer queue.

#### `id(&self) -> u32`

##### Description
Returns the unique ID of the task. This ID can be used with `rtos-trace` to associate task names with their IDs.
```

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

### Implementing a Custom Pender Callback

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/index.html?search=

Define the `__pender` callback for a custom platform implementation. This function is responsible for notifying the executor's thread/core to wake up and poll tasks. The `context` parameter can be used to pass RTOS task handles or other relevant data.

```rust
#[unsafe(export_name = "__pender")]
fn __pender(context: *mut ()) {
    // `context` is the argument passed to `raw::Executor::new`. Here we're using it
    // to pass a handle to the RTOS task but you can use it for anything.
    my_rtos::notify_task(context as _);
}
```

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

### AvailableTask

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=u32+-%3E+bool

Provides methods to interact with TaskStorage for task management.

```APIDOC
## AvailableTask<F: Future + 'static>

### Description
An uninitialized `TaskStorage`.

### Methods

#### `fn claim(task: &'static TaskStorage<F>) -> Option<Self>`

##### Description
Try to claim a `TaskStorage`. This function returns `None` if a task has already been spawned and has not finished running.

#### `fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>`

##### Description
Initialize the `TaskStorage` to run the given future.
```

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

### SpawnToken

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SpawnToken.html

Represents a task instance ready to be spawned into an executor. It ensures that tasks are always spawned and cannot be aborted by dropping the token.

```APIDOC
## Struct SpawnToken

### Description
Token to spawn a newly-created task in an executor. When calling a task function (like `#[embassy_executor::task] async fn my_task() { ... }`), the returned value is a `SpawnToken` that represents an instance of the task, ready to spawn. You must then spawn it into an executor, typically with `Spawner::spawn()`.

The generic parameter `S` determines whether the task can be spawned in executors in other threads or not. If `S: Send`, it can, which allows spawning it into a `SendSpawner`. If not, it can’t, so it can only be spawned into the current thread’s executor, with `Spawner`.

### Panics
Dropping a SpawnToken instance panics. You may not “abort” spawning a task in this way. Once you’ve invoked a task function and obtained a SpawnToken, you _must_ spawn it.

### Methods
#### `id(&self) -> u32`
Returns the task ID. This can be used in combination with rtos-trace to match task names with IDs.

#### `metadata(&self) -> &Metadata`
Get the metadata for this task. You can use this to set metadata fields prior to spawning it.
```

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

### TaskStorage Blanket Implementations - Any

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskStorage.html?search=

Demonstrates the implementation of the `Any` trait for `TaskStorage`, allowing for runtime type identification.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
fn type_id(&self) -> TypeId
```

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

### Embassy Executor Main Attribute Usage

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/attr.main.html?search=std%3A%3Avec

Use this attribute to define the entry point for your Cortex-M application. The function must be async, accept a Spawner, and not use generics. Only one `main` task can be declared.

```rust
#[embassy_executor::main]
async fn main(_s: embassy_executor::Spawner) {
    // Function body
}
```

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

### TaskPool::spawn

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskPool.html

Attempts to spawn a new task into the TaskPool. It searches for the first available storage slot and spawns the provided future. If no slots are free, it returns a `SpawnError::Busy`.

```APIDOC
## TaskPool::spawn

### Description
Try to spawn a task in the pool. See `TaskStorage::spawn()` for details. This will loop over the pool and spawn the task in the first storage that is currently free. If none is free, `SpawnError::Busy` is returned.

### Method

```rust
pub fn spawn( &'static self, future: impl FnOnce() -> F, ) -> Result<SpawnToken<impl Sized>, SpawnError>
```

### Parameters

#### Path Parameters
- **self** (`&'static self`) - Required - The TaskPool instance.
- **future** (`impl FnOnce() -> F`) - Required - A closure that returns the future to be spawned.

### Response

#### Success Response
- **SpawnToken** (`Result<SpawnToken<impl Sized>, SpawnError>`) - A token representing the spawned task if successful.

#### Error Response
- **SpawnError::Busy** (`Result<SpawnToken<impl Sized>, SpawnError>`) - Returned if the TaskPool is full and no slots are available.
```

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

### SpawnToken

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SpawnToken.html?search=

Represents a token for spawning a newly-created task in an executor. It allows for managing task instances before they are spawned.

```APIDOC
## Struct SpawnToken

Embassy Executor

### Description
Token to spawn a newly-created task in an executor. When calling a task function (like `#[embassy_executor::task] async fn my_task() { ... }`), the returned value is a `SpawnToken` that represents an instance of the task, ready to spawn. You must then spawn it into an executor, typically with `Spawner::spawn()`.

The generic parameter `S` determines whether the task can be spawned in executors in other threads or not. If `S: Send`, it can, which allows spawning it into a `SendSpawner`. If not, it can’t, so it can only be spawned into the current thread’s executor, with `Spawner`.

### Panics
Dropping a SpawnToken instance panics. You may not “abort” spawning a task in this way. Once you’ve invoked a task function and obtained a SpawnToken, you _must_ spawn it.

### Methods

#### `id(&self) -> u32`
Returns the task ID. This can be used in combination with rtos-trace to match task names with IDs.

#### `metadata(&self) -> &Metadata`
Get the metadata for this task. You can use this to set metadata fields prior to spawning it.

### Trait Implementations

#### `Drop`
Executes the destructor for this type.

#### `Freeze`

#### `!RefUnwindSafe`

#### `!Send`

#### `!Sync`

#### `Unpin`

#### `!UnwindSafe`

#### `Any`

#### `Borrow<T>`

#### `BorrowMut<T>`

#### `From<T>`

#### `Into<U>`

#### `TryFrom<U>`

#### `TryInto<U>`
```

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

### Copy for SendSpawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html?search=std%3A%3Avec

Indicates that SendSpawner can be copied.

```APIDOC
### impl Copy for SendSpawner
```

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

### TryFrom

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html

Attempts to convert a value into another type, returning a Result.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error.

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

### Description
Performs the conversion.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### Metadata struct

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Metadata.html?search=u32+-%3E+bool

Provides methods to interact with task metadata, including priority and deadline management.

```APIDOC
## Metadata

Metadata associated with a task.

### `impl Metadata`

#### `pub fn for_current_task() -> impl Future<Output = &'static Self>`

Get the metadata for the current task. You can use this to read or modify the current task’s metadata. This function is `async` just to get access to the current async context. It returns instantly, it does not block/yield.

#### `pub fn priority(&self) -> u8`

Get this task’s priority.

#### `pub fn set_priority(&self, priority: u8)`

Set this task’s priority.

#### `pub fn deadline(&self) -> u64`

Get this task’s deadline.

#### `pub fn set_deadline(&self, instant_ticks: u64)`

Set this task’s deadline. This method does NOT check whether the deadline has already passed.

#### `pub fn unset_deadline(&self)`

Remove this task’s deadline. This brings it back to the defaul where it’s not scheduled ahead of other tasks.

#### `pub fn increment_deadline(&self, duration_ticks: u64)`

Set the this task’s deadline `increment_ticks` from the previous deadline. This deadline is saturated to the max tick value. Note that by default (unless otherwise set), tasks start life with the deadline not set, which means this method will have no effect. Analogous to one increment of `Ticker::every().next()`. Returns the deadline that was set.
```

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

### Into

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html

Converts a value into another type, leveraging the `From` trait.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### TaskStorage::spawn

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskStorage.html?search=std%3A%3Avec

Attempts to spawn a new task using the provided future. Fails if the storage is already busy.

```APIDOC
## TaskStorage::spawn

### Description
Try to spawn the task. The `future` closure constructs the future. It’s only called if spawning is actually possible. It is a closure instead of a simple `future: F` param to ensure the future is constructed in-place, avoiding a temporary copy in the stack thanks to NRVO optimizations.

This function will fail if the task is already spawned and has not finished running. In this case, `SpawnError::Busy` is returned.

Once the task has finished running, you may spawn it again. It is allowed to spawn it on a different executor.

### Method
`spawn(&'static self, future: impl FnOnce() -> F)`

### Parameters
*   `self`: A static reference to the `TaskStorage`.
*   `future`: A closure that constructs the future to be spawned.

### Returns
*   `Ok(SpawnToken<impl Sized>)`: If the task was successfully spawned.
*   `Err(SpawnError)`: If the `TaskStorage` is busy.
```

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

### impl<T, U> TryInto<U> for T

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `try_into` function attempts a conversion that may fail, returning a `Result`. It's the counterpart to `try_from`.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error for `TryInto`.

### Type
<U as TryFrom<T>>::Error
```

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

### Description
Performs a fallible conversion from type `T` to type `U`.

### Method
N/A (Method on `T`)

### Parameters
* **self** (T) - The value to attempt conversion from.

### Response
* **Result<U, Error>** - Ok(U) if the conversion is successful, Err(Error) otherwise.
```

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

### impl<T, U> TryFrom<U> for T

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.InterruptExecutor.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `try_from` function attempts a conversion that may fail, returning a `Result`. This is used for fallible conversions.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error for `TryFrom`.

### Type
Infallible
```

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

### Description
Performs a fallible conversion from type `U` to type `T`.

### Method
N/A (Associated function)

### Parameters
* **value** (U) - The value to attempt conversion from.

### Response
* **Result<T, Error>** - Ok(T) if the conversion is successful, Err(Error) otherwise.
```

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

### Generic Implementations for SpawnError

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/enum.SpawnError.html

Lists various auto-trait and blanket implementations for SpawnError, including `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `From`, `Into`, `TryFrom`, and `TryInto`.

```rust
fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

```rust
fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more
```

```rust
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
```

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
```

```rust
fn from(t: T) -> T
Returns the argument unchanged.
```

```rust
fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
```

```rust
type Error = Infallible
The type returned in the event of a conversion error.
```

```rust
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
```

```rust
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
```

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

### SendSpawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Handle to spawn tasks into an executor from any thread. This Spawner can be used from any thread (it is Send), but it can only spawn Send tasks. The reason for this is spawning is effectively “sending” the tasks to the executor thread. If you want to spawn non-Send tasks, use Spawner.

```APIDOC
## Struct SendSpawner

### Description
Handle to spawn tasks into an executor from any thread. This Spawner can be used from any thread (it is Send), but it can only spawn Send tasks. The reason for this is spawning is effectively “sending” the tasks to the executor thread. If you want to spawn non-Send tasks, use Spawner.

### Methods

#### `for_current_executor()`

##### Description
Get a Spawner for the current executor.
This function is `async` just to get access to the current async context. It returns instantly, it does not block/yield.

##### Panics
Panics if the current executor is not an Embassy executor.

#### `spawn<S: Send>(&self, token: SpawnToken<S>)`

##### Description
Spawn a task into an executor.
You obtain the `token` by calling a task function (i.e. one marked with `#[embassy_executor::task]`)

### Trait Implementations

#### `Clone`

##### `clone(&self) -> SendSpawner`
Returns a duplicate of the value.

##### `clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

#### `Copy`
```

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

### SendSpawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html?search=

Handle to spawn tasks into an executor from any thread. This Spawner can be used from any thread (it is Send), but it can only spawn Send tasks. The reason for this is spawning is effectively “sending” the tasks to the executor thread. If you want to spawn non-Send tasks, use Spawner.

```APIDOC
## struct SendSpawner

### Description
Handle to spawn tasks into an executor from any thread. This Spawner can be used from any thread (it is Send), but it can only spawn Send tasks. The reason for this is spawning is effectively “sending” the tasks to the executor thread. If you want to spawn non-Send tasks, use Spawner.

### Methods

#### `for_current_executor()`

- **Description**: Get a Spawner for the current executor.
- **Signature**: `pub fn for_current_executor() -> impl Future<Output = Self>`
- **Notes**: This function is `async` just to get access to the current async context. It returns instantly, it does not block/yield.
- **Panics**: Panics if the current executor is not an Embassy executor.

#### `spawn<S: Send>(&self, token: SpawnToken<S>)`

- **Description**: Spawn a task into an executor.
- **Signature**: `pub fn spawn<S: Send>(&self, token: SpawnToken<S>)`
- **Parameters**:
  - `token` (SpawnToken<S>): You obtain the `token` by calling a task function (i.e. one marked with `#[embassy_executor::task]`).

### Trait Implementations

#### `Clone`

- **Description**: Returns a duplicate of the value.
- **Signature**: `fn clone(&self) -> SendSpawner`

#### `Copy`

- **Description**: Indicates that the type can be copied by simply copying bits.

### Auto Trait Implementations

- `Freeze`
- `RefUnwindSafe`
- `Send`
- `Sync`
- `Unpin`
- `UnwindSafe`
```

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

### TaskPool Sync Implementation

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskPool.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The TaskPool is Sync, meaning it can be safely accessed from multiple threads concurrently.

```rust
impl<F, const N: usize> Sync for TaskPool<F, N>
```

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

### Clone Implementation for SpawnError

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/enum.SpawnError.html

Demonstrates the `clone` and `clone_from` methods for the SpawnError enum, allowing for duplication of the error value.

```rust
fn clone(&self) -> SpawnError
Returns a duplicate of the value. Read more
```

```rust
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`. Read more
```

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

### Spawn a Task

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Spawner.html

Spawns a task into the executor using a SpawnToken. The token is obtained by calling a task function marked with `#[embassy_executor::task]`.

```rust
pub fn spawn<S>(&self, token: SpawnToken<S>)
```

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

### TryFrom Trait Implementation for AvailableTask

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=u32+-%3E+bool

Shows the TryFrom trait implementation for AvailableTask, which attempts a conversion that may fail.

```rust
type Error = Infallible
```

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

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

### impl Clone for Spawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.Spawner.html

Provides functionality to create duplicate Spawner instances. Spawner implements both `Clone` and `Copy` traits.

```APIDOC
## impl Clone for Spawner

### clone

Returns a duplicate of the value.

### clone_from

Performs copy-assignment from `source`.
```

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

### TaskStorage::spawn

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskStorage.html

Attempts to spawn a task using the provided future-constructing closure. Fails if the storage is already busy.

```APIDOC
## TaskStorage::spawn

### Description
Try to spawn the task. The `future` closure constructs the future. It’s only called if spawning is actually possible. It is a closure instead of a simple `future: F` param to ensure the future is constructed in-place, avoiding a temporary copy in the stack thanks to NRVO optimizations.
This function will fail if the task is already spawned and has not finished running. In this case, `SpawnError::Busy` is returned. Once the task has finished running, you may spawn it again. It is allowed to spawn it on a different executor.

### Method
`spawn( &'static self, future: impl FnOnce() -> F ) -> Result<SpawnToken<impl Sized>, SpawnError>`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **future** (impl FnOnce() -> F) - Required - A closure that constructs the future to be spawned.

### Response
#### Success Response (200)
- Returns a `SpawnToken` on successful spawning.

#### Error Response
- `SpawnError::Busy`: If the task is already spawned and has not finished running.
```

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

### TryInto

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html

Attempts to convert a value into another type, leveraging the `TryFrom` trait, returning a Result.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

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

### Description
Performs the conversion.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### AvailableTask<F>

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=std%3A%3Avec

Represents an uninitialized TaskStorage that can be claimed and then initialized with a future. It allows for managing task lifecycles within the embassy-executor.

```APIDOC
## struct AvailableTask<F: Future + 'static>

### Description
An uninitialized `TaskStorage`.

## Methods

### `fn claim(task: &'static TaskStorage<F>) -> Option<Self>`

#### Description
Try to claim a `TaskStorage`.
This function returns `None` if a task has already been spawned and has not finished running.

### `fn initialize(self, future: impl FnOnce() -> F) -> SpawnToken<F>`

#### Description
Initialize the `TaskStorage` to run the given future.

```

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

### Claim AvailableTask Storage

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.AvailableTask.html?search=

Attempts to claim an uninitialized TaskStorage. Returns None if the task has already been spawned and has not yet finished.

```rust
pub fn claim(task: &'static TaskStorage<F>) -> Option<Self>
```

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

### Clone to Uninit TaskRef

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.TaskRef.html

Performs copy-assignment from TaskRef to an uninitialized memory location. This is an experimental nightly-only API.

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

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

### From

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/raw/struct.Executor.html

Converts a value into another type.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
N/A (Method signature provided)

### Endpoint
N/A
```

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

### Clone for SendSpawner

Source: https://docs.embassy.dev/embassy-executor/git/cortex-m/struct.SendSpawner.html?search=std%3A%3Avec

Provides methods for cloning SendSpawner instances.

```APIDOC
## impl Clone for SendSpawner

### fn clone(&self) -> SendSpawner

Returns a duplicate of the value. Read more

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

Performs copy-assignment from `source`. Read more
```
Tokens:
Raw