use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use pixelmap::Photo;
use crate::error::Error;
use crate::event::{Event, Flow, Status};
use crate::options::Options;
use crate::pipeline::{self, Model};
#[derive(Clone, Debug, Default)]
pub struct Cancel(Arc<AtomicBool>);
impl Cancel {
pub fn new() -> Self {
Cancel::default()
}
pub fn cancel(&self) {
self.0.store(true, Ordering::Relaxed);
}
pub fn is_cancelled(&self) -> bool {
self.0.load(Ordering::Relaxed)
}
}
pub struct Job {
events: Receiver<Event>,
status: Arc<Mutex<Status>>,
cancel: Cancel,
worker: Option<JoinHandle<Result<Model, Error>>>,
}
impl Job {
pub fn start(photos: Vec<Arc<Photo>>, options: Options) -> Job {
let (sender, events) = mpsc::channel();
let status = Arc::new(Mutex::new(Status::new()));
let cancel = Cancel::new();
let worker_status = Arc::clone(&status);
let worker_cancel = cancel.clone();
let worker = thread::spawn(move || {
pipeline::run(&photos, &options, &mut |event| {
if let Ok(mut status) = worker_status.lock() {
status.update(&event);
}
let _ = sender.send(event);
if worker_cancel.is_cancelled() {
Flow::Break(())
} else {
Flow::Continue(())
}
})
});
Job {
events,
status,
cancel,
worker: Some(worker),
}
}
pub fn events(&self) -> &Receiver<Event> {
&self.events
}
pub fn status(&self) -> Status {
self.status
.lock()
.map(|status| status.clone())
.unwrap_or_else(|poisoned| poisoned.into_inner().clone())
}
pub fn cancel(&self) {
self.cancel.cancel();
}
pub fn canceller(&self) -> Cancel {
self.cancel.clone()
}
pub fn join(mut self) -> Result<Model, Error> {
self.worker
.take()
.expect("a job holds its worker until it is joined")
.join()
.unwrap_or_else(|panic| std::panic::resume_unwind(panic))
}
}
impl std::fmt::Debug for Job {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Job")
.field("status", &self.status())
.field("cancelled", &self.cancel.is_cancelled())
.field(
"finished",
&self.worker.as_ref().map_or(true, |w| w.is_finished()),
)
.finish_non_exhaustive()
}
}
impl Drop for Job {
fn drop(&mut self) {
if self.worker.is_none() {
return;
}
self.cancel.cancel();
}
}