scaproust 0.3.2

Nanomsg scalability protocols implementation in rust. Various messaging patterns over pluggable transports
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

// Copyright (c) 2015-2017 Contributors as noted in the AUTHORS file.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>
// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
// This file may not be copied, modified, or distributed except according to those terms.

use std::io;

use mio::{Poll, Token, Ready, Event, Events, Evented, PollOpt};

pub trait EventHandler {
    fn handle(&mut self, el: &mut EventLoop, token: Token, events: Ready);
}

pub struct EventLoop {
    events_poller: Poll,
    events: Events,
    running: bool
}

impl EventLoop {
    pub fn new() -> io::Result<EventLoop> {
        let evts = Events::with_capacity(1024);
        let poll = try!(Poll::new());
        let event_loop = EventLoop {
            events_poller: poll,
            events: evts,
            running: false
        };

        Ok(event_loop)
    }

    pub fn shutdown(&mut self) {
        self.running = false;
    }

    pub fn run<H: EventHandler>(&mut self, event_handler: &mut H) -> io::Result<()> {
        self.running = true;

        while self.running {
            try!(self.run_once(event_handler));
        }

        Ok(())
    }

    pub fn run_once<H: EventHandler>(&mut self, event_handler: &mut H) -> io::Result<()> {
        let event_count = match self.poll_events() {
            Ok(count) => count,
            Err(err) => {
                if err.kind() == io::ErrorKind::Interrupted {
                    0
                } else {
                    return Err(err);
                }
            }
        };

        self.process_events(event_handler, event_count);

        Ok(())
    }

    fn poll_events(&mut self) -> io::Result<usize> {
        self.events_poller.poll(&mut self.events, None)
    }

    fn process_events<H: EventHandler>(&mut self, event_handler: &mut H, count: usize) {
        for event in self.events.iter().take(count).collect::<Vec<Event>>() {
            event_handler.handle(self, event.token(), event.readiness());
        }
    }

    pub fn register(&mut self, io: &Evented, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> {
        self.events_poller.register(io, token, interest, opt)
    }
    pub fn reregister(&mut self, io: &Evented, token: Token, interest: Ready, opt: PollOpt) -> io::Result<()> {
        self.events_poller.reregister(io, token, interest, opt)
    }
    pub fn deregister(&mut self, io: &Evented) -> io::Result<()> {
        self.events_poller.deregister(io)
    }
}