format: Added `io_uring::create_write_compressed()`: Spawns a background thread that compresses the written data to a file using the `io_uring` subsystem. Compression & IO operations are performed asynchonously.
//TODO: Add `tokio_uring` version of `save_chain_to_file()`/`load_chain_from_file()` that spawns the `tokio_uring` runtime internally to queue reads/writes from/to a file.
#[cfg(feature="io_uring")]
modio_uring{
usesuper::*;
usestd::{
path::Path,
};
usefutures::{
prelude::*,
io::{
//AsyncRead,
//AsyncBufRead,
//AsyncWrite,
AllowStdIo,
},
};
usetokio::{
io::{
AsyncRead,
AsyncBufRead,
AsyncWrite,
ReadHalf,WriteHalf,
SimplexStream,
simplex,
AsyncReadExt,
AsyncWriteExt,
},
};
usetokio_uring::{
fs,
buf,
};
useasync_compression::{
Level,
zstd::CParameter,
tokio::{
bufread::{
ZstdDecoder,
ZstdEncoder,
},
writeaszstd_write,
},
};
// Add `tokio_uring` version of `save_chain_to_file()`/`load_chain_from_file()` that spawns the `tokio_uring` runtime internally to queue reads/writes from/to a file. (Maybe default-feature-gate this?)
/// Creates an future that, when executed, reads all data from `reader` via `io_uring`, into generic byte sink `writer`.
///
/// # Task dispatch
/// This function *creates* the async function, it should be executed via `spawn()` *inside* a `tokio_uring` context.
///
/// # Returns
/// The future polls to return an `io::Result<usize>` of the number of bytes read from `reader` and written to `writer`.
/// Create a pipe *writer* that compresses the bytes written into `output_file` on a backing task.
///
/// Must be called within a `tokio_uring` context.
///
/// # Returns
/// A tuple of:
/// - Backing task join-handle. It will complete when all bytes have been copied and the returned write stream has been closed.
/// - Write end of async pipe. When all data has been written, it should be closed and then the handle should be awaited to ensure the data is flushed.
/// Write `data` to file `output` using `io_uring` (overwriting if `force` is `true`.)
///
/// # Synchonicity
/// This runs on a background thread, the encoding of the object bytes into the stream can be done on the current thread, the compression and writing to the file is done on a backing thread.
///
/// # Returns
/// A synchonous writer to write the data to, and a `JoinHandle` to the backing thread that completes to the number of bytes written to the file.
