Struct libuv::handles::async::AsyncHandle

pub struct AsyncHandle { /* fields omitted */ }

Async handles allow the user to “wakeup” the event loop and get a callback called from another thread.

Implementations

impl AsyncHandle

pub fn new<CB: Into<AsyncCB<'static>>>(
    r#loop: &Loop,
    cb: CB
) -> Result<AsyncHandle>

Create and initialize a new async handle

pub fn send(&mut self) -> Result<()>

Wake up the event loop and call the async handle’s callback.

Note: It’s safe to call this function from any thread. The callback will be called on the loop thread.

Note: uv_async_send() is async-signal-safe. It’s safe to call this function from a signal handler.

Warning: libuv will coalesce calls to send(), that is, not every call to it will yield an execution of the callback. For example: if send() is called 5 times in a row before the callback is called, the callback will only be called once. If send() is called again after the callback was called, it will be called again.

Trait Implementations

impl Clone for AsyncHandle

fn clone(&self) -> AsyncHandle

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for AsyncHandle

impl From<AsyncHandle> for Handle

fn from(r#async: AsyncHandle) -> Handle

Performs the conversion.

impl HandleTrait for AsyncHandle

fn is_active(&self) -> bool

Returns non-zero if the handle is active, zero if it’s inactive. What “active” means depends on the type of handle: * An AsyncHandle is always active and cannot be deactivated, except by closing it with close(). * A PipeHandle, TcpHandle, UdpHandle, etc. - basically any handle that deals with i/o - is active when it is doing something that involves i/o, like reading, writing, connecting, accepting new connections, etc. * A CheckHandle, IdleHandle, TimerHandle, etc. is active when it has been started with a call to start().

fn is_closing(&self) -> bool

Returns non-zero if the handle is closing or closed, zero otherwise.

fn close<CB: Into<CloseCB<'static>>>(&mut self, cb: CB)

Request handle to be closed. close_cb will be called asynchronously after this call. This MUST be called on each handle before memory is released. Moreover, the memory can only be released in close_cb or after it has returned.

fn ref(&mut self)

Reference the given handle. References are idempotent, that is, if a handle is already referenced calling this function again will have no effect.

fn unref(&mut self)

Un-reference the given handle. References are idempotent, that is, if a handle is not referenced calling this function again will have no effect.

fn has_ref(&self) -> bool

Returns true if the handle referenced, zero otherwise.

fn send_buffer_size(&mut self, value: i32) -> Result<i32>

Gets or sets the size of the send buffer that the operating system uses for the socket.

fn recv_buffer_size(&mut self, value: i32) -> Result<i32>

Gets or sets the size of the receive buffer that the operating system uses for the socket.

fn get_fileno(&self) -> Result<OsFile>

Gets the platform dependent file descriptor equivalent.

fn get_loop(&self) -> Loop

Returns the Loop associated with this handle.

fn get_type(&self) -> HandleType

Returns the type of the handle.

impl Send for AsyncHandle

impl Sync for AsyncHandle

impl ToHandle for AsyncHandle

fn to_handle(&self) -> Handle

impl TryFrom<Handle> for AsyncHandle

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(handle: Handle) -> Result<Self, Self::Error>

Performs the conversion.