Struct breadthread::BreadThread

pub struct BreadThread<'evh, Ctrl: Controller> { /* fields omitted */ }

The object representing the bread thread. The thread this object is created in is the bread thread, and it cannot be moved out of the bread thread.

The lifetime associated with this object is the lifetime of whatever event handler is passed in. If you want to pass its handles between threads, this lifetime will probably be 'static unless you’re using scoped threads or scoped executors.

Implementations

impl<'evh, Ctrl: Controller> BreadThread<'evh, Ctrl>

pub fn try_new(controller: Ctrl) -> Result<Self, Error<Ctrl::Error>>

Create a new BreadThread from a controller. This function returns an error if the thread is already a bread thread.

pub fn new(controller: Ctrl) -> Self

Create a new BreadThread from a controller. This function panics an error if the thread is already a bread thread.

pub fn with<T, F: FnOnce(&Ctrl) -> T>(&self, f: F) -> T

Use the controller in a closure.

pub fn with_mut<T, F: FnOnce(&mut Ctrl) -> T>(&mut self, f: F) -> T

Use the controller in a mutable closure.

pub fn send_directive<T: Any + Send>(
    &self,
    directive: Ctrl::Directive
) -> Result<Receiver<T>, Error<Ctrl::Error>>

Send a directive to the thread’s controller.

pub fn set_event_handler<F: FnMut(&Ctrl, Ctrl::Event) -> Result<(), Ctrl::Error> + Send + 'evh>(
    &self,
    event_handler: F
)

Set the event handler we are using for the bread thread.

pub fn process_event(
    &self,
    event: Ctrl::Event
) -> Result<(), Error<Ctrl::Error>>

Process an event using the currently set event handler.

pub fn main_loop(self) -> Result<(), Error<Ctrl::Error>>

Run the main loop.

pub fn handle(&self) -> ThreadHandle<'evh, Ctrl>

Create a handle to this BreadThread that can send directives.

Trait Implementations

impl<'evh, Ctrl: Controller> Drop for BreadThread<'evh, Ctrl>

fn drop(&mut self)

Executes the destructor for this type.