1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
//! Machinery for [tasks](https://html.spec.whatwg.org/multipage/#concept-task).
use std::fmt;
use std::intrinsics;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
/// A task that can be run. The name method is for profiling purposes.
pub trait Task {
#[allow(unsafe_code)]
fn name(&self) -> &'static str { unsafe { intrinsics::type_name::<Self>() } }
fn run(self: Box<Self>);
}
impl fmt::Debug for Task + Send {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
fmt.debug_tuple(self.name()).field(&format_args!("...")).finish()
}
}
/// Encapsulated state required to create cancellable tasks from non-script threads.
pub struct TaskCanceller {
pub cancelled: Option<Arc<AtomicBool>>,
}
impl TaskCanceller {
/// Returns a wrapped `task` that will be cancelled if the `TaskCanceller`
/// says so.
pub fn wrap_task<T>(&self, task: Box<T>) -> Box<Task + Send>
where
T: Send + Task + 'static,
{
box CancellableTask {
cancelled: self.cancelled.clone(),
inner: task,
}
}
}
/// A task that can be cancelled by toggling a shared flag.
pub struct CancellableTask<T: Send + Task> {
cancelled: Option<Arc<AtomicBool>>,
inner: Box<T>,
}
impl<T> CancellableTask<T>
where
T: Send + Task,
{
fn is_cancelled(&self) -> bool {
self.cancelled.as_ref().map_or(false, |cancelled| {
cancelled.load(Ordering::SeqCst)
})
}
}
impl<T> Task for CancellableTask<T>
where
T: Send + Task,
{
fn run(self: Box<Self>) {
if !self.is_cancelled() {
self.inner.run()
}
}
}
|
