Generalize PacketKind

There is no need for a separate trait, we can simply use 'Packet'
instead which is more flexible.

Author: Dylan McKay

src/lib.rs

@@ -11,7 +11,7 @@
 
 pub use self::types::{Type, Integer, Array, String, ByteOrder};
 pub use self::error::Error;
-pub use self::packet::{PacketKind, Packet};
+pub use self::packet::Packet;
 
 #[macro_use]
 pub mod types;

src/packet/macros.rs

@@ -73,7 +73,7 @@ macro_rules! define_packet_kind
             }
         }
 
-        impl $crate::PacketKind for $ty
+        impl $crate::Packet for $ty
         {
             fn read(read: &mut ::std::io::Read) -> Result<Self, $crate::Error> {
                 let packet_id = <$id_ty as $crate::Type>::read(read)?;

src/packet/mod.rs

@@ -1,4 +1,4 @@
-pub use self::packet::{PacketKind, Packet};
+pub use self::packet::Packet;
 
 #[macro_use]
 pub mod macros;

src/packet/packet.rs

@@ -4,8 +4,8 @@ use std::io::prelude::*;
 use std::io::Cursor;
 use std::fmt;
 
-/// A packet enum.
-pub trait PacketKind : Clone + fmt::Debug
+/// A specific packet type.
+pub trait Packet : Clone + fmt::Debug
 {
     fn read(read: &mut Read) -> Result<Self, Error>;
     fn write(&self, write: &mut Write) -> Result<(), Error>;
@@ -22,17 +22,10 @@ pub trait PacketKind : Clone + fmt::Debug
     }
 }
 
-/// A specific packet type.
-pub trait Packet : Clone + fmt::Debug
-{
-    fn read(read: &mut Read) -> Result<Self, Error>;
-    fn write(&self, write: &mut Write) -> Result<(), Error>;
-}
-
 #[cfg(test)]
 #[allow(unused_variables)]
 mod test {
-    pub use PacketKind;
+    pub use Packet;
 
     define_packet!(Handshake);
     define_packet!(Kick);
@@ -51,7 +44,7 @@ mod test {
         properties: ::std::collections::HashMap<String, bool>
     });
 
-    define_packet_kind!(Packet: u32 {
+    define_packet_kind!(PacketKind: u32 {
         0x00 => Handshake,
         0x01 => Kick,
         0x02 => Hello,
@@ -75,25 +68,25 @@ mod test {
         describe! packet_ids {
             describe! numerical {
                 it "gets the corrrect ids" {
-                    assert_eq!(Packet::Handshake(Handshake).packet_id(), 0x00);
-                    assert_eq!(Packet::Kick(Kick).packet_id(), 0x01);
+                    assert_eq!(PacketKind::Handshake(Handshake).packet_id(), 0x00);
+                    assert_eq!(PacketKind::Kick(Kick).packet_id(), 0x01);
 
-                    assert_eq!(Packet::Hello(hello).packet_id(), 0x02);
-                    assert_eq!(Packet::Goodbye(goodbye).packet_id(), 0x03);
+                    assert_eq!(PacketKind::Hello(hello).packet_id(), 0x02);
+                    assert_eq!(PacketKind::Goodbye(goodbye).packet_id(), 0x03);
                 }
             }
 
             describe! writing {
                 it "writes the correct values" {
-                    let packet = Packet::Hello(hello);
+                    let packet = PacketKind::Hello(hello);
 
                     assert_eq!(&packet.bytes().unwrap(), hello_expected_bytes);
                 }
             }
 
             describe! reading {
                 it "reads the correct values" {
-                    let packet = Packet::from_bytes(hello_expected_bytes).unwrap();
+                    let packet = PacketKind::from_bytes(hello_expected_bytes).unwrap();
 
                     assert_eq!(packet.bytes().unwrap(), hello_expected_bytes);
                 }

src/wire/dgram/mod.rs

@@ -1,20 +1,20 @@
-use {PacketKind, Error};
+use {Packet, Error};
 use wire::middleware;
 
 use std::io::prelude::*;
 use std::io::Cursor;
 use std;
 
 /// A datagram-based packet pipeline.
-pub struct Pipeline<P: PacketKind, M: middleware::Pipeline>
+pub struct Pipeline<P: Packet, M: middleware::Pipeline>
 {
     pub middleware: M,
 
     _a: std::marker::PhantomData<P>,
 }
 
 impl<P,M> Pipeline<P,M>
-    where P: PacketKind, M: middleware::Pipeline
+    where P: Packet, M: middleware::Pipeline
 {
     pub fn new(middleware: M) -> Self {
         Pipeline {

src/wire/stream/connection.rs

@@ -1,4 +1,4 @@
-use {PacketKind, Error};
+use {Packet, Error};
 use wire::stream::{Transport, transport};
 use wire::middleware;
 
@@ -7,7 +7,7 @@ use std::io::Cursor;
 
 /// A stream-based connection.
 // TODO: Allow custom transports.
-pub struct Connection<P: PacketKind, S: Read + Write, M: middleware::Pipeline = middleware::pipeline::Default>
+pub struct Connection<P: Packet, S: Read + Write, M: middleware::Pipeline = middleware::pipeline::Default>
 {
     pub stream: S,
     pub transport: transport::Simple,
@@ -17,7 +17,7 @@ pub struct Connection<P: PacketKind, S: Read + Write, M: middleware::Pipeline =
 }
 
 impl<P,S,M> Connection<P,S,M>
-    where P: PacketKind, S: Read + Write, M: middleware::Pipeline
+    where P: Packet, S: Read + Write, M: middleware::Pipeline
 {
     /// Creates a new connection.
     pub fn new(stream: S, middleware: M) -> Self {
@@ -61,7 +61,7 @@ impl<P,S,M> Connection<P,S,M>
 #[cfg(test)]
 mod test
 {
-    pub use PacketKind;
+    pub use Packet;
     pub use super::Connection;
     pub use wire::middleware;
 
@@ -71,13 +71,13 @@ mod test
         data: Vec<u8>
     });
 
-    define_packet_kind!(Packet : u8 {
+    define_packet_kind!(PacketKind : u8 {
         0x00 => Ping
     });
 
     describe! connection {
         it "can write and read back data" {
-            let ping = Packet::Ping(Ping { data: vec![5, 4, 3, 2, 1]});
+            let ping = PacketKind::Ping(Ping { data: vec![5, 4, 3, 2, 1]});
 
             let buffer = Cursor::new(Vec::new());
             let mut connection = Connection::new(buffer, middleware::pipeline::default());