Struct calloop::io::Async

pub struct Async<'l, F: AsFd> {
    fd: Option<F>,
    dispatcher: Rc<RefCell<IoDispatcher>>,
    inner: Rc<dyn IoLoopInner + 'l>,
    was_nonblocking: bool,
}

Adapter for async IO manipulations

This type wraps an IO object, providing methods to create futures waiting for its readiness.

If the futures-io cargo feature is enabled, it also implements AsyncRead and/or AsyncWrite if the underlying type implements Read and/or Write.

Note that this adapter and the futures procuded from it and not threadsafe.

Platform-Specific

• Windows: Usually, on drop, the file descriptor is set back to its previous status. For example, if the file was previously nonblocking it will be set to nonblocking, and if the file was blocking it will be set to blocking. However, on Windows, it is impossible to tell what its status was before. Therefore it will always be set to blocking.

Fields

fd: Option<F>

dispatcher: Rc<RefCell<IoDispatcher>>

inner: Rc<dyn IoLoopInner + 'l>

was_nonblocking: bool

Implementations

impl<'l, F: AsFd> Async<'l, F>

pub(crate) fn new<Data>( inner: Rc<LoopInner<'l, Data>>, fd: F, ) -> Result<Async<'l, F>>

pub fn get_mut(&mut self) -> &mut F

Mutably access the underlying IO object

pub fn readable<'s>(&'s mut self) -> Readable<'s, 'l, F>

A future that resolves once the object becomes ready for reading

pub fn writable<'s>(&'s mut self) -> Writable<'s, 'l, F>

A future that resolves once the object becomes ready for writing

pub fn into_inner(self) -> F

Remove the async adapter and retrieve the underlying object

fn readiness(&self) -> Readiness

fn register_waker(&self, interest: Interest, waker: Waker) -> Result<()>

Trait Implementations

impl<'l, F: AsFd + Debug> Debug for Async<'l, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'l, F: AsFd> Drop for Async<'l, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<'l, F: AsFd> Unpin for Async<'l, F>