eureka-mmanager 0.3.3

An Actix actor collection for downloading manga, chapters, covers from Mangadex
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use actix::prelude::*;
use dev::ToEnvelope;

use super::MailBoxResult;

use crate::{
    download::{
        messages::{
            CancelTaskMessage, StartDownload, SubcribeMessage, TaskStateMessage,
            TaskSubscriberMessages, WaitForFinishedMessage,
        },
        state::{TaskState, WaitForFinished},
    },
    recipients::MaybeWeakRecipient,
};

pub trait Cancelable: Actor {
    fn cancel(&mut self, ctx: &mut Self::Context);
}

pub trait Download: Actor {
    fn download(&mut self, ctx: &mut Self::Context);
}

pub trait State: Actor
where
    Self::State: Into<TaskState> + Send,
{
    type State;
    fn state(&self) -> TaskState {
        self.inner_state().into()
    }
    fn inner_state(&self) -> Self::State;
}

pub trait Subscribe: State {
    fn subscribe(&mut self, subscriber: MaybeWeakRecipient<TaskSubscriberMessages<Self::State>>);
}

pub trait CanBeWaited: State {
    type Ok;
    type Loading;
    fn wait(&mut self) -> WaitForFinished<Self::Ok, Self::Loading>;
}

pub trait AsyncCancelable: Sync {
    fn cancel(&self) -> impl std::future::Future<Output = MailBoxResult<()>> + Send;
}

impl<A> AsyncCancelable for Addr<A>
where
    A: Handler<CancelTaskMessage> + Cancelable,
    <A as actix::Actor>::Context:
        actix::dev::ToEnvelope<A, crate::download::messages::CancelTaskMessage>,
{
    async fn cancel(&self) -> MailBoxResult<()> {
        self.send(CancelTaskMessage).await
    }
}

pub trait AsyncDownload: Sync {
    fn download(&self) -> impl std::future::Future<Output = MailBoxResult<()>> + Send;
}

impl<A> AsyncDownload for Addr<A>
where
    A: Handler<StartDownload> + Download,
    <A as Actor>::Context: ToEnvelope<A, StartDownload>,
{
    async fn download(&self) -> MailBoxResult<()> {
        self.send(StartDownload).await
    }
}

pub trait AsyncState: Sync {
    type State: Send;
    fn state(&self) -> impl std::future::Future<Output = MailBoxResult<TaskState>> + Send;
}

impl<A> AsyncState for Addr<A>
where
    A: Handler<TaskStateMessage> + State,
    <A as Actor>::Context: ToEnvelope<A, TaskStateMessage>,
{
    type State = <A as State>::State;
    async fn state(&self) -> MailBoxResult<TaskState> {
        self.send(TaskStateMessage).await
    }
}

pub trait AsyncSubscribe: AsyncState {
    fn subscribe(
        &self,
        subscriber: MaybeWeakRecipient<TaskSubscriberMessages<Self::State>>,
    ) -> impl std::future::Future<Output = MailBoxResult<()>> + Send;
}

impl<A> AsyncSubscribe for Addr<A>
where
    A: Handler<SubcribeMessage<<A as State>::State>>
        + Subscribe
        + Handler<TaskStateMessage>
        + State,
    <A as State>::State: Send + Sync,
    <A as Actor>::Context:
        ToEnvelope<A, SubcribeMessage<<A as State>::State>> + ToEnvelope<A, TaskStateMessage>,
{
    async fn subscribe(
        &self,
        subscriber: MaybeWeakRecipient<TaskSubscriberMessages<Self::State>>,
    ) -> MailBoxResult<()> {
        self.send(SubcribeMessage(subscriber)).await
    }
}

pub trait AsyncCanBeWaited: AsyncState {
    type Ok;
    type Loading;
    fn wait(
        &mut self,
    ) -> impl std::future::Future<Output = MailBoxResult<WaitForFinished<Self::Ok, Self::Loading>>> + Send;
}

impl<A> AsyncCanBeWaited for Addr<A>
where
    A: Handler<SubcribeMessage<<A as State>::State>>
        + Subscribe
        + Handler<TaskStateMessage>
        + State
        + CanBeWaited
        + Handler<WaitForFinishedMessage<<A as CanBeWaited>::Ok, <A as CanBeWaited>::Loading>>,
    <A as State>::State: Send + Sync,
    <A as CanBeWaited>::Loading: Send + Sync,
    <A as CanBeWaited>::Ok: Send + Sync,
    <A as Actor>::Context: ToEnvelope<A, SubcribeMessage<<A as State>::State>>
        + ToEnvelope<A, TaskStateMessage>
        + ToEnvelope<A, WaitForFinishedMessage<<A as CanBeWaited>::Ok, <A as CanBeWaited>::Loading>>,
{
    type Loading = <A as CanBeWaited>::Loading;
    type Ok = <A as CanBeWaited>::Ok;
    async fn wait(&mut self) -> MailBoxResult<WaitForFinished<Self::Ok, Self::Loading>> {
        self.send(WaitForFinishedMessage::<
            <A as CanBeWaited>::Ok,
            <A as CanBeWaited>::Loading,
        >::new())
            .await
    }
}