Struct pr47::util::serializer::CoroutineContext

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

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.

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

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