Struct libpulse_binding::mainloop::api::MainloopInner

pub struct MainloopInner<T> where
    T: MainloopInternalType,  { /* private fields */ }

Mainloop inner wrapper.

This contains the actual main loop object pointers, holding both the pointer to the actual opaque main loop C object, and the pointer to the associated API vtable.

An instance of this type will be held, in an Rc ref counted wrapper both in an outer Mainloop wrapper, and by all event objects. With event objects holding a ref-counted copy, this both gives event objects access to the API pointer, which they need, and also it allows us to ensure that event objects do not outlive the main loop object (which internally owns the API object), and thus ensures correct destruction order of event and main loop objects.

Trait Implementations

impl<T> Drop for MainloopInner<T> where
    T: MainloopInternalType, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T> MainloopInnerType for MainloopInner<T> where
    T: MainloopInternalType, 

This is the actual implementation of the ‘inner type’ trait.

It is not possible to replace this with ‘default’ method implementations within the trait itself since the trait does not know about the existence of the struct attributes being accessed.

fn get_ptr(&self) -> *mut T

Gets opaque main loop object pointer.

Warning: The pointer is only valid for the lifetime of this object.

fn get_api_ptr(&self) -> *const MainloopApi

Gets raw API object pointer.

Warning: The pointer is only valid for the lifetime of this object.

fn get_api(&self) -> &MainloopApi

Gets main loop API object pointer.

type I = T

Internal mainloop type.

fn supports_rtclock(&self) -> bool

Returns true if the mainloop implementation supports monotonic based time events.

unsafe fn new(
    ptr: *mut Self::I,
    api: *const MainloopApi,
    dropfn: fn(_: &mut MainloopInner<Self::I>),
    supports_rtclock: bool
) -> MainloopInner<Self::I>

Create a new instance