Struct `SigEvent`

#[repr(C)]
pub struct SigEvent { /* private fields */ }

Used to request asynchronous notification of the completion of certain events, such as POSIX AIO and timers.

Implementations

`impl SigEvent`

fn new(sigev_notify: SigevNotify<'_>) -> SigEvent

Note: this constructor does not allow the user to set the sigev_notify_kevent_flags field. That's considered ok because on FreeBSD at least those flags don't do anything useful. That field is part of a union that shares space with the more genuinely useful fields.

Note: This constructor also doesn't allow the caller to set the sigev_notify_function or sigev_notify_attributes fields, which are required for SIGEV_THREAD. That's considered ok because on no operating system is SIGEV_THREAD the most efficient way to deliver AIO notification. FreeBSD and DragonFly BSD programs should prefer SIGEV_KEVENT. Linux, Solaris, and portable programs should prefer SIGEV_THREAD_ID or SIGEV_SIGNAL. That field is part of a union that shares space with the more genuinely useful sigev_notify_thread_id

fn sigevent(&self) -> sigevent

Return a copy of the inner structure

fn as_mut_ptr(&mut self) -> *mut sigevent

Returns a mutable pointer to the sigevent wrapped by self

Trait Implementations

`impl Clone for SigEvent`

fn clone(&self) -> Self

`impl Debug for SigEvent`

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

`impl Eq for SigEvent`

`impl From<&sigevent> for SigEvent`

fn from(sigevent: &sigevent) -> Self

`impl Hash for SigEvent`

fn hash<__H: Hasher>(&self, state: &mut __H)

`impl PartialEq for SigEvent`

fn eq(&self, other: &Self) -> bool

`impl StructuralPartialEq for SigEvent`

Auto Trait Implementations

`impl !Send for SigEvent`

`impl !Sync for SigEvent`

`impl Freeze for SigEvent`

`impl RefUnwindSafe for SigEvent`

`impl Unpin for SigEvent`

`impl UnsafeUnpin for SigEvent`

`impl UnwindSafe for SigEvent`

Blanket Implementations

`impl<T> Any for SigEvent where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for SigEvent where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for SigEvent where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for SigEvent where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for SigEvent`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for SigEvent where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into<U> for SigEvent where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for SigEvent where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto<U> for SigEvent where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>