daxvena/elemeld - Change 6WLPW4L4PN6ANYYW3I6AOCN3SXQP37RQTUOM52IVXL3SRZD7UHAAC

Merged EventManager into Elemeld

Created by daxvena on March 7, 2016

6WLPW4L4PN6ANYYW3I6AOCN3SXQP37RQTUOM52IVXL3SRZD7UHAAC

Dependencies

In channels

main

Change contents

Replacement in src/cluster.rs at line 2 [3.13]
B:BD[3.22] → [3.22:44]
```
use elemeld::Elemeld;
```
[3.22]
[4.23]
```
use elemeld::Config;
```

Replacement in src/cluster.rs at line 35 [3.13]

B:BD[3.472] → [3.472:549]

    pub fn filter_host_event<H>(&mut self, host: &H) -> Option<io::NetEvent>

[3.472]

[3.549]

    pub fn process_host_event<H>(&mut self, host: &H, event: io::HostEvent) -> Option<io::NetEvent>

Replacement in src/cluster.rs at line 38 [3.13]

B:BD[3.590] → [3.590:624]

B:BD[3.624] → [4.76:126]

        match host.recv_event() {
            Some(io::HostEvent::Motion(event)) =>

[3.590]

[3.676]

        match event {
            io::HostEvent::Motion(event) => {

Replacement in src/cluster.rs at line 51 [3.13]

∅:D[5.690] → [4.127:187]

B:BD[3.1036] → [4.127:187]

                } else { None },
            Some(event) =>

[5.690]

[3.1148]

                } else { None }
            },
            event => {

Replacement in src/cluster.rs at line 60 [3.13]

B:BD[3.1460] → [4.188:221]

∅:D[4.221] → [3.1542:1568]

B:BD[3.1542] → [3.1542:1568]

                } else { None },
            None => None,

[3.1460]

[3.1568]

                } else { None }
            },

Replacement in src/cluster.rs at line 65 [3.13]

B:BD[3.1585] → [3.1585:1672]

    pub fn filter_net_event(&mut self, event: io::NetEvent) -> Option<io::HostEvent> {

[3.1585]

[3.1672]

    pub fn process_net_event(&mut self, event: io::NetEvent) -> Option<io::HostEvent> {

Replacement in src/elemeld.rs at line 1 [3.8294]
B:BD[3.8294] → [3.8295:8303]
```
use io;
```
[3.8294]
[3.8303]
```
use io::{self, HostInterface, NetInterface};
```
Insertion in src/elemeld.rs at line 3 [3.8294]
[3.8325]
[3.8325]
```
use x11::X11Interface;
use ip::IpInterface;
```

Replacement in src/elemeld.rs at line 6 [3.8294]

B:BD[3.8326] → [3.8326:8453]

pub struct Elemeld<H, N> where
    H: io::HostInterface,
    N: io::NetInterface,
{
    host: H,
    net: N,
    state: State,

[3.8326]

[3.8453]

use mio;
use std::net;
const HOST_EVENT: mio::Token = mio::Token(0);
const NET_EVENT: mio::Token = mio::Token(1);
pub struct Elemeld<'a> {
    config: &'a Config,

Insertion in src/elemeld.rs at line 15 [3.8294]

[3.8475]

    host: X11Interface,
    net: IpInterface<'a>,
    state: State,

Insertion in src/elemeld.rs at line 20 [3.8294]

[3.8478]

[6.1041]

pub struct Config {
    pub server_addr: mio::IpAddr,
    pub multicast_addr: mio::IpAddr,
    pub port: u16
}

Replacement in src/elemeld.rs at line 33 [3.8294]

B:BD[3.8566] → [3.8566:8692]

impl<H, N> Elemeld<H, N> where
    H: io::HostInterface,
    N: io::NetInterface,
{
    pub fn new(host: H, net: N) -> Self {

[3.8566]

[3.8692]

impl<'a> Elemeld<'a> {
    pub fn new(event_loop: &mut mio::EventLoop<Self>, config: &'a Config) -> Self {
        // Setup host interface
        let host = X11Interface::open();
        event_loop.register(&host,
                            HOST_EVENT,
                            mio::EventSet::readable(),
                            mio::PollOpt::level()).unwrap();
        // Setup cluster

Insertion in src/elemeld.rs at line 45 [3.8294]

[3.8782]

        let cluster = Cluster::new(width, height, x, y);

Insertion in src/elemeld.rs at line 47 [3.8294]

[3.8783]

        // Setup net interface
        let net = IpInterface::open(config);
        event_loop.register(&net,
                            NET_EVENT,
                            mio::EventSet::readable() |
                            mio::EventSet::writable(),
                            mio::PollOpt::oneshot()).unwrap();

Insertion in src/elemeld.rs at line 56 [3.8294]

[3.8801]

            config: config,
            cluster: cluster,

Deletion in src/elemeld.rs at line 61 [3.8294]
B:BD[3.8885] → [3.8885:8941]
```
            cluster: Cluster::new(width, height, x, y),
```

Replacement in src/elemeld.rs at line 64 [3.8294]

B:BD[3.8958] → [3.8958:8993]

    pub fn host_event(&mut self) {

[3.8958]

[3.8993]

    pub fn host_event(&mut self, event: io::HostEvent) {

Replacement in src/elemeld.rs at line 66 [3.8294]

B:BD[3.9020] → [3.9020:9103]

B:BD[3.9103] → [2.230:671]

            State::Connected => match self.cluster.filter_host_event(&self.host) {
                Some(event) => {
                    match event {
                        io::NetEvent::Focus(focus) => {
                            self.net.send_to_all(&[event]);
                        },
                        event => {
                            let addr = self.cluster.focused_screen().default_route();
                            self.net.send_to(&[event], addr);
                        }
                    }

[3.9020]

[2.671]

            State::Connected => match self.cluster.process_host_event(&self.host, event) {
                Some(event) => match event {
                    // Global events
                    io::NetEvent::Focus(focus) => {
                        self.net.send_to_all(&[event]);
                    },
                    // Focused events
                    event => {
                        let addr = self.cluster.focused_screen().default_route();
                        self.net.send_to(&[event], addr);
                    },

Replacement in src/elemeld.rs at line 84 [3.8294]

B:BD[3.9252] → [3.9252:9512]

B:BD[3.9512] → [6.1072:1125]

B:BD[6.1125] → [2.691:788]

∅:D[2.788] → [3.9666:9800]

B:BD[3.9666] → [3.9666:9800]

B:BD[3.9800] → [6.1126:1193]

∅:D[7.1151] → [3.9856:9934]

∅:D[6.1193] → [3.9856:9934]

B:BD[3.9856] → [3.9856:9934]

    pub fn net_event(&mut self) {
        match self.net.recv_from() {
            Some((events, addr)) => for event in events {
                match event {
                    // Initialization events
                    io::NetEvent::Connect(cluster) => {
                        self.cluster.merge(cluster);
                        self.net.send_to(&[io::NetEvent::Cluster(self.cluster.clone())], &addr);
                        self.state = State::Connected;
                    },
                    io::NetEvent::Cluster(cluster) => {
                        self.cluster.replace(&self.host, cluster);
                        self.state = State::Connected;
                    },

[3.9252]

[3.9934]

    pub fn net_event(&mut self, event: io::NetEvent, addr: net::SocketAddr) {
        match event {
            // Initialization events
            io::NetEvent::Connect(cluster) => {
                self.cluster.merge(cluster);
                self.net.send_to(&[io::NetEvent::Cluster(self.cluster.clone())], &addr);
                self.state = State::Connected;
            },
            io::NetEvent::Cluster(cluster) => {
                self.cluster.replace(&self.host, cluster);
                self.state = State::Connected;
            },
            // Global events
            io::NetEvent::Focus(focus) => {
                self.cluster.refocus(&self.host, focus);
            },
            // Focued events
            event => match self.cluster.process_net_event(event) {
                Some(event) => { self.host.send_event(event); },
                None => (),
            },
        }
    }
}

Replacement in src/elemeld.rs at line 109 [3.8294]

B:BD[3.9935] → [3.9935:9972]

B:BD[3.9972] → [5.2683:2800]

∅:D[5.2800] → [3.10302:10325]

B:BD[3.10302] → [3.10302:10325]

B:BD[3.10325] → [4.2554:2701]

                    // Global events
                    io::NetEvent::Focus(focus) => {
                        self.cluster.refocus(&self.host, focus);
                    },
                    event => match self.cluster.filter_net_event(event) {
                        Some(event) => { self.host.send_event(event); },

[3.9935]

[4.2701]

impl<'a> mio::Handler for Elemeld<'a> {
    type Timeout = ();
    type Message = ();
    fn ready(&mut self,
             event_loop: &mut mio::EventLoop<Self>,
             token: mio::Token, events: mio::EventSet)
    {
        match token {
            HOST_EVENT => {
                if events.is_readable() {
                    match self.host.recv_event() {
                        Some(event) => self.host_event(event),

Replacement in src/elemeld.rs at line 123 [3.8294]
B:BD[4.2737] → [4.2737:2760]
```
                    },
```
[4.2737]
[3.10573]
```
                    }
```

Replacement in src/elemeld.rs at line 126 [3.8294]

B:BD[3.10606] → [3.10606:10640]

            None => (),
        }

[3.10606]

[3.10640]

            NET_EVENT => {
                if events.is_readable() {
                    match self.net.recv_from() {
                        Some((events, addr)) => for event in events {
                            self.net_event(event, addr);
                        },
                        None => (),
                    }
                }

Replacement in src/elemeld.rs at line 136 [3.8294]

B:BD[3.10641] → [3.10641:10789]

B:BD[3.10789] → [2.789:834]

        match self.state {
            State::Connecting => {
                self.net.send_to_all(&[io::NetEvent::Connect(self.cluster.clone())]);
                self.state = State::Waiting;

[3.10641]

[3.10832]

                if events.is_writable() {
                    match self.state {
                        State::Connecting => {
                            self.net.send_to_all(&[io::NetEvent::Connect(self.cluster.clone())]);
                            self.state = State::Waiting;
                            event_loop.reregister(&self.net,
                                                  NET_EVENT,
                                                  mio::EventSet::readable(),
                                                  mio::PollOpt::level()).unwrap();
                        },
                        _ => ()
                    }
                }

Replacement in src/elemeld.rs at line 150 [3.8294]
B:BD[3.10847] → [3.10847:10867]
```
            _ => ()
```
[3.10847]
[3.10867]
```
            _ => unreachable!(),
```
Insertion in src/ip.rs at line 2 [3.11607]
[3.11638]
[3.11638]
```
use elemeld::Config;
```
Replacement in src/ip.rs at line 7 [3.11607]
B:BD[3.11665] → [3.11665:11731]
```
use std::str;
use std::net::{SocketAddr, SocketAddrV4, Ipv4Addr};
```
[3.11665]
[3.11731]
```
use std::{net, str};
```

Replacement in src/ip.rs at line 10 [3.11607]

B:BD[3.11753] → [3.11753:11798]

pub struct IpInterface {
    config: Config,

[3.11753]

[3.11798]

pub struct IpInterface<'a> {
    config: &'a Config,

Replacement in src/ip.rs at line 17 [3.11607]

B:BD[3.11893] → [3.11893:12060]

pub struct Config {
    pub server_addr: Ipv4Addr,
    pub multicast_addr: Ipv4Addr,
    pub port: u16
}
impl IpInterface {
    pub fn open(config: Config) -> Self {

[3.11893]

[3.12060]

impl<'a> IpInterface<'a> {
    pub fn open(config: &'a Config) -> Self {

Replacement in src/ip.rs at line 21 [3.11607]

B:BD[3.12168] → [3.12168:12370]

        socket.join_multicast(&mio::IpAddr::V4(config.multicast_addr)).unwrap();
        socket.bind(&SocketAddr::V4(
            SocketAddrV4::new(config.server_addr, config.port)
        )).unwrap();

[3.12168]

[3.12370]

        socket.join_multicast(&config.multicast_addr).unwrap();
        socket.bind(&match config.server_addr {
            mio::IpAddr::V4(addr) => net::SocketAddr::V4((net::SocketAddrV4::new(addr, config.port))),
            mio::IpAddr::V6(addr) => net::SocketAddr::V6((net::SocketAddrV6::new(addr, config.port, 0, 0))),
        }).unwrap();

Replacement in src/ip.rs at line 36 [3.11607]

B:BD[3.12545] → [3.12545:12666]

impl NetInterface for IpInterface {
    fn send_to(&self, events: &[io::NetEvent], addr: &SocketAddr) -> Option<usize> {

[3.12545]

[3.12666]

impl<'a> NetInterface for IpInterface<'a> {
    fn send_to(&self, events: &[io::NetEvent], addr: &net::SocketAddr) -> Option<usize> {

Replacement in src/ip.rs at line 54 [3.11607]

B:BD[3.13186] → [3.13186:13342]

        let multicast_addr = SocketAddr::V4(SocketAddrV4::new(self.config.multicast_addr, self.config.port));
        self.send_to(events, &multicast_addr)

[3.13186]

[3.13342]

        let addr = match self.config.multicast_addr {
            mio::IpAddr::V4(addr) => net::SocketAddr::V4((net::SocketAddrV4::new(addr, self.config.port))),
            mio::IpAddr::V6(addr) => net::SocketAddr::V6((net::SocketAddrV6::new(addr, self.config.port, 0, 0))),
        };
        self.send_to(events, &addr)

Replacement in src/ip.rs at line 61 [3.11607]

B:BD[3.13349] → [3.13349:13418]

    fn recv_from(&self) -> Option<(Vec<io::NetEvent>, SocketAddr)> {

[3.13349]

[3.13418]

    fn recv_from(&self) -> Option<(Vec<io::NetEvent>, net::SocketAddr)> {

Replacement in src/ip.rs at line 91 [3.11607]
B:BD[3.14330] → [3.14330:14366]
```
impl mio::Evented for IpInterface {
```
[3.14330]
[3.14366]
```
impl<'a> mio::Evented for IpInterface<'a> {
```
Deletion in src/main.rs at line 27 [8.10002]
∅:D[4.2853] → [3.14963:14964]
B:BD[3.14963] → [3.14963:14964]
B:BD[8.10164] → [3.14997:15073]
```
use elemeld::Elemeld;
use x11::X11Interface;
use ip::{IpInterface, Config};
```

Replacement in src/main.rs at line 28 [8.10002]

B:BD[3.15074] → [4.2854:2945]

const HOST_EVENT: mio::Token = mio::Token(0);
const NET_EVENT: mio::Token = mio::Token(1);

[3.15074]

[9.840]

use elemeld::{Elemeld, Config};
use std::net;

Replacement in src/main.rs at line 32 [8.10002]

B:BD[8.10353] → [4.2946:3003]

∅:D[4.3003] → [3.15112:15178]

B:BD[8.10469] → [3.15112:15178]

B:BD[3.15178] → [4.3004:3119]

    let mut event_loop = mio::EventLoop::new().unwrap();
    let mut manager = EventManager::new(&mut event_loop, Config {
        server_addr: mio::Ipv4Addr::new(0, 0, 0, 0),
        multicast_addr: mio::Ipv4Addr::new(239, 255, 80, 80),

[8.10353]

[10.106]

    let config = Config {
        server_addr: mio::IpAddr::V4(net::Ipv4Addr::new(0, 0, 0, 0)),
        multicast_addr: mio::IpAddr::V4(net::Ipv4Addr::new(239, 255, 80, 80)),

Replacement in src/main.rs at line 36 [8.10002]

B:BD[10.126] → [10.126:134]

B:BD[8.10572] → [8.10572:10573]

B:BD[8.10573] → [3.15284:15327]

∅:D[11.59] → [8.10835:10838]

∅:D[3.15327] → [8.10835:10838]

∅:D[12.49] → [8.10835:10838]

∅:D[9.976] → [8.10835:10838]

B:BD[8.10835] → [8.10835:10838]

B:BD[8.10838] → [3.15328:15399]

∅:D[3.15399] → [10.207:210]

B:BD[10.207] → [10.207:210]

B:BD[10.210] → [3.15400:15420]

B:BD[3.15420] → [4.3120:3196]

∅:D[4.3196] → [3.15421:15494]

B:BD[10.282] → [3.15421:15494]

∅:D[3.15494] → [13.1148:1183]

B:BD[13.1148] → [13.1148:1183]

B:BD[13.1183] → [3.15495:15535]

B:BD[3.15535] → [4.3197:3313]

∅:D[4.3313] → [8.11720:11721]

B:BD[8.11720] → [8.11720:11721]

B:BD[8.11721] → [3.15536:15612]

∅:D[3.15612] → [13.1374:1408]

B:BD[8.12035] → [13.1374:1408]

∅:D[13.1408] → [9.1073:1112]

B:BD[8.12076] → [9.1073:1112]

B:BD[9.1112] → [4.3314:3486]

    });
    event_loop.run(&mut manager).unwrap();
}
struct EventManager {
    elemeld: Elemeld<X11Interface, IpInterface>,
}
impl EventManager {
    fn new(event_loop: &mut mio::EventLoop<Self>, config: Config) -> Self {
        // Setup host interface
        let host = X11Interface::open();
        event_loop.register(&host,
                            HOST_EVENT,
                            mio::EventSet::readable(),
                            mio::PollOpt::level()).unwrap();
        // Setup net interface
        let net = IpInterface::open(config);
        event_loop.register(&net,
                            NET_EVENT,
                            mio::EventSet::readable() |
                            mio::EventSet::writable(),
                            mio::PollOpt::level()).unwrap();

[10.126]

[11.496]

};

Replacement in src/main.rs at line 38 [8.10002]

B:BD[11.497] → [3.15687:15745]

∅:D[14.771] → [8.14592:14598]

∅:D[15.1269] → [8.14592:14598]

∅:D[3.15745] → [8.14592:14598]

B:BD[8.14592] → [8.14592:14598]

        EventManager { elemeld: Elemeld::new(host, net) }
    }

[11.497]

[8.14598]

    let mut event_loop = mio::EventLoop::new().unwrap();
    let mut elemeld = Elemeld::new(&mut event_loop, &config);
    event_loop.run(&mut elemeld).unwrap();

Deletion in src/main.rs at line 42 [8.10002]

B:BD[8.14600] → [8.14600:14601]

B:BD[8.14601] → [4.3487:3524]

∅:D[3.15778] → [8.14627:14674]

∅:D[4.3524] → [8.14627:14674]

B:BD[8.14627] → [8.14627:14674]

B:BD[8.14674] → [4.3525:3662]

∅:D[4.3662] → [8.14797:14819]

B:BD[8.14797] → [8.14797:14819]

B:BD[8.14819] → [3.15779:15883]

∅:D[3.15883] → [8.16378:16429]

B:BD[8.16378] → [8.16378:16429]


impl mio::Handler for EventManager {
    type Timeout = ();
    type Message = ();
    fn ready(&mut self,
             event_loop: &mut mio::EventLoop<Self>,
             token: mio::Token, events: mio::EventSet)
    {
        match token {
            HOST_EVENT => self.elemeld.host_event(),
            NET_EVENT => self.elemeld.net_event(),
            _ => unreachable!(),
        }
    }
}