daxvena/elemeld - Change YYUB6HZYSVQSCO7DGF6ETPAXTMG6SG2RQQXLP73NKPLDMZEC3PGAC

Removed buggy/unused network features

Created by daxvena on March 16, 2016

YYUB6HZYSVQSCO7DGF6ETPAXTMG6SG2RQQXLP73NKPLDMZEC3PGAC

Dependencies

In channels

main

Change contents

Replacement in src/cluster.rs at line 1 [4.13]
B:BD[4.13] → [4.14:22]
B:BD[4.22] → [5.0:21]
```
use io;
use elemeld::Config;
```
[4.13]
[6.23]
```
use io::*;
```
Replacement in src/cluster.rs at line 5 [4.13]
B:BD[4.56] → [4.56:70]
```
use std::net;
```
[4.56]
[4.70]
```
use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6, IpAddr};
```
Deletion in src/cluster.rs at line 25 [4.13]
B:BD[7.27] → [7.27:54]
```
        use std::io::Read;
```

Replacement in src/cluster.rs at line 56 [4.13]

B:BD[4.472] → [5.22:122]

∅:D[5.122] → [4.549:584]

B:BD[4.549] → [4.549:584]

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

[4.472]

[4.584]

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

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

B:BD[5.145] → [5.145:191]

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

[5.145]

[4.676]

            HostEvent::Motion(event) => {

Replacement in src/cluster.rs at line 71 [4.13]

B:BD[8.637] → [8.637:690]

                    Some(io::NetEvent::Focus(focus))

[8.637]

[5.192]

                    Some(NetEvent::Focus(focus))

Replacement in src/cluster.rs at line 77 [4.13]

B:BD[4.1227] → [4.1227:1403]

                        io::HostEvent::Button(event) => Some(io::NetEvent::Button(event)),
                        io::HostEvent::Key(event) => Some(io::NetEvent::Key(event)),

[4.1227]

[4.1403]

                        HostEvent::Button(event) => Some(NetEvent::Button(event)),
                        HostEvent::Key(event) => Some(NetEvent::Key(event)),

Replacement in src/cluster.rs at line 86 [4.13]

B:BD[4.1585] → [5.311:399]

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

[4.1585]

[4.1672]

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

Replacement in src/cluster.rs at line 89 [4.13]

B:BD[4.1734] → [4.1734:1894]

                io::NetEvent::Button(event) => Some(io::HostEvent::Button(event)),
                io::NetEvent::Key(event) => Some(io::HostEvent::Key(event)),

[4.1734]

[4.1894]

                NetEvent::Button(event) => Some(HostEvent::Button(event)),
                NetEvent::Key(event) => Some(HostEvent::Key(event)),

Replacement in src/cluster.rs at line 120 [4.13]
B:BD[8.946] → [8.946:975]
```
        H: io::HostInterface
```
[8.946]
[8.975]
```
        H: HostInterface
```
Replacement in src/cluster.rs at line 127 [4.13]
∅:D[9.467] → [4.2176:2205]
∅:D[8.1174] → [4.2176:2205]
B:BD[4.2176] → [4.2176:2205]
```
        H: io::HostInterface
```
[8.1174]
[4.2205]
```
        H: HostInterface
```

Replacement in src/cluster.rs at line 136 [4.13]

B:BD[6.294] → [6.294:366]

            host.send_event(io::HostEvent::Position(io::PositionEvent {

[6.294]

[8.1226]

            host.send_event(HostEvent::Position(PositionEvent {

Replacement in src/cluster.rs at line 296 [4.13]
∅:D[10.697] → [9.829:858]
B:BD[9.829] → [9.829:858]
```
        H: io::HostInterface
```
[10.697]
[9.858]
```
        H: HostInterface
```

Replacement in src/cluster.rs at line 323 [4.13]

B:BD[6.1750] → [6.1750:1795]

                    net::IpAddr::V4(addr) =>

[6.1750]

[6.1795]

                    IpAddr::V4(addr) =>

Replacement in src/cluster.rs at line 325 [4.13]

B:BD[6.1844] → [6.1844:1934]

                            Some(net::SocketAddr::V4(net::SocketAddrV4::new(addr, port)))

[6.1844]

[6.1934]

                            Some(SocketAddr::V4(SocketAddrV4::new(addr, port)))

Replacement in src/cluster.rs at line 327 [4.13]

B:BD[6.1975] → [6.1975:2020]

                    net::IpAddr::V6(addr) =>

[6.1975]

[6.2020]

                    IpAddr::V6(addr) =>

Replacement in src/cluster.rs at line 329 [4.13]

B:BD[6.2069] → [6.2069:2165]

                            Some(net::SocketAddr::V6(net::SocketAddrV6::new(addr, port, 0, 0)))

[6.2069]

[6.2165]

                            Some(SocketAddr::V6(SocketAddrV6::new(addr, port, 0, 0)))

Replacement in src/cluster.rs at line 345 [4.13]

B:BD[11.130] → [11.130:184]

    pub fn default_route(&self) -> &net::SocketAddr {

[11.130]

[11.184]

    pub fn default_route(&self) -> &SocketAddr {

Replacement in src/cluster.rs at line 351 [4.13]
∅:D[10.942] → [6.2317:2347]
B:BD[4.7046] → [6.2317:2347]
```
struct Addr(net::SocketAddr);
```
[10.942]
[4.7082]
```
struct Addr(SocketAddr);
```

Replacement in src/cluster.rs at line 372 [4.13]

B:BD[4.7711] → [4.7711:7766]

                match val.parse::<net::SocketAddr>() {

[4.7711]

[6.2450]

                match val.parse::<SocketAddr>() {

Replacement in src/elemeld.rs at line 1 [4.8294]
B:BD[4.8294] → [5.400:445]
```
use io::{self, HostInterface, NetInterface};
```
[4.8294]
[4.8303]
```
use io::*;
```
Replacement in src/elemeld.rs at line 6 [4.8294]
B:BD[4.8326] → [5.491:514]
```
use mio;
use std::net;
```
[4.8326]
[5.514]
```
use mio::*;
```

Replacement in src/elemeld.rs at line 8 [4.8294]

B:BD[5.515] → [5.515:606]

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

[5.515]

[5.606]

use std::io;
use std::net::SocketAddr;
const HOST_EVENT: Token = Token(0);
const NET_EVENT: Token = Token(1);

Replacement in src/elemeld.rs at line 23 [4.8294]

B:BD[5.746] → [5.746:817]

    pub server_addr: mio::IpAddr,
    pub multicast_addr: mio::IpAddr,

[5.746]

[5.817]

    pub server_addr: IpAddr,
    pub multicast_addr: IpAddr,

Replacement in src/elemeld.rs at line 36 [4.8294]

B:BD[5.862] → [5.862:946]

    pub fn new(event_loop: &mut mio::EventLoop<Self>, config: &'a Config) -> Self {

[5.862]

[5.946]

    pub fn new(event_loop: &mut EventLoop<Self>, config: &'a Config) -> io::Result<Self> {

Replacement in src/elemeld.rs at line 39 [4.8294]

B:BD[5.1019] → [5.1019:1210]

        event_loop.register(&host,
                            HOST_EVENT,
                            mio::EventSet::readable(),
                            mio::PollOpt::level()).unwrap();

[5.1019]

[5.1210]

        try!(event_loop.register(&host,
                                 HOST_EVENT,
                                 EventSet::readable(),
                                 PollOpt::level()));

Replacement in src/elemeld.rs at line 50 [4.8294]

B:BD[5.1326] → [5.1326:1618]

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

[5.1326]

[5.1618]

        let net = try!(IpInterface::open(config));
        try!(event_loop.register(&net,
                                 NET_EVENT,
                                 EventSet::readable() |
                                 EventSet::writable(),
                                 PollOpt::oneshot()));

Replacement in src/elemeld.rs at line 57 [4.8294]
∅:D[5.1619] → [4.8783:8801]
B:BD[4.8783] → [4.8783:8801]
```
        Elemeld {
```
[5.1619]
[5.1620]
```
        Ok(Elemeld {
```
Replacement in src/elemeld.rs at line 63 [4.8294]
B:BD[4.8941] → [4.8941:8951]
```
        }
```
[4.8885]
[4.8951]
```
        })
```

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

B:BD[4.8958] → [5.1679:1736]

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

[4.8958]

[4.8993]

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

Replacement in src/elemeld.rs at line 71 [4.8294]

B:BD[5.1910] → [5.1910:2018]

                    io::NetEvent::Focus(focus) => {
                        self.net.send_to_all(&[event]);

[5.1910]

[5.2018]

                    NetEvent::Focus(focus) => {
                        match self.net.send_to_all(NetEvent::Focus(focus)) {
                            Err(e) => {
                                error!("Failed to send event to cluster: {}", e);
                                self.state = State::Waiting;
                            }
                            _ => (),
                        };

Replacement in src/elemeld.rs at line 83 [4.8294]

B:BD[5.2192] → [5.2192:2250]

                        self.net.send_to(&[event], addr);

[5.2192]

[5.2250]

                        match self.net.send_to(event, addr) {
                            Err(e) => error!("Failed to send event to {}: {}", addr, e),
                            _ => (),
                        };

Replacement in src/elemeld.rs at line 95 [4.8294]

B:BD[4.9252] → [5.2274:2352]

    pub fn net_event(&mut self, event: io::NetEvent, addr: net::SocketAddr) {

[4.9252]

[5.2352]

    pub fn net_event(&mut self, event: NetEvent, addr: &SocketAddr) {

Replacement in src/elemeld.rs at line 98 [4.8294]

B:BD[5.2411] → [5.2411:2459]

            io::NetEvent::Connect(cluster) => {

[5.2411]

[5.2459]

            NetEvent::Connect(cluster) => {

Replacement in src/elemeld.rs at line 100 [4.8294]

B:BD[5.2504] → [5.2504:2640]

                self.net.send_to(&[io::NetEvent::Cluster(self.cluster.clone())], &addr);
                self.state = State::Connected;

[5.2504]

[5.2640]

                match self.net.send_to(NetEvent::Cluster(self.cluster.clone()), addr) {
                    Ok(_) => self.state = State::Connected,
                    Err(err) => error!("Failed to connect: {}", err),
                };

Replacement in src/elemeld.rs at line 105 [4.8294]

B:BD[5.2655] → [5.2655:2703]

            io::NetEvent::Cluster(cluster) => {

[5.2655]

[5.2703]

            NetEvent::Cluster(cluster) => {

Replacement in src/elemeld.rs at line 110 [4.8294]

B:BD[5.2853] → [5.2853:2897]

            io::NetEvent::Focus(focus) => {

[5.2853]

[5.2897]

            NetEvent::Focus(focus) => {

Replacement in src/elemeld.rs at line 122 [4.8294]
B:BD[4.9935] → [5.3192:3232]
```
impl<'a> mio::Handler for Elemeld<'a> {
```
[4.9935]
[5.3232]
```
impl<'a> Handler for Elemeld<'a> {
```

Replacement in src/elemeld.rs at line 127 [4.8294]

B:BD[5.3303] → [5.3303:3410]

             event_loop: &mut mio::EventLoop<Self>,
             token: mio::Token, events: mio::EventSet)

[5.3303]

[5.3410]

             event_loop: &mut EventLoop<Self>,
             token: Token, events: EventSet)

Replacement in src/elemeld.rs at line 147 [4.8294]

B:BD[5.3764] → [5.3764:3954]

                        Some((events, addr)) => for event in events {
                            self.net_event(event, addr);
                        },
                        None => (),

[5.3764]

[5.3954]

                        Ok(Some((event, addr))) => self.net_event(event, &addr),
                        Ok(None) => (),
                        Err(err) => error!("Failed to receive event: {}", err),

Replacement in src/elemeld.rs at line 156 [4.8294]

B:BD[5.4123] → [5.4123:4221]

                            self.net.send_to_all(&[io::NetEvent::Connect(self.cluster.clone())]);

[5.4123]

[5.4221]

                            match self.net.send_to_all(NetEvent::Connect(self.cluster.clone())) {
                                Err(err) => error!("Failed to connect: {}", err),
                                _ => (),
                            };

Replacement in src/elemeld.rs at line 164 [4.8294]

B:BD[5.4400] → [5.4400:4560]

                                                  mio::EventSet::readable(),
                                                  mio::PollOpt::level()).unwrap();

[5.4400]

[5.4560]

                                                  EventSet::readable(),
                                                  PollOpt::level()).unwrap();

Replacement in src/io.rs at line 1 [12.11]
B:BD[12.11] → [4.10886:10899]
```
use cluster;
```
[12.11]
[4.10899]
```
use cluster::{Cluster, Focus};
use std::io;
```

Replacement in src/io.rs at line 18 [12.11]

B:BD[4.11044] → [4.11044:11253]

    fn send_to(&self, events: &[NetEvent], addr: &SocketAddr) -> Option<usize>;
    fn send_to_all(&self, events: &[NetEvent]) -> Option<usize>;
    fn recv_from(&self) -> Option<(Vec<NetEvent>, SocketAddr)>;

[4.11044]

[13.356]

    fn send_to(&self, event: NetEvent, addr: &SocketAddr) -> io::Result<Option<()>>;
    fn send_to_all(&self, event: NetEvent) -> io::Result<Option<()>>;
    fn recv_from(&self) -> io::Result<Option<(NetEvent, SocketAddr)>>;

Replacement in src/io.rs at line 33 [12.11]

B:BD[4.11296] → [4.11296:11358]

B:BD[4.11358] → [8.2801:2828]

    Connect(cluster::Cluster),
    Cluster(cluster::Cluster),
    Focus(cluster::Focus),

[4.11296]

[4.11400]

    Connect(Cluster),
    Cluster(Cluster),
    Focus(Focus),

Replacement in src/ip.rs at line 1 [4.11607]
B:BD[4.11607] → [4.11608:11638]
```
use io::{self, NetInterface};
```
[4.11607]
[5.4694]
```
use io::*;
```
Replacement in src/ip.rs at line 4 [4.11607]
B:BD[4.11639] → [4.11639:11648]
```
use mio;
```
[4.11639]
[4.11648]
```
use mio::*;
use mio::udp::UdpSocket;
```
Replacement in src/ip.rs at line 8 [4.11607]
B:BD[4.11665] → [5.4716:4737]
∅:D[5.4737] → [4.11731:11752]
B:BD[4.11731] → [4.11731:11752]
```
use std::{net, str};
use std::cell::Cell;
```
[4.11665]
[4.11752]
```
use std::io;
use std::net::{SocketAddr, SocketAddrV4, SocketAddrV6};
```

Replacement in src/ip.rs at line 13 [4.11607]

∅:D[5.4791] → [4.11798:11890]

B:BD[4.11798] → [4.11798:11890]

    socket: mio::udp::UdpSocket,
    out_packets: Cell<usize>,
    in_packets: Cell<usize>,

[5.4791]

[4.11890]

    socket: udp::UdpSocket,

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

B:BD[5.4819] → [5.4819:4865]

∅:D[5.4865] → [4.12060:12168]

B:BD[4.12060] → [4.12060:12168]

B:BD[4.12168] → [5.4866:5211]

    pub fn open(config: &'a Config) -> Self {
        let socket = mio::udp::UdpSocket::v4().unwrap();
        socket.set_multicast_loop(false).unwrap();
        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();

[5.4819]

[4.12370]

    pub fn open(config: &'a Config) -> io::Result<Self> {
        let socket = try!(UdpSocket::v4());
        try!(socket.set_multicast_loop(false));
        try!(socket.join_multicast(&config.multicast_addr));
        try!(socket.bind(&match config.server_addr {
            IpAddr::V4(addr) => SocketAddr::V4((SocketAddrV4::new(addr, config.port))),
            IpAddr::V6(addr) => SocketAddr::V6((SocketAddrV6::new(addr, config.port, 0, 0))),
        }));

Replacement in src/ip.rs at line 26 [4.11607]
B:BD[4.12371] → [4.12371:12393]
```
        IpInterface {
```
[4.12371]
[4.12393]
```
        Ok(IpInterface {
```

Replacement in src/ip.rs at line 29 [4.11607]

B:BD[4.12449] → [4.12449:12536]

            out_packets: Cell::new(0),
            in_packets: Cell::new(0),
        }

[4.12449]

[4.12536]

})

Replacement in src/ip.rs at line 34 [4.11607]

B:BD[5.5256] → [5.5256:5346]

∅:D[5.5346] → [4.12666:12772]

B:BD[4.12666] → [4.12666:12772]

B:BD[4.12772] → [3.1747:1786]

∅:D[11.876] → [4.12804:13010]

∅:D[3.1786] → [4.12804:13010]

B:BD[4.12804] → [4.12804:13010]

B:BD[4.13010] → [3.1787:1838]

∅:D[3.1838] → [4.13063:13099]

B:BD[4.13063] → [4.13063:13099]

    fn send_to(&self, events: &[io::NetEvent], addr: &net::SocketAddr) -> Option<usize> {
        let id = self.out_packets.get();
        let msg = serde_json::to_string(&(id, events)).unwrap();
        debug!("=> {} {}", addr, msg);
        match self.socket.send_to(msg.as_bytes(), &addr).unwrap() {
            Some(size) => {
                self.out_packets.set(id + 1);
                Some(size)
            },
            None => {
                error!("Failed to send: {}", msg);
                None
            },

[5.5256]

[4.13099]

    fn send_to(&self, event: NetEvent, addr: &SocketAddr) -> io::Result<Option<()>> {
        debug!("=> {} <= {:#?}", addr, event);
        let packet = serde_json::to_vec(&event).unwrap();
        match self.socket.send_to(&packet, addr) {
            Ok(Some(_)) => Ok(Some(())),
            Ok(None) => Err(io::Error::new(
                io::ErrorKind::WouldBlock,
                "The OS socket buffer is probably full"
            )),
            Err(err) => Err(err),

Replacement in src/ip.rs at line 47 [4.11607]

B:BD[4.13116] → [4.13116:13186]

    fn send_to_all(&self, events: &[io::NetEvent]) -> Option<usize> {

[4.13116]

[5.5347]

    fn send_to_all(&self, event: NetEvent) -> io::Result<Option<()>> {

Replacement in src/ip.rs at line 49 [4.11607]

B:BD[5.5401] → [5.5401:5623]

            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))),

[5.5401]

[5.5623]

            IpAddr::V4(addr) => SocketAddr::V4((SocketAddrV4::new(addr, self.config.port))),
            IpAddr::V6(addr) => SocketAddr::V6((SocketAddrV6::new(addr, self.config.port, 0, 0))),

Replacement in src/ip.rs at line 52 [4.11607]

B:BD[5.5634] → [5.5634:5670]

        self.send_to(events, &addr)

[5.5634]

[4.13342]

        
        self.send_to(event, &addr)

Replacement in src/ip.rs at line 56 [4.11607]

B:BD[4.13349] → [5.5671:5745]

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

[4.13349]

[4.13418]

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

Replacement in src/ip.rs at line 58 [4.11607]

B:BD[4.13451] → [4.13451:13607]

B:BD[4.13607] → [3.1839:1886]

∅:D[11.926] → [4.13647:13858]

∅:D[3.1886] → [4.13647:13858]

B:BD[4.13647] → [4.13647:13858]

B:BD[4.13858] → [3.1887:1938]

∅:D[3.1938] → [4.13912:13979]

B:BD[4.13912] → [4.13912:13979]

B:BD[4.13979] → [3.1939:2008]

∅:D[3.2008] → [4.14051:14179]

B:BD[4.14051] → [4.14051:14179]

        match self.socket.recv_from(&mut buf).unwrap() {
            Some((len, addr)) => {
                let msg = str::from_utf8(&buf[..len]).unwrap();
                debug!("<= {} {}", addr, msg);
                
                let (id, events): (usize, Vec<io::NetEvent>) = serde_json::from_str(msg).unwrap();
                let expected_id = self.in_packets.get();
                if id < expected_id {
                    warn!("^ out of sync packet");
                } else {
                    if id > expected_id {
                        warn!("^ lost {} packets", id - expected_id)
                    }
                    self.in_packets.set(id + 1);
                }
                Some((events, addr))

[4.13451]

[4.14179]

        match self.socket.recv_from(&mut buf) {
            Ok(Some((len, addr))) => match serde_json::from_slice(&buf[..len]) {
                Ok(event) => {
                    debug!("<= {} => {:#?}", addr, event);
                    Ok(Some((event, addr)))
                },
                Err(err) => Err(io::Error::new(io::ErrorKind::InvalidData, err)),

Replacement in src/ip.rs at line 66 [4.11607]

B:BD[4.14194] → [4.14194:14220]

            None => None,

[4.14194]

[4.14220]

            Ok(None) => Ok(None),
            Err(err) => Err(err),

Replacement in src/ip.rs at line 76 [4.11607]

B:BD[4.14330] → [5.5746:5790]

∅:D[5.5790] → [4.14366:14510]

B:BD[4.14366] → [4.14366:14510]

impl<'a> mio::Evented for IpInterface<'a> {
    fn register(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {

[4.14330]

[4.14510]

impl<'a> Evented for IpInterface<'a> {
    fn register(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {

Replacement in src/ip.rs at line 81 [4.11607]

B:BD[4.14579] → [4.14579:14725]

    fn reregister(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {

[4.14579]

[4.14725]

    fn reregister(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {

Replacement in src/ip.rs at line 85 [4.11607]

B:BD[4.14796] → [4.14796:14878]

    fn deregister(&self, selector: &mut mio::Selector) -> ::std::io::Result<()> {

[4.14796]

[4.14878]

    fn deregister(&self, selector: &mut Selector) -> io::Result<()> {

Replacement in src/main.rs at line 33 [14.10002]
B:BD[5.5823] → [5.5823:5837]
```
use std::net;
```
[5.5823]
[15.840]
```
use mio::{IpAddr, EventLoop};
use std::net::Ipv4Addr;
```

Replacement in src/main.rs at line 40 [14.10002]

B:BD[5.5864] → [5.5864:6013]

        server_addr: mio::IpAddr::V4(net::Ipv4Addr::new(0, 0, 0, 0)),
        multicast_addr: mio::IpAddr::V4(net::Ipv4Addr::new(239, 255, 80, 80)),

[5.5864]

[16.106]

        server_addr: IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
        multicast_addr: IpAddr::V4(Ipv4Addr::new(239, 255, 80, 80)),

Replacement in src/main.rs at line 45 [14.10002]

B:BD[17.497] → [5.6022:6141]

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

[17.497]

[5.6141]

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

Replacement in src/x11.rs at line 3 [14.308]
B:BD[12.1837] → [13.4474:4505]
```
use io::{self, HostInterface};
```
[12.1837]
[14.343]
```
use io::*;
```
Replacement in src/x11.rs at line 10 [14.308]
B:BD[13.4542] → [13.4542:4551]
```
use mio;
```
[13.4542]
[14.1999]
```
use mio::*;
```
Replacement in src/x11.rs at line 12 [14.308]
B:BD[14.2000] → [4.15884:15905]
```
use std::{ptr, mem};
```
[14.2000]
[13.4601]
```
use std::{io, ptr, mem};
```

Replacement in src/x11.rs at line 91 [14.308]

B:BD[14.3118] → [4.15989:16084]

    fn recv_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<io::HostEvent> {

[14.3118]

[13.6054]

    fn recv_generic_event(&self, cookie: xlib::XGenericEventCookie) -> Option<HostEvent> {

Replacement in src/x11.rs at line 104 [14.308]

B:BD[13.6542] → [13.6542:6614]

            self.send_position_event(io::PositionEvent { x: x, y: y });

[13.6542]

[13.6614]

            self.send_position_event(PositionEvent { x: x, y: y });

Replacement in src/x11.rs at line 107 [14.308]

B:BD[18.1621] → [4.16085:16157]

        Some(io::HostEvent::Motion(io::MotionEvent { dx: dx, dy: dy }))

[18.1621]

[18.1793]

        Some(HostEvent::Motion(MotionEvent { dx: dx, dy: dy }))

Replacement in src/x11.rs at line 110 [14.308]

B:BD[18.1800] → [4.16158:16257]

B:BD[14.3737] → [4.16258:16311]

    fn recv_button_event(&self, event: xlib::XButtonEvent, state: bool) -> Option<io::HostEvent> {
        Some(io::HostEvent::Button(io::ButtonEvent {

[18.1800]

[2.22]

    fn recv_button_event(&self, event: xlib::XButtonEvent, state: bool) -> Option<HostEvent> {
        Some(HostEvent::Button(ButtonEvent {

Replacement in src/x11.rs at line 117 [14.308]

B:BD[14.6446] → [4.16312:16405]

    fn recv_key_event(&self, event: xlib::XKeyEvent, state: bool) -> Option<io::HostEvent> {

[14.6446]

[13.7313]

    fn recv_key_event(&self, event: xlib::XKeyEvent, state: bool) -> Option<HostEvent> {

Replacement in src/x11.rs at line 119 [14.308]

B:BD[13.7413] → [4.16406:16453]

        Some(io::HostEvent::Key(io::KeyEvent {

[13.7413]

[19.19]

        Some(HostEvent::Key(KeyEvent {

Replacement in src/x11.rs at line 125 [14.308]

B:BD[18.1808] → [4.16454:16516]

    fn send_position_event(&self, event: io::PositionEvent) {

[18.1808]

[13.10106]

    fn send_position_event(&self, event: PositionEvent) {

Replacement in src/x11.rs at line 133 [14.308]

B:BD[18.1932] → [4.16517:16575]

    fn send_motion_event(&self, event: io::MotionEvent) {

[18.1932]

[13.10390]

    fn send_motion_event(&self, event: MotionEvent) {

Replacement in src/x11.rs at line 142 [14.308]

B:BD[14.7570] → [4.16576:16634]

    fn send_button_event(&self, event: io::ButtonEvent) {

[14.7570]

[13.10942]

    fn send_button_event(&self, event: ButtonEvent) {

Replacement in src/x11.rs at line 149 [14.308]

B:BD[14.8295] → [4.16635:16687]

    fn send_key_event(&self, event: io::KeyEvent) {

[14.8295]

[13.13426]

    fn send_key_event(&self, event: KeyEvent) {

Replacement in src/x11.rs at line 227 [14.308]

B:BD[13.15058] → [4.16788:16840]

    fn recv_event(&self) -> Option<io::HostEvent> {

[13.15058]

[13.15106]

    fn recv_event(&self) -> Option<HostEvent> {

Replacement in src/x11.rs at line 248 [14.308]

B:BD[13.15893] → [4.16841:16890]

    fn send_event(&self, event: io::HostEvent) {

[13.15893]

[13.15938]

    fn send_event(&self, event: HostEvent) {

Replacement in src/x11.rs at line 250 [14.308]

B:BD[13.15960] → [4.16891:17189]

            io::HostEvent::Position(event) => self.send_position_event(event),
            io::HostEvent::Motion(event) => self.send_motion_event(event),
            io::HostEvent::Button(event) => self.send_button_event(event),
            io::HostEvent::Key(event) => self.send_key_event(event),

[13.15960]

[12.5968]

            HostEvent::Position(event) => self.send_position_event(event),
            HostEvent::Motion(event) => self.send_motion_event(event),
            HostEvent::Button(event) => self.send_button_event(event),
            HostEvent::Key(event) => self.send_key_event(event),

Replacement in src/x11.rs at line 262 [14.308]

B:BD[13.16335] → [4.17190:17227]

∅:D[4.17227] → [13.16367:16511]

B:BD[13.16367] → [13.16367:16511]

impl mio::Evented for X11Interface {
    fn register(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {

[13.16335]

[13.16511]

impl Evented for X11Interface {
    fn register(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {

Replacement in src/x11.rs at line 267 [14.308]

B:BD[14.8415] → [13.16593:16739]

    fn reregister(&self, selector: &mut mio::Selector, token: mio::Token, interest: mio::EventSet, opts: mio::PollOpt) -> ::std::io::Result<()> {

[14.8415]

[13.16739]

    fn reregister(&self, selector: &mut Selector, token: Token, interest: EventSet, opts: PollOpt) -> io::Result<()> {

Replacement in src/x11.rs at line 271 [14.308]

B:BD[13.16823] → [13.16823:16905]

    fn deregister(&self, selector: &mut mio::Selector) -> ::std::io::Result<()> {

[13.16823]

[13.16905]

    fn deregister(&self, selector: &mut Selector) -> io::Result<()> {