async-callback-manager 0.1.0

Library that provides an interface to create and manage asynchronous callbacks in Rust. Dependency of `youtui` music player.
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
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
71
72
73
74
75
76
77
78

use crate::{AsyncTask, BackendStreamingTask, BackendTask, FrontendEffect, TaskHandler};
use futures::StreamExt;
#[derive(Debug, PartialEq)]
struct Task1;
#[derive(Debug, PartialEq)]
struct Task2;
#[derive(Debug, PartialEq)]
struct StreamingTask;
impl BackendTask<()> for Task1 {
    type Output = ();
    type MetadataType = ();
    #[allow(clippy::manual_async_fn)]
    fn into_future(
        self,
        _: &(),
    ) -> impl std::future::Future<Output = Self::Output> + Send + 'static {
        async {}
    }
}
impl BackendTask<()> for Task2 {
    type Output = ();
    type MetadataType = ();
    #[allow(clippy::manual_async_fn)]
    fn into_future(
        self,
        _: &(),
    ) -> impl std::future::Future<Output = Self::Output> + Send + 'static {
        async {}
    }
}
impl BackendStreamingTask<()> for StreamingTask {
    type Output = ();
    type MetadataType = ();
    fn into_stream(
        self,
        _: &(),
    ) -> impl futures::Stream<Item = Self::Output> + Send + Unpin + 'static {
        futures::stream::once(async move {}).boxed()
    }
}
#[tokio::test]
async fn test_recursive_map() {
    #[derive(PartialEq, Debug, Clone)]
    #[cfg(all(feature = "task-equality", feature = "task-debug"))]
    struct Handler1;
    #[derive(PartialEq, Debug, Clone)]
    #[cfg(all(feature = "task-equality", feature = "task-debug"))]
    struct Handler2;
    #[cfg(all(feature = "task-equality", feature = "task-debug"))]
    impl TaskHandler<(), (), (), ()> for Handler1 {
        fn handle(self, _: ()) -> impl crate::FrontendEffect<(), (), ()> {
            |_: &mut ()| AsyncTask::new_future(Task1, Handler2, None)
        }
    }
    #[cfg(all(feature = "task-equality", feature = "task-debug"))]
    impl TaskHandler<(), (), (), ()> for Handler2 {
        fn handle(self, _: ()) -> impl crate::FrontendEffect<(), (), ()> {
            |_: &mut ()| AsyncTask::new_future(Task2, crate::NoOpHandler, None)
        }
    }

    #[cfg(not(any(feature = "task-equality", feature = "task-debug")))]
    let handler = |_: &mut (), _| {
        AsyncTask::new_future(
            Task1,
            |_: &mut (), _| AsyncTask::new_future(Task2, |_: &mut (), _| {}, None),
            None,
        )
    };
    #[cfg(all(feature = "task-equality", feature = "task-debug"))]
    let handler = Handler1;

    let recursive_task = AsyncTask::new_stream(StreamingTask, handler, None);
    // Here, it's expected that this is succesful.
    // TODO: Run the task for an expected outcome.
    #[allow(unused_must_use)]
    let _ = recursive_task.map_frontend(|tmp: &mut ()| tmp);
}