eureka-mmanager 0.4.0

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

use std::time::Duration;

use actix::{dev::RecipientRequest, Message, Recipient, WeakRecipient};
use parking_lot::lock_api::RwLock;
use shrink_fit_wrapper::ShrinkFitWrapper;

use crate::ArcRwLock;

#[derive(Clone, Debug)]
pub enum MaybeWeakRecipient<M>
where
    M: Message + Send,
    M::Result: Send,
{
    Strong(Recipient<M>),
    Weak(WeakRecipient<M>),
}

impl<M> MaybeWeakRecipient<M>
where
    M: Message + Send,
    M::Result: Send,
{
    pub fn as_weak(&self) -> WeakRecipient<M> {
        match self {
            MaybeWeakRecipient::Strong(recipient) => recipient.downgrade(),
            MaybeWeakRecipient::Weak(weak_recipient) => weak_recipient.clone(),
        }
    }
    pub fn as_strong(&self) -> Option<Recipient<M>> {
        match self {
            MaybeWeakRecipient::Strong(recipient) => Some(recipient.clone()),
            MaybeWeakRecipient::Weak(weak_recipient) => weak_recipient.upgrade(),
        }
    }
    pub fn make_weak(&mut self) {
        *self = Self::Weak(self.as_weak());
    }
    pub fn make_strong(&mut self) {
        if let Some(strong) = self.as_strong() {
            *self = Self::Strong(strong);
        }
    }
    pub fn connected(&self) -> bool {
        self.as_strong().is_some_and(|d| d.connected())
    }
    /// `true` indicate that the [`Recipient::do_send`] was called, `false` otherwise.
    pub fn do_send(&self, message: M) -> bool {
        if let Some(recept) = self.as_strong() {
            recept.do_send(message);
            true
        } else {
            false
        }
    }
    pub fn send(&self, message: M) -> Option<RecipientRequest<M>> {
        self.as_strong().map(|d| d.send(message))
    }
}

impl<M> From<Recipient<M>> for MaybeWeakRecipient<M>
where
    M: Message + Send,
    M::Result: Send,
{
    fn from(value: Recipient<M>) -> Self {
        Self::Strong(value)
    }
}

impl<M> From<WeakRecipient<M>> for MaybeWeakRecipient<M>
where
    M: Message + Send,
    M::Result: Send,
{
    fn from(value: WeakRecipient<M>) -> Self {
        Self::Weak(value)
    }
}

#[derive(Debug, Clone)]
pub(crate) struct Recipients<M>(ArcRwLock<ShrinkFitWrapper<Vec<MaybeWeakRecipient<M>>>>)
where
    M: Message + Send,
    M::Result: Send;

impl<M> Default for Recipients<M>
where
    M: Message + Send,
    M::Result: Send,
{
    fn default() -> Self {
        Self(ArcRwLock::new(RwLock::new(
            ShrinkFitWrapper::new(Vec::default())
                .set_shrink_duration_cycle(Duration::from_secs(60 * 5)),
        )))
    }
}

impl<M> Recipients<M>
where
    M: Message + Send,
    M::Result: Send,
{
    fn clean_up(&self) {
        self.0.write().as_mut().retain(|e| e.connected());
    }
    pub fn push_recipient(&self, recipient: MaybeWeakRecipient<M>) {
        {
            let mut write = self.0.write();
            write.as_mut().push(recipient);
        }
        self.clean_up();
    }
    pub fn has_connection(&self) -> bool {
        self.0.read().iter().any(|r| r.connected())
    }
}

impl<M> Recipients<M>
where
    M: Message + Clone + Send,
    M::Result: Send,
{
    pub fn do_send(&self, message: M) {
        self.0
            .write()
            .as_mut()
            .retain(|recipient| recipient.do_send(message.clone()));
    }
}