change(wire): remove generic in parse and emit

examples/ping.rs

@@ -208,7 +208,7 @@ fn main() {
 
             match remote_addr {
                 IpAddress::Ipv4(_) => {
-                    let icmp_packet = Icmpv4Packet::new_checked(&payload).unwrap();
+                    let icmp_packet = Icmpv4Packet::new_checked(payload).unwrap();
                     let icmp_repr = Icmpv4Repr::parse(&icmp_packet, &device_caps.checksum).unwrap();
                     get_icmp_pong!(
                         Icmpv4Repr,
@@ -221,7 +221,7 @@ fn main() {
                     );
                 }
                 IpAddress::Ipv6(address) => {
-                    let icmp_packet = Icmpv6Packet::new_checked(&payload).unwrap();
+                    let icmp_packet = Icmpv6Packet::new_checked(payload).unwrap();
                     let icmp_repr = Icmpv6Repr::parse(
                         &remote_addr,
                         &iface

src/iface/interface/mod.rs

@@ -1494,8 +1494,8 @@ impl InterfaceInner {
         };
 
         // Emit function for the IP header and payload.
-        let emit_ip = |repr: &IpRepr, mut tx_buffer: &mut [u8]| {
-            repr.emit(&mut tx_buffer, &self.caps.checksum);
+        let emit_ip = |repr: &IpRepr, tx_buffer: &mut [u8]| {
+            repr.emit(tx_buffer, &self.caps.checksum);
 
             let payload = &mut tx_buffer[repr.header_len()..];
             packet.emit_payload(repr, payload, &caps)

src/iface/interface/sixlowpan.rs

@@ -421,7 +421,7 @@ impl InterfaceInner {
                     tx_buf = &mut tx_buf[ieee_len..];
 
                     // Add the first fragment header
-                    let mut frag1_packet = SixlowpanFragPacket::new_unchecked(&mut tx_buf);
+                    let mut frag1_packet = SixlowpanFragPacket::new_unchecked(&mut tx_buf[..]);
                     frag1.emit(&mut frag1_packet);
                     tx_buf = &mut tx_buf[frag1.buffer_len()..];
 
@@ -752,7 +752,7 @@ mod tests {
             0xfd, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
         ])];
 
-        let ieee_frame = Ieee802154Frame::new_checked(&SIXLOWPAN_COMPRESSED_RPL_DAO).unwrap();
+        let ieee_frame = Ieee802154Frame::new_checked(&SIXLOWPAN_COMPRESSED_RPL_DAO[..]).unwrap();
         let ieee_repr = Ieee802154Repr::parse(&ieee_frame).unwrap();
 
         let mut buffer = [0u8; 256];

src/iface/interface/tests/ipv4.rs

@@ -181,8 +181,8 @@ fn test_icmp_error_port_unreachable(#[case] medium: Medium) {
 
     let mut udp_bytes_unicast = vec![0u8; 20];
     let mut udp_bytes_broadcast = vec![0u8; 20];
-    let mut packet_unicast = UdpPacket::new_unchecked(&mut udp_bytes_unicast);
-    let mut packet_broadcast = UdpPacket::new_unchecked(&mut udp_bytes_broadcast);
+    let mut packet_unicast = UdpPacket::new_unchecked(&mut udp_bytes_unicast[..]);
+    let mut packet_broadcast = UdpPacket::new_unchecked(&mut udp_bytes_broadcast[..]);
 
     let udp_repr = UdpRepr {
         src_port: 67,

src/iface/interface/tests/mod.rs

@@ -78,7 +78,7 @@ fn test_handle_udp_broadcast(
     let udp_socket = udp::Socket::new(rx_buffer, tx_buffer);
 
     let mut udp_bytes = vec![0u8; 13];
-    let mut packet = UdpPacket::new_unchecked(&mut udp_bytes);
+    let mut packet = UdpPacket::new_unchecked(&mut udp_bytes[..]);
 
     let socket_handle = sockets.add(udp_socket);
 

src/socket/icmp.rs

@@ -723,7 +723,7 @@ mod test_ipv4 {
         assert!(socket.can_send());
 
         let mut bytes = [0xff; 24];
-        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
         ECHOV4_REPR.emit(&mut packet, &checksum);
 
         assert_eq!(
@@ -770,7 +770,7 @@ mod test_ipv4 {
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = [0xff; 24];
-        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
         ECHOV4_REPR.emit(&mut packet, &checksum);
 
         s.set_hop_limit(Some(0x2a));
@@ -840,7 +840,7 @@ mod test_ipv4 {
 
         let checksum = ChecksumCapabilities::default();
         let mut bytes = [0xff; 20];
-        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv4Packet::new_unchecked(&mut bytes[..]);
         let icmp_repr = Icmpv4Repr::EchoRequest {
             ident: 0x4321,
             seq_no: 0x5678,
@@ -866,7 +866,7 @@ mod test_ipv4 {
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = [0xff; 18];
-        let mut packet = UdpPacket::new_unchecked(&mut bytes);
+        let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
         UDP_REPR.emit(
             &mut packet,
             &REMOTE_IPV4.into(),
@@ -986,7 +986,7 @@ mod test_ipv6 {
         assert!(socket.can_send());
 
         let mut bytes = vec![0xff; 24];
-        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
         ECHOV6_REPR.emit(
             &LOCAL_IPV6.into(),
             &REMOTE_IPV6.into(),
@@ -1038,7 +1038,7 @@ mod test_ipv6 {
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = vec![0xff; 24];
-        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
         ECHOV6_REPR.emit(
             &LOCAL_IPV6.into(),
             &REMOTE_IPV6.into(),
@@ -1154,7 +1154,7 @@ mod test_ipv6 {
 
         let checksum = ChecksumCapabilities::default();
         let mut bytes = [0xff; 20];
-        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes);
+        let mut packet = Icmpv6Packet::new_unchecked(&mut bytes[..]);
         let icmp_repr = Icmpv6Repr::EchoRequest {
             ident: 0x4321,
             seq_no: 0x5678,
@@ -1185,7 +1185,7 @@ mod test_ipv6 {
         let checksum = ChecksumCapabilities::default();
 
         let mut bytes = [0xff; 18];
-        let mut packet = UdpPacket::new_unchecked(&mut bytes);
+        let mut packet = UdpPacket::new_unchecked(&mut bytes[..]);
         UDP_REPR.emit(
             &mut packet,
             &REMOTE_IPV6.into(),

src/wire/arp.rs

@@ -270,7 +270,7 @@ pub enum Repr {
 impl Repr {
     /// Parse an Address Resolution Protocol packet and return a high-level representation,
     /// or return `Err(Error)` if the packet is not recognized.
-    pub fn parse<T: AsRef<[u8]>>(packet: &Packet<T>) -> Result<Repr> {
+    pub fn parse(packet: &Packet<&[u8]>) -> Result<Repr> {
         match (
             packet.hardware_type(),
             packet.protocol_type(),
@@ -296,7 +296,7 @@ impl Repr {
     }
 
     /// Emit a high-level representation into an Address Resolution Protocol packet.
-    pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, packet: &mut Packet<T>) {
+    pub fn emit(&self, packet: &mut Packet<&mut [u8]>) {
         match *self {
             Repr::EthernetIpv4 {
                 operation,
@@ -319,7 +319,7 @@ impl Repr {
     }
 }
 
-impl<T: AsRef<[u8]>> fmt::Display for Packet<T> {
+impl fmt::Display for Packet<&[u8]> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match Repr::parse(self) {
             Ok(repr) => write!(f, "{repr}"),
@@ -375,7 +375,7 @@ impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
         f: &mut fmt::Formatter,
         indent: &mut PrettyIndent,
     ) -> fmt::Result {
-        match Packet::new_checked(buffer) {
+        match Packet::new_checked(buffer.as_ref()) {
             Err(err) => write!(f, "{indent}({err})"),
             Ok(packet) => write!(f, "{indent}{packet}"),
         }
@@ -451,7 +451,7 @@ mod test {
     #[test]
     fn test_emit() {
         let mut bytes = vec![0xa5; 28];
-        let mut packet = Packet::new_unchecked(&mut bytes);
+        let mut packet = Packet::new_unchecked(&mut bytes[..]);
         packet_repr().emit(&mut packet);
         assert_eq!(&*packet.into_inner(), &PACKET_BYTES[..]);
     }

src/wire/dhcpv4.rs

@@ -703,10 +703,7 @@ impl<'a> Repr<'a> {
     }
 
     /// Parse a DHCP packet and return a high-level representation.
-    pub fn parse<T>(packet: &'a Packet<&'a T>) -> Result<Self>
-    where
-        T: AsRef<[u8]> + ?Sized,
-    {
+    pub fn parse(packet: &'a Packet<&'a [u8]>) -> Result<Self> {
         let transaction_id = packet.transaction_id();
         let client_hardware_address = packet.client_hardware_address();
         let client_ip = packet.client_ip();
@@ -834,10 +831,7 @@ impl<'a> Repr<'a> {
 
     /// Emit a high-level representation into a Dynamic Host
     /// Configuration Protocol packet.
-    pub fn emit<T>(&self, packet: &mut Packet<&mut T>) -> Result<()>
-    where
-        T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
-    {
+    pub fn emit(&self, packet: &mut Packet<&mut [u8]>) -> Result<()> {
         packet.set_sname_and_boot_file_to_zero();
         packet.set_opcode(self.message_type.opcode());
         packet.set_hardware_type(Hardware::Ethernet);
@@ -1211,7 +1205,7 @@ mod test {
     fn test_emit_discover() {
         let repr = discover_repr();
         let mut bytes = vec![0xa5; repr.buffer_len()];
-        let mut packet = Packet::new_unchecked(&mut bytes);
+        let mut packet = Packet::new_unchecked(&mut bytes[..]);
         repr.emit(&mut packet).unwrap();
         let packet = &*packet.into_inner();
         let packet_len = packet.len();
@@ -1225,7 +1219,7 @@ mod test {
     fn test_emit_offer() {
         let repr = offer_repr();
         let mut bytes = vec![0xa5; repr.buffer_len()];
-        let mut packet = Packet::new_unchecked(&mut bytes);
+        let mut packet = Packet::new_unchecked(&mut bytes[..]);
         repr.emit(&mut packet).unwrap();
     }
 
@@ -1244,10 +1238,10 @@ mod test {
             repr
         };
         let mut bytes = vec![0xa5; repr.buffer_len()];
-        let mut packet = Packet::new_unchecked(&mut bytes);
+        let mut packet = Packet::new_unchecked(&mut bytes[..]);
         repr.emit(&mut packet).unwrap();
 
-        let packet = Packet::new_unchecked(&bytes);
+        let packet = Packet::new_unchecked(&bytes[..]);
         let repr_parsed = Repr::parse(&packet).unwrap();
 
         assert_eq!(

src/wire/dns.rs

@@ -417,10 +417,7 @@ impl<'a> Repr<'a> {
     }
 
     /// Emit a high-level representation into a DNS packet.
-    pub fn emit<T: ?Sized>(&self, packet: &mut Packet<&mut T>)
-    where
-        T: AsRef<[u8]> + AsMut<[u8]>,
-    {
+    pub fn emit(&self, packet: &mut Packet<&mut [u8]>) {
         packet.set_transaction_id(self.transaction_id);
         packet.set_flags(self.flags);
         packet.set_opcode(self.opcode);

src/wire/ethernet.rs

@@ -267,7 +267,7 @@ pub struct Repr {
 
 impl Repr {
     /// Parse an Ethernet II frame and return a high-level representation.
-    pub fn parse<T: AsRef<[u8]> + ?Sized>(frame: &Frame<&T>) -> Result<Repr> {
+    pub fn parse(frame: &Frame<&[u8]>) -> Result<Repr> {
         frame.check_len()?;
         Ok(Repr {
             src_addr: frame.src_addr(),
@@ -282,7 +282,7 @@ impl Repr {
     }
 
     /// Emit a high-level representation into an Ethernet II frame.
-    pub fn emit<T: AsRef<[u8]> + AsMut<[u8]>>(&self, frame: &mut Frame<T>) {
+    pub fn emit(&self, frame: &mut Frame<&mut [u8]>) {
         frame.set_src_addr(self.src_addr);
         frame.set_dst_addr(self.dst_addr);
         frame.set_ethertype(self.ethertype);

src/wire/icmpv4.rs

@@ -392,13 +392,10 @@ pub enum Repr<'a> {
 impl<'a> Repr<'a> {
     /// Parse an Internet Control Message Protocol version 4 packet and return
     /// a high-level representation.
-    pub fn parse<T>(
-        packet: &Packet<&'a T>,
+    pub fn parse(
+        packet: &Packet<&'a [u8]>,
         checksum_caps: &ChecksumCapabilities,
-    ) -> Result<Repr<'a>>
-    where
-        T: AsRef<[u8]> + ?Sized,
-    {
+    ) -> Result<Repr<'a>> {
         // Valid checksum is expected.
         if checksum_caps.icmpv4.rx() && !packet.verify_checksum() {
             return Err(Error);
@@ -482,10 +479,7 @@ impl<'a> Repr<'a> {
 
     /// Emit a high-level representation into an Internet Control Message Protocol version 4
     /// packet.
-    pub fn emit<T>(&self, packet: &mut Packet<&mut T>, checksum_caps: &ChecksumCapabilities)
-    where
-        T: AsRef<[u8]> + AsMut<[u8]> + ?Sized,
-    {
+    pub fn emit(&self, packet: &mut Packet<&mut [u8]>, checksum_caps: &ChecksumCapabilities) {
         packet.set_msg_code(0);
         match *self {
             Repr::EchoRequest {
@@ -553,7 +547,7 @@ impl<'a> Repr<'a> {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
+impl<'a> fmt::Display for Packet<&'a [u8]> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match Repr::parse(self, &ChecksumCapabilities::default()) {
             Ok(repr) => write!(f, "{repr}"),
@@ -617,7 +611,7 @@ impl<T: AsRef<[u8]>> PrettyPrint for Packet<T> {
         f: &mut fmt::Formatter,
         indent: &mut PrettyIndent,
     ) -> fmt::Result {
-        let packet = match Packet::new_checked(buffer) {
+        let packet = match Packet::new_checked(buffer.as_ref()) {
             Err(err) => return write!(f, "{indent}({err})"),
             Ok(packet) => packet,
         };
@@ -687,9 +681,9 @@ mod test {
     fn test_echo_emit() {
         let repr = echo_packet_repr();
         let mut bytes = vec![0xa5; repr.buffer_len()];
-        let mut packet = Packet::new_unchecked(&mut bytes);
+        let mut packet = Packet::new_unchecked(&mut bytes[..]);
         repr.emit(&mut packet, &ChecksumCapabilities::default());
-        assert_eq!(&packet.into_inner()[..], &ECHO_PACKET_BYTES[..]);
+        assert_eq!(packet.into_inner(), &ECHO_PACKET_BYTES[..]);
     }
 
     #[test]