Struct ApplyContext 

pub struct ApplyContext<F>(/* private fields */);

A Future wrapper that preserves context across async executor boundaries.

Many async executors don’t preserve thread-local state between poll calls, which can cause context loss in async code. ApplyContext solves this by saving and restoring the context around each poll.

Use Cases

• Working with executors that use thread pools
• Spawning tasks that need to maintain parent context
• Ensuring consistent logging context in async code

Examples

logwise::declare_logging_domain!();
use logwise::context::{Context, ApplyContext};

async fn process_data() {
    logwise::info_sync!("Processing data");
}

// Create a context for this operation
let ctx = Context::new_task(None, "data_processor".to_string(), logwise::Level::Info, true);

// Wrap the future to preserve context
let future = ApplyContext::new(ctx, process_data());

// The context will be active during all poll calls
future.await;

Implementation Details

ApplyContext implements Future by:

1. Saving the current thread-local context
2. Setting its wrapped context as current
3. Polling the inner future
4. Restoring the original context

This ensures the wrapped future always sees the correct context, regardless of which thread or executor polls it.

Implementations

impl<F> ApplyContext<F>

pub fn new(context: Context, f: F) -> Self

Creates a new ApplyContext wrapper.

Arguments

• context - The context to apply during polling
• f - The future to wrap

Examples

logwise::declare_logging_domain!();
use logwise::context::{Context, ApplyContext};
use std::future::Future;

async fn my_task() -> i32 {
    logwise::info_sync!("Running task");
    42
}

let ctx = Context::new_task(None, "wrapped_task".to_string(), logwise::Level::Info, true);
let wrapped = ApplyContext::new(ctx, my_task());
let result = wrapped.await;
assert_eq!(result, 42);

Trait Implementations

impl<F> Future for ApplyContext<F>

where F: Future,

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.