51 lines
1.4 KiB
Rust
51 lines
1.4 KiB
Rust
//! `Executable` is a property to execute a closure
|
|
|
|
use anyhow::Result;
|
|
|
|
use std::sync::{Arc, RwLock};
|
|
|
|
use crate::prelude::*;
|
|
|
|
/// `Executable` holds a closure which can be executed
|
|
pub struct Executable<I: Send + Sync + 'static> {
|
|
gui_handler: Arc<GuiHandler>,
|
|
callback: RwLock<Option<Arc<dyn Fn(I) -> Result<()> + Send + Sync>>>,
|
|
}
|
|
|
|
impl<I: Send + Sync + 'static> Executable<I> {
|
|
/// Factory method for `Executable`, returns `Arc<Executable>`
|
|
pub fn new(gui_handler: &Arc<GuiHandler>) -> Arc<Self> {
|
|
Arc::new(Executable {
|
|
gui_handler: gui_handler.clone(),
|
|
callback: RwLock::new(None),
|
|
})
|
|
}
|
|
|
|
/// Set callback closure
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `callback` is a `Option<Callback>` closure
|
|
pub fn set_callback<F>(&self, callback: impl Into<Option<F>>)
|
|
where
|
|
F: Fn(I) -> Result<()> + Send + Sync + 'static,
|
|
{
|
|
let mut function = self.callback.write().unwrap();
|
|
|
|
match callback.into() {
|
|
Some(f) => *function = Some(Arc::new(f)),
|
|
None => *function = None,
|
|
}
|
|
}
|
|
|
|
/// Execute the callback closure if possible
|
|
pub fn execute(&self, input: I) -> Result<()> {
|
|
if let Some(callback) = self.callback.read().unwrap().as_ref() {
|
|
let callback = callback.clone();
|
|
|
|
self.gui_handler.add_callback(move || (callback)(input));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|