Struct diny_core::util::AsyncSliceWriter

pub struct AsyncSliceWriter<'b> { /* fields omitted */ }

Writes asynchronously to a slice of bytes, without attempting to allocate more memory if a write is attempted past the end of the slice.

Should a write be attempted past the end of the slice without any remaining space, an error of WriteZero will be returned.

Examples

use futures::{AsyncWriteExt, executor};
use diny_core::util::AsyncSliceWriter;
 
let     send = [7u8; 5];
let mut buff = [0u8; 7];
let mut writer = AsyncSliceWriter::from(&mut buff[..]);
executor::block_on(writer.write(&send));
assert_eq!(send, writer.as_written());

The written bytes can then be easily retrieved by using an AsyncSliceReader

use futures::AsyncReadExt;
use diny_core::util::AsyncSliceReader;

let mut recv = [0u8; 5];
let mut reader = AsyncSliceReader::from(&writer);
executor::block_on(reader.read(&mut recv));
assert_eq!(send, recv);

Implementations

impl<'b> AsyncSliceWriter<'b>

pub fn new(buf: &'b mut [u8]) -> Self

Instantiates a new async reader that implements AsyncWrite over the provided slice.

pub fn bytes_written(&self) -> usize

Returns the number of bytes that have been written so far into the provided slice.

pub fn as_written(&self) -> &[u8]

Returns a read-only slice of the data that has been written so far into the provided slice.

Trait Implementations

impl AsyncWrite for AsyncSliceWriter<'_>

fn poll_write(
    self: Pin<&mut Self>,
    _cx: &mut Context<'_>,
    buf: &[u8]
) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

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

Attempt to flush the object, ensuring that any buffered data reach their destination.

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

Attempt to close the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<'b> From<&'b AsyncSliceWriter<'b>> for AsyncSliceReader<'b>

fn from(s: &'b AsyncSliceWriter<'b>) -> Self

Performs the conversion.

impl<'b> From<&'b mut [u8]> for AsyncSliceWriter<'b>

fn from(buf: &'b mut [u8]) -> Self

Performs the conversion.