tokio-fs-ext 0.7.1

Extend tokio fs to be compatible with native and wasm
Documentation 
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

use futures::stream::{FuturesUnordered, StreamExt};
use tokio::sync::mpsc;

use super::{FsOffload, FsOffloadDefault, FsTask};

pub struct Server {
    pub(super) receiver: mpsc::UnboundedReceiver<FsTask>,
}

impl Server {
    pub async fn serve(&mut self, offload: impl FsOffload) {
        let mut tasks = FuturesUnordered::new();
        let offload = &offload;

        loop {
            tokio::select! {
                res = self.receiver.recv() => {
                    match res {
                        Some(task) => {
                            tasks.push(async move {
                                task.execute(offload).await;
                            });
                        }
                        None => {
                            while (tasks.next().await).is_some() {}
                            break;
                        }
                    }
                }
                Some(_) = tasks.next() => {}
            }
        }
    }

    pub async fn serve_default(&mut self) {
        self.serve(FsOffloadDefault).await
    }
}