[−][src]Struct libpulse_binding::mainloop::threaded::Mainloop
This acts as a safe interface to the internal PA Mainloop.
The mainloop object pointers are further enclosed here in a ref counted wrapper, allowing this outer wrapper to have clean methods for creating event objects, which can cleanly pass a copy of the inner ref counted mainloop object to them. Giving this to events serves two purposes, firstly because they need the API pointer, secondly, it ensures that event objects do not outlive the mainloop object.
Fields
_inner: Rc<MainloopInner<MainloopInternal>>
The ref-counted inner data.
Implementations
impl Mainloop
[src]
pub fn new() -> Option<Self>
[src]
Allocates a new threaded main loop object.
You have to call start
before the event loop thread starts running.
pub fn start(&mut self) -> Result<(), PAErr>
[src]
Starts the event loop thread.
pub fn stop(&mut self)
[src]
Terminates the event loop thread cleanly.
Make sure to unlock the mainloop object before calling this function.
pub fn lock(&mut self)
[src]
Locks the event loop object, effectively blocking the event loop thread from processing events.
You can use this to enforce exclusive access to all objects attached to the event loop. This lock is recursive. This function may not be called inside the event loop thread. Events that are dispatched from the event loop thread are executed with this lock held.
pub fn unlock(&mut self)
[src]
Unlocks the event loop object, inverse of lock
.
pub fn wait(&mut self)
[src]
Waits for an event to be signalled by the event loop thread.
You can use this to pass data from the event loop thread to the main thread in a
synchronized fashion. This function may not be called inside the event loop thread. Prior to
this call the event loop object needs to be locked using lock
. While
waiting the lock will be released. Immediately before returning it will be acquired again.
This function may spuriously wake up even without signal
being called.
You need to make sure to handle that!
pub fn signal(&mut self, wait_for_accept: bool)
[src]
Signals all threads waiting for a signalling event in wait
.
If wait_for_accept
is true
, do not return before the signal was accepted by an
accept
call. While waiting for that condition the event loop object is
unlocked.
pub fn accept(&mut self)
[src]
Accepts a signal from the event thread issued with signal
.
This call should only be used in conjunction with signal
with wait_for_accept
as
true
.
pub fn get_retval(&self) -> Retval
[src]
Gets the return value as specified with the main loop’s quit
routine (used internally by
threaded mainloop).
pub fn get_api<'a>(&self) -> &'a MainloopApi
[src]
Gets the main loop abstraction layer vtable for this main loop.
There is no need to free this object as it is owned by the loop and is destroyed when the loop is freed.
Talking to PA directly with C requires fetching this pointer explicitly via this function. This is actually unnecessary through this binding. The pointer is retrieved automatically upon Mainloop creation, stored internally, and automatically obtained from it by functions that need it.
pub fn in_thread(&self) -> bool
[src]
Checks whether or not we are in the event loop thread (returns true
if so).
pub fn set_name(&mut self, name: &str)
[src]
Sets the name of the thread.
Available since PA version 5.
Trait Implementations
impl Mainloop for Mainloop
[src]
type MI = MainloopInner<MainloopInternal>
fn inner(&self) -> Rc<MainloopInner<MainloopInternal>>
[src]
fn new_io_event(
&mut self,
fd: i32,
events: IoEventFlagSet,
callback: Box<dyn FnMut(IoEventRef<Self::MI>, i32, IoEventFlagSet) + 'static>
) -> Option<IoEvent<Self::MI>>
[src]
&mut self,
fd: i32,
events: IoEventFlagSet,
callback: Box<dyn FnMut(IoEventRef<Self::MI>, i32, IoEventFlagSet) + 'static>
) -> Option<IoEvent<Self::MI>>
fn new_timer_event(
&mut self,
tv: &UnixTs,
callback: Box<dyn FnMut(TimeEventRef<Self::MI>) + 'static>
) -> Option<TimeEvent<Self::MI>>
[src]
&mut self,
tv: &UnixTs,
callback: Box<dyn FnMut(TimeEventRef<Self::MI>) + 'static>
) -> Option<TimeEvent<Self::MI>>
fn new_timer_event_rt(
&mut self,
t: MonotonicTs,
callback: Box<dyn FnMut(TimeEventRef<Self::MI>) + 'static>
) -> Option<TimeEvent<Self::MI>>
[src]
&mut self,
t: MonotonicTs,
callback: Box<dyn FnMut(TimeEventRef<Self::MI>) + 'static>
) -> Option<TimeEvent<Self::MI>>
fn new_deferred_event(
&mut self,
callback: Box<dyn FnMut(DeferEventRef<Self::MI>) + 'static>
) -> Option<DeferEvent<Self::MI>>
[src]
&mut self,
callback: Box<dyn FnMut(DeferEventRef<Self::MI>) + 'static>
) -> Option<DeferEvent<Self::MI>>
fn once_event(&mut self, callback: Box<dyn FnMut() + 'static>)
[src]
fn quit(&mut self, retval: Retval)
[src]
impl MainloopSignals for Mainloop
[src]
fn init_signals(&mut self) -> Result<(), PAErr>
[src]
fn signals_done(&self)
[src]
Auto Trait Implementations
impl !RefUnwindSafe for Mainloop
impl !Send for Mainloop
impl !Sync for Mainloop
impl Unpin for Mainloop
impl UnwindSafe for Mainloop
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,