Struct LocalScopedSink 

pub struct LocalScopedSink<'env, T, E> { /* private fields */ }

Local sink with a scoped future.

Unlike ScopedSink it is not Send, so it can work in no-std environment.

Implementations

impl<'env, T: 'env, E: 'env> LocalScopedSink<'env, T, E>

pub fn new_dyn(f: DynLocalSinkFn<'env, T, E>) -> Self

Create new LocalScopedSink from a DynLocalSinkFn.

You should probably use new instead.

Examples

let mut sink: LocalScopedSink<usize, Error> = LocalScopedSink::new_dyn(Box::new(|_| {
    Box::pin(async { Ok(()) })
}));

pub fn new<F>(f: F) -> Self

where for<'scope> F: 'env + FnMut(Pin<&'scope mut LocalSinkInner<'scope, 'env, T>>) -> DynLocalSinkFuture<'scope, E>,

Create new LocalScopedSink.

Future should be consuming all items of the stream. If not, the function will be called again to restart itself. It is guaranteed if the sink is closed, the future will never restarts.

Examples

let mut sink = <LocalScopedSink<_, Error>>::new(|mut stream| Box::pin(async move {
    // Reads a value. If future returns before sink is closed, it will be restarted.
    if let Some(v) = stream.next().await {
        println!("Value: {v}");
    }
    Ok(())
}));

// Send a value
sink.send(1).await?;

// Close the sink
sink.close().await?;

Trait Implementations

impl<'env, T: 'env, E: 'env> Sink<T> for LocalScopedSink<'env, T, E>

type Error = E

The type of value produced by the sink when an error occurs.

fn poll_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), E>>

Attempts to prepare the Sink to receive a value.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), E>>

Flush any remaining output from this sink.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), E>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), E>>

Flush any remaining output and close this sink, if necessary.

impl<'__pin, 'env, T, E> Unpin for LocalScopedSink<'env, T, E>

where PinnedFieldsOf<__Origin<'__pin, 'env, T, E>>: Unpin,