Huge Update #2

examples/client.rs

@@ -3,6 +3,7 @@ extern crate enet;
 use std::net::Ipv4Addr;
 
 use enet::*;
+use std::time::Duration;
 
 fn main() {
     let enet = Enet::new().expect("could not initialize ENet");
@@ -20,8 +21,10 @@ fn main() {
     host.connect(&Address::new(Ipv4Addr::LOCALHOST, 9001), 10, 0)
         .expect("connect failed");
 
-    let mut peer = loop {
-        let e = host.service(1000).expect("service failed");
+    let peer_id = loop {
+        let e = host
+            .service(Duration::from_secs(1))
+            .expect("service failed");
 
         let e = match e {
             Some(ev) => ev,
@@ -30,31 +33,34 @@ fn main() {
 
         println!("[client] event: {:#?}", e);
 
-        match e {
-            Event::Connect(ref p) => {
-                break p.clone();
-            }
-            Event::Disconnect(ref p, r) => {
-                println!("connection NOT successful, peer: {:?}, reason: {}", p, r);
+        match e.kind {
+            EventKind::Connect => break e.peer_id,
+            EventKind::Disconnect { data } => {
+                println!(
+                    "connection NOT successful, peer: {:?}, reason: {}",
+                    e.peer_id, data
+                );
                 std::process::exit(0);
             }
-            Event::Receive { .. } => {
+            EventKind::Receive { .. } => {
                 panic!("unexpected Receive-event while waiting for connection")
             }
         };
     };
 
     // send a "hello"-like packet
-    peer.send_packet(
-        Packet::new(b"harro", PacketMode::ReliableSequenced).unwrap(),
-        1,
-    ).unwrap();
+    host[peer_id]
+        .send_packet(
+            Packet::from_vec(b"harro".to_vec(), PacketMode::ReliableSequenced).unwrap(),
+            1,
+        )
+        .unwrap();
 
     // disconnect after all outgoing packets have been sent.
-    peer.disconnect_later(5);
+    host[peer_id].disconnect_later(5);
 
     loop {
-        let e = host.service(1000).unwrap();
+        let e = host.service(Duration::from_secs(1)).unwrap();
         println!("received event: {:#?}", e);
     }
 }

examples/server.rs

@@ -1,8 +1,8 @@
 extern crate enet;
 
-use std::net::Ipv4Addr;
-
 use enet::*;
+use std::net::Ipv4Addr;
+use std::time::Duration;
 
 fn main() {
     let enet = Enet::new().expect("could not initialize ENet");
@@ -20,16 +20,20 @@ fn main() {
         .expect("could not create host");
 
     loop {
-        match host.service(1000).expect("service failed") {
-            Some(Event::Connect(_)) => println!("new connection!"),
-            Some(Event::Disconnect(..)) => println!("disconnect!"),
-            Some(Event::Receive {
-                channel_id,
-                ref packet,
-                ..
-            }) => println!("got packet on channel {}, content: '{}'", channel_id,
-                         std::str::from_utf8(packet.data()).unwrap()),
-            _ => (),
+        // Wait 500 ms for any events.
+        if let Some(Event { kind, .. }) = host
+            .service(Duration::from_millis(500))
+            .expect("service failed")
+        {
+            match kind {
+                EventKind::Connect => println!("new connection!"),
+                EventKind::Disconnect { .. } => println!("disconnect!"),
+                EventKind::Receive { channel_id, packet } => println!(
+                    "got packet on channel {}, content: '{}'",
+                    channel_id,
+                    std::str::from_utf8(packet.data()).unwrap()
+                ),
+            }
         }
     }
 }

src/address.rs

@@ -1,4 +1,4 @@
-use std::ffi::CString;
+use std::ffi::CStr;
 use std::net::{Ipv4Addr, SocketAddrV4};
 
 use crate::Error;
@@ -20,7 +20,7 @@ impl Address {
     }
 
     /// Create a new address from a given hostname.
-    pub fn from_hostname(hostname: &CString, port: u16) -> Result<Address, Error> {
+    pub fn from_hostname(hostname: &CStr, port: u16) -> Result<Address, Error> {
         use enet_sys::enet_address_set_host;
 
         let mut addr = ENetAddress { host: 0, port };

src/event.rs

@@ -1,64 +1,60 @@
+#![allow(non_upper_case_globals)]
 use enet_sys::{
     ENetEvent, _ENetEventType_ENET_EVENT_TYPE_CONNECT, _ENetEventType_ENET_EVENT_TYPE_DISCONNECT,
     _ENetEventType_ENET_EVENT_TYPE_NONE, _ENetEventType_ENET_EVENT_TYPE_RECEIVE,
 };
 
-use crate::{Packet, Peer};
+use crate::{Host, Packet, PeerID};
 
-/// This enum represents an event that can occur when servicing an `EnetHost`.
-///
-/// Also see the official ENet documentation for more information.
+/// This struct represents an event that can occur when servicing an `Host`.
 #[derive(Debug)]
-pub enum Event<'a, T> {
-    /// This variant represents the connection of a peer, contained in the only field.
-    Connect(Peer<'a, T>),
-    /// This variant represents the disconnection of a peer, either because it was requested or due to a timeout.
-    ///
-    /// The disconnected peer is contained in the first field, while the second field contains the user-specified
-    /// data for this disconnection.
-    Disconnect(Peer<'a, T>, u32),
-    /// This variants repersents a packet that was received.
+pub struct Event {
+    /// The peer that this event happened on.
+    pub peer_id: PeerID,
+    /// The type of this event.
+    pub kind: EventKind,
+}
+
+/// The type of an event.
+#[derive(Debug)]
+pub enum EventKind {
+    /// Peer has connected.
+    Connect,
+    /// Peer has disconnected.
+    //
+    /// The data of the peer will be dropped on the next call to Host::service or when the structure is dropped.
+    Disconnect {
+        /// The data associated with this event. Usually a reason for disconnection.
+        data: u32,
+    },
+    /// Peer has received a packet.
     Receive {
-        /// The `Peer` that sent the packet.
-        sender: Peer<'a, T>,
-        /// The channel on which the packet was received.
+        /// ID of the channel that the packet was received on.
         channel_id: u8,
-        /// The `Packet` that was received.
+        /// The received packet.
         packet: Packet,
     },
 }
 
-impl<'a, T> Event<'a, T> {
-    pub(crate) fn from_sys_event<'b>(event_sys: &'b ENetEvent) -> Option<Event<'a, T>> {
-        #[allow(non_upper_case_globals)]
-        match event_sys.type_ {
-            _ENetEventType_ENET_EVENT_TYPE_NONE => None,
-            _ENetEventType_ENET_EVENT_TYPE_CONNECT => {
-                Some(Event::Connect(Peer::new(event_sys.peer)))
-            }
-            _ENetEventType_ENET_EVENT_TYPE_DISCONNECT => Some(Event::Disconnect(
-                Peer::new(event_sys.peer),
-                event_sys.data,
-            )),
-            _ENetEventType_ENET_EVENT_TYPE_RECEIVE => Some(Event::Receive {
-                sender: Peer::new(event_sys.peer),
+impl Event {
+    pub(crate) fn from_sys_event<T>(event_sys: ENetEvent, host: &Host<T>) -> Option<Event> {
+        if event_sys.type_ == _ENetEventType_ENET_EVENT_TYPE_NONE {
+            return None;
+        }
+
+        let peer_id = unsafe { host.peer_id(event_sys.peer) };
+        let kind = match event_sys.type_ {
+            _ENetEventType_ENET_EVENT_TYPE_CONNECT => EventKind::Connect,
+            _ENetEventType_ENET_EVENT_TYPE_DISCONNECT => EventKind::Disconnect {
+                data: event_sys.data,
+            },
+            _ENetEventType_ENET_EVENT_TYPE_RECEIVE => EventKind::Receive {
                 channel_id: event_sys.channelID,
                 packet: Packet::from_sys_packet(event_sys.packet),
-            }),
-            _ => panic!("unrecognized event type: {}", event_sys.type_),
-        }
-    }
-}
+            },
+            _ => panic!("unexpected event type: {}", event_sys.type_),
+        };
 
-impl<'a, T> Drop for Event<'a, T> {
-    fn drop(&mut self) {
-        match self {
-            // Seemingly, the lifetime of an ENetPeer ends with the end of the Disconnect event.
-            // However, this is *not really clear* in the ENet docs!
-            // It looks like the Peer *might* live longer, but not shorter, so it should be safe
-            // to destroy the associated data (if any) here.
-            Event::Disconnect(peer, _) => peer.set_data(None),
-            _ => (),
-        }
+        Some(Event { peer_id, kind })
     }
 }