Struct StreamConverters 

pub struct StreamConverters;

Bridges between std::io::Read/Write and Datum byte streams. Mirrors Akka’s StreamConverters.

from_reader/to_writer adapt blocking readers/writers into a Source/Sink; as_input_stream/as_output_stream go the other way, materializing a blocking InputStreamHandle/OutputStreamHandle over a stream. All factory closures run at materialization, never at blueprint construction.

Implementations

impl StreamConverters

pub fn from_reader<F, R>(factory: F, chunk_size: usize) -> Source<Vec<u8>>

where F: Fn() -> Result<R> + Send + Sync + 'static, R: Read + Send + 'static,

Wraps any blocking std::io::Read as a Source<Vec<u8>> emitting up to chunk_size bytes per element.

factory is invoked at materialization and the reader is driven on the Datum thread pool, with a small bounded reader queue so a slow consumer backpressures the reader instead of buffering unboundedly. Read errors fail the stream. Panics if chunk_size == 0.

pub fn to_writer<F, W>(factory: F) -> Sink<Vec<u8>, StreamCompletion<NotUsed>>

where F: Fn() -> Result<W> + Send + Sync + 'static, W: Write + Send + 'static,

Wraps any blocking std::io::Write as a Sink<Vec<u8>>, writing each upstream chunk in order.

factory runs at materialization. The writer is flushed exactly once — on completion or on error — and dropped afterwards; upstream errors are forwarded to the materialized StreamCompletion.

pub fn as_input_stream( read_timeout: Duration, ) -> Sink<Vec<u8>, InputStreamHandle>

Creates a Sink which when materialized returns an InputStreamHandle that can be used to read the values produced by the stream this sink is attached to.

This sink bridges Datum streams to synchronous blocking code. The materialized handle implements std::io::Read: each read() call blocks the caller (up to read_timeout) until upstream produces a chunk, then copies as many bytes as possible into the provided buffer. Partial reads are supported — the handle retains any leftover bytes from a previous chunk and serves them on the next call.

EOF is signalled by read() returning Ok(0) when the stream completes. Stream errors surface as io::Error. Dropping the handle cancels the stream.

Matches Akka StreamConverters.asInputStream semantics.

pub fn as_output_stream( write_timeout: Duration, ) -> Source<Vec<u8>, OutputStreamHandle>

Creates a Source which when materialized returns an OutputStreamHandle that can be used to write bytes into the stream.

This source is intended for inter-operation with blocking APIs. The materialized handle implements std::io::Write: each write() call blocks (up to write_timeout) until the stream has capacity, then produces one stream element from the written bytes. Backpressure is respected — writes block when the internal buffer is full.

flush() is a no-op. OutputStreamHandle::close() completes the stream (signals EOF to downstream). Dropping the handle cancels the stream.

Matches Akka StreamConverters.asOutputStream semantics.