seal_rs 0.3.2

Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
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

//! Predefined mailbox without queue size restrictions
//!
//! Is is the default actor mailbox. When using it, you must be careful, because if your system will
//! can't handle the load, this mailbox will be the main point of failure. He simply will use all
//! existed RAM.
//!
use crate::actors::mailbox::Mailbox;
use crate::actors::envelope::Envelope;
use std::collections::vec_deque::VecDeque;
use crate::actors::abstract_actor_ref::AbstractActorRef;

pub struct UnboundMailbox {
    is_planned: bool,
    queue: VecDeque<Envelope>
}

impl UnboundMailbox {
    pub fn new() -> UnboundMailbox {
        UnboundMailbox {
            is_planned: false,
            queue: VecDeque::new()
        }
    }
}

impl Mailbox for UnboundMailbox {

    fn set_planned(self: &mut Self, planned: bool) {
        self.is_planned = planned;
    }

    fn is_planned(self: &Self) -> bool {
        self.is_planned
    }

    fn enqueue(self: &mut Self, envelope: Envelope) {
        self.queue.push_back(envelope);
    }

    fn dequeue(self: &mut Self) -> Envelope {
        self.queue.pop_front().unwrap()
    }

    fn has_messages(self: &Self) -> bool {
        self.queue.len() > 0
    }

    /// Drops all messages to the DeadLetter
    fn clean_up(self: &mut Self, sender: Box<AbstractActorRef>, dead_letters: Box<AbstractActorRef>) {
        let mut dead_letters = dead_letters;

        while true {
            if self.queue.len() > 0 {
                dead_letters.tell(Box::new(self.queue.pop_front().unwrap()), Some(sender.clone()));
            } else {
                break;
            }
        }
    }
}