Struct CoroutineContext 

pub struct CoroutineContext<SerializedData: 'static + Send> {
    pub serializer: Serializer<(CoroutineSharedData, SerializedData)>,
    pub task_id: u32,
    /* private fields */
}

Context of one coroutine/task

Fields

serializer: Serializer<(CoroutineSharedData, SerializedData)>

Data shared by all tasks in the same serialization group.

task_id: u32

Task ID of the current task. 0 implies main task, while other values are used for children tasks.

Implementations

impl<SD: 'static + Send> CoroutineContext<SD>

pub async fn main_context(shared_data: SD) -> Self

Creates a new, main coroutine context with given shared_data

pub fn child_context( serializer: Serializer<(CoroutineSharedData, SD)>, permit: SerializerLock<'static, (CoroutineSharedData, SD)>, task_id: u32, ) -> Self

pub fn get_shared_data_mut(&mut self) -> &mut SD

Given the fact that the permit is held, and there’s not another mutable reference to the shared data, retrieve the shared data.

pub async fn co_yield(&self)

Interrupt current task, allowing other task to run.

pub async fn co_await<FUT, RET>(&self, fut: FUT) -> RET

where FUT: Future<Output = RET>, RET: Send + Sync,

Interrupt current task, await for given fut. During this time other tasks may run.

pub async fn co_spawn_task<FN, ARGS, FUT, RET>( &self, f: FN, args: ARGS, ) -> JoinHandle<RET>

where FN: FnOnce(CoroutineContext<SD>, ARGS) -> FUT + Send + 'static, ARGS: Send + 'static, FUT: Future<Output = RET> + Send, RET: Send + 'static,

Spawn a new task managed by the current serialization group

pub async fn finish(&self)

Called on main task exit, wait for all other tasks to finish.

Trait Implementations

impl<SD: 'static + Send> Drop for CoroutineContext<SD>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<SD: 'static + Send> Send for CoroutineContext<SD>

impl<SD: 'static + Send> Sync for CoroutineContext<SD>