bobwen-dev/hunter
1
0
Fork 0
mirror of https://github.com/bobwen-dev/hunter synced 2025-04-12 00:55:41 +02:00
Code Issues Releases Wiki Activity

make async clonable

Browse Source
This commit is contained in:
rabite 2019-03-25 15:28:45 +01:00
parent 3888f49aeb
commit 153bf24238
2 changed files with 15 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/files.rs
View File

@ -457,41 +457,8 @@ impl Hash for File {
impl Eq for File {} impl Eq for File {}
impl Clone for File {
fn clone(&self) -> Self {
let meta = self.meta.value.clone();
let meta = match meta {
Ok(meta) => Async::new_with_value(meta.clone()),
Err(_) => File::make_async_meta(&self.path, self.dirty_meta.clone())
};
let dirsize = if let Some(ref dirsize) = self.dirsize { #[derive(Clone, Debug)]
let dirsize = dirsize.value.clone();
let dirsize = match dirsize {
Ok(dirsize) => Async::new_with_value(dirsize),
Err(_) => File::make_async_dirsize(&self.path,
self.dirty_meta.clone())
};
Some(dirsize)
} else { None };
File {
name: self.name.clone(),
path: self.path.clone(),
kind: self.kind.clone(),
dirsize: dirsize,
target: self.target.clone(),
color: self.color.clone(),
meta: meta,
dirty_meta: self.dirty_meta.clone(),
meta_processed: self.meta_processed.clone(),
selected: self.selected.clone(),
tag: self.tag.clone()
}
}
}
#[derive(Debug)]
pub struct File { pub struct File {
pub name: String, pub name: String,
pub path: PathBuf, pub path: PathBuf,

27
src/preview.rs
View File

@ -51,11 +51,12 @@ impl<T: Send + Debug> Debug for Async<T> {
} }
#[derive(Clone)]
pub struct Async<T: Send> { pub struct Async<T: Send> {
pub value: HResult<T>, pub value: HResult<T>,
async_value: AsyncValue<T>, async_value: AsyncValue<T>,
async_closure: Option<AsyncValueFn<T>>, async_closure: Arc<Mutex<Option<AsyncValueFn<T>>>>,
on_ready: Option<AsyncReadyFn<T>>, on_ready: Arc<Mutex<Option<AsyncReadyFn<T>>>>,
stale: Stale stale: Stale
} }
@ -65,8 +66,8 @@ impl<T: Send + 'static> Async<T> {
let async_value = Async { let async_value = Async {
value: HError::async_not_ready(), value: HError::async_not_ready(),
async_value: Arc::new(Mutex::new(None)), async_value: Arc::new(Mutex::new(None)),
async_closure: Some(closure), async_closure: Arc::new(Mutex::new(Some(closure))),
on_ready: None, on_ready: Arc::new(Mutex::new(None)),
stale: Arc::new(Mutex::new(false)) }; stale: Arc::new(Mutex::new(false)) };
async_value async_value
@ -76,17 +77,17 @@ impl<T: Send + 'static> Async<T> {
Async { Async {
value: Ok(val), value: Ok(val),
async_value: Arc::new(Mutex::new(None)), async_value: Arc::new(Mutex::new(None)),
async_closure: None, async_closure: Arc::new(Mutex::new(None)),
on_ready: None, on_ready: Arc::new(Mutex::new(None)),
stale: Arc::new(Mutex::new(false)) stale: Arc::new(Mutex::new(false))
} }
} }
pub fn run(&mut self) -> HResult<()> { pub fn run(&mut self) -> HResult<()> {
let closure = self.async_closure.take()?; let closure = self.async_closure.lock()?.take()?;
let async_value = self.async_value.clone(); let async_value = self.async_value.clone();
let stale = self.stale.clone(); let stale = self.stale.clone();
let on_ready_fn = self.on_ready.take(); let on_ready_fn = self.on_ready.lock()?.take();
std::thread::spawn(move|| -> HResult<()> { std::thread::spawn(move|| -> HResult<()> {
let mut value = closure(stale); let mut value = closure(stale);
@ -104,10 +105,10 @@ impl<T: Send + 'static> Async<T> {
} }
pub fn run_pooled(&mut self, pool: &ThreadPool) -> HResult<()> { pub fn run_pooled(&mut self, pool: &ThreadPool) -> HResult<()> {
let closure = self.async_closure.take()?; let closure = self.async_closure.lock()?.take()?;
let async_value = self.async_value.clone(); let async_value = self.async_value.clone();
let stale = self.stale.clone(); let stale = self.stale.clone();
let on_ready_fn = self.on_ready.take(); let on_ready_fn = self.on_ready.lock()?.take();
pool.spawn(move || { pool.spawn(move || {
let mut value = closure(stale); let mut value = closure(stale);
@ -126,9 +127,9 @@ impl<T: Send + 'static> Async<T> {
} }
pub fn wait(&mut self) -> HResult<()> { pub fn wait(&mut self) -> HResult<()> {
let closure = self.async_closure.take()?; let closure = self.async_closure.lock()?.take()?;
let mut value = closure(self.stale.clone()); let mut value = closure(self.stale.clone());
let on_ready_fn = self.on_ready.take(); let on_ready_fn = self.on_ready.lock()?.take();
if let Ok(ref mut value) = value { if let Ok(ref mut value) = value {
@ -185,7 +186,7 @@ impl<T: Send + 'static> Async<T> {
pub fn on_ready(&mut self, pub fn on_ready(&mut self,
fun: AsyncReadyFn<T>) { fun: AsyncReadyFn<T>) {
self.on_ready = Some(fun); *self.on_ready.lock().unwrap() = Some(fun);
} }
} }