Use is_empty instead of length comparison

These were flagged by `cargo clippy`:

    warning: length comparison to zero

examples/client.rs

@@ -77,7 +77,7 @@ fn main() {
             if socket.may_recv() {
                 let data = socket.recv(|data| {
                     let mut data = data.to_owned();
-                    if data.len() > 0 {
+                    if !data.is_empty() {
                         debug!("recv data: {:?}",
                                str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
                         data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
@@ -86,7 +86,7 @@ fn main() {
                     }
                     (data.len(), data)
                 }).unwrap();
-                if socket.can_send() && data.len() > 0 {
+                if socket.can_send() && !data.is_empty() {
                     debug!("send data: {:?}",
                            str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
                     socket.send_slice(&data[..]).unwrap();

examples/server.rs

@@ -133,7 +133,7 @@ fn main() {
                 let data = socket.recv(|buffer| {
                     let recvd_len = buffer.len();
                     let mut data = buffer.to_owned();
-                    if data.len() > 0 {
+                    if !data.is_empty() {
                         debug!("tcp:6970 recv data: {:?}",
                                str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
                         data = data.split(|&b| b == b'\n').collect::<Vec<_>>().concat();
@@ -142,7 +142,7 @@ fn main() {
                     }
                     (recvd_len, data)
                 }).unwrap();
-                if socket.can_send() && data.len() > 0 {
+                if socket.can_send() && !data.is_empty() {
                     debug!("tcp:6970 send data: {:?}",
                            str::from_utf8(data.as_ref()).unwrap_or("(invalid utf8)"));
                     socket.send_slice(&data[..]).unwrap();
@@ -164,7 +164,7 @@ fn main() {
 
             if socket.may_recv() {
                 socket.recv(|buffer| {
-                    if buffer.len() > 0 {
+                    if !buffer.is_empty() {
                         debug!("tcp:6971 recv {:?} octets", buffer.len());
                     }
                     (buffer.len(), ())
@@ -183,7 +183,7 @@ fn main() {
 
             if socket.may_send() {
                 socket.send(|data| {
-                    if data.len() > 0 {
+                    if !data.is_empty() {
                         debug!("tcp:6972 send {:?} octets", data.len());
                         for (i, b) in data.iter_mut().enumerate() {
                             *b = (i % 256) as u8;

src/socket/tcp.rs

@@ -685,7 +685,7 @@ impl<'a> TcpSocket<'a> {
             // we still can receive indefinitely.
             State::FinWait1 | State::FinWait2 => true,
             // If we have something in the receive buffer, we can receive that.
-            _ if self.rx_buffer.len() > 0 => true,
+            _ if !self.rx_buffer.is_empty() => true,
             _ => false
         }
     }
@@ -833,7 +833,7 @@ impl<'a> TcpSocket<'a> {
         self.recv_error_check()?;
 
         let buffer = self.rx_buffer.get_allocated(0, size);
-        if buffer.len() > 0 {
+        if !buffer.is_empty() {
             #[cfg(any(test, feature = "verbose"))]
             net_trace!("{}:{}:{}: rx buffer: peeking at {} octets",
                        self.meta.handle, self.local_endpoint, self.remote_endpoint,
@@ -1368,7 +1368,7 @@ impl<'a> TcpSocket<'a> {
                 // Increment duplicate ACK count and set for retransmit if we just recived
                 // the third duplicate ACK
                 Some(ref last_rx_ack) if
-                    repr.payload.len() == 0 &&
+                    repr.payload.is_empty() &&
                     *last_rx_ack == ack_number &&
                     ack_number < self.remote_last_seq => {
                     // Increment duplicate ACK count
@@ -1649,7 +1649,7 @@ impl<'a> TcpSocket<'a> {
                     match self.state {
                         State::FinWait1 | State::LastAck =>
                             repr.control = TcpControl::Fin,
-                        State::Established | State::CloseWait if repr.payload.len() > 0 =>
+                        State::Established | State::CloseWait if !repr.payload.is_empty() =>
                             repr.control = TcpControl::Psh,
                         _ => ()
                     }
@@ -1682,12 +1682,12 @@ impl<'a> TcpSocket<'a> {
         if is_keep_alive {
             net_trace!("{}:{}:{}: sending a keep-alive",
                        self.meta.handle, self.local_endpoint, self.remote_endpoint);
-        } else if repr.payload.len() > 0 {
+        } else if !repr.payload.is_empty() {
             net_trace!("{}:{}:{}: tx buffer: sending {} octets at offset {}",
                        self.meta.handle, self.local_endpoint, self.remote_endpoint,
                        repr.payload.len(), self.remote_last_seq - self.local_seq_no);
         }
-        if repr.control != TcpControl::None || repr.payload.len() == 0 {
+        if repr.control != TcpControl::None || repr.payload.is_empty() {
             let flags =
                 match (repr.control, repr.ack_number) {
                     (TcpControl::Syn,  None)    => "SYN",

src/wire/dhcpv4.rs

@@ -727,7 +727,7 @@ impl<'a> Repr<'a> {
         let mut max_size = None;
 
         let mut options = packet.options()?;
-        while options.len() > 0 {
+        while !options.is_empty() {
             let (next_options, option) = DhcpOption::parse(options)?;
             match option {
                 DhcpOption::EndOfList => break,

src/wire/ndisc.rs

@@ -228,7 +228,7 @@ impl<'a> Repr<'a> {
                 where T: AsRef<[u8]> + ?Sized {
         match packet.msg_type() {
             Message::RouterSolicit => {
-                let lladdr = if packet.payload().len() > 0 {
+                let lladdr = if !packet.payload().is_empty() {
                     let opt = NdiscOption::new_checked(packet.payload())?;
                     match opt.option_type() {
                         NdiscOptionType::SourceLinkLayerAddr => Some(opt.link_layer_addr()),
@@ -263,7 +263,7 @@ impl<'a> Repr<'a> {
                 })
             },
             Message::NeighborSolicit => {
-                let lladdr = if packet.payload().len() > 0 {
+                let lladdr = if !packet.payload().is_empty() {
                     let opt = NdiscOption::new_checked(packet.payload())?;
                     match opt.option_type() {
                         NdiscOptionType::SourceLinkLayerAddr => Some(opt.link_layer_addr()),
@@ -277,7 +277,7 @@ impl<'a> Repr<'a> {
                 })
             },
             Message::NeighborAdvert => {
-                let lladdr = if packet.payload().len() > 0 {
+                let lladdr = if !packet.payload().is_empty() {
                     let opt = NdiscOption::new_checked(packet.payload())?;
                     match opt.option_type() {
                         NdiscOptionType::TargetLinkLayerAddr => Some(opt.link_layer_addr()),

src/wire/tcp.rs

@@ -294,7 +294,7 @@ impl<T: AsRef<[u8]>> Packet<T> {
     pub fn selective_ack_permitted(&self) -> Result<bool> {
         let data = self.buffer.as_ref();
         let mut options = &data[field::OPTIONS(self.header_len())];
-        while options.len() > 0 {
+        while !options.is_empty() {
             let (next_options, option) = TcpOption::parse(options)?;
             match option {
                 TcpOption::SackPermitted => {
@@ -315,7 +315,7 @@ impl<T: AsRef<[u8]>> Packet<T> {
     ) -> Result<[Option<(u32, u32)>; 3]> {
         let data = self.buffer.as_ref();
         let mut options = &data[field::OPTIONS(self.header_len())];
-        while options.len() > 0 {
+        while !options.is_empty() {
             let (next_options, option) = TcpOption::parse(options)?;
             match option {
                 TcpOption::SackRange(slice) => {
@@ -789,7 +789,7 @@ impl<'a> Repr<'a> {
         let mut options = packet.options();
         let mut sack_permitted = false;
         let mut sack_ranges = [None, None, None];
-        while options.len() > 0 {
+        while !options.is_empty() {
             let (next_options, option) = TcpOption::parse(options)?;
             match option {
                 TcpOption::EndOfList => break,
@@ -905,7 +905,7 @@ impl<'a> Repr<'a> {
                 let tmp = options; options = TcpOption::SackRange(self.sack_ranges).emit(tmp);
             }
 
-            if options.len() > 0 {
+            if !options.is_empty() {
                 TcpOption::EndOfList.emit(options);
             }
         }
@@ -929,7 +929,7 @@ impl<'a> Repr<'a> {
     /// Return whether the segment has no flags set (except PSH) and no data.
     pub fn is_empty(&self) -> bool {
         match self.control {
-            _ if self.payload.len() != 0 => false,
+            _ if !self.payload.is_empty() => false,
             Control::Syn  | Control::Fin | Control::Rst => false,
             Control::None | Control::Psh => true
         }
@@ -959,7 +959,7 @@ impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Packet<&'a T> {
         write!(f, " len={}", self.payload().len())?;
 
         let mut options = self.options();
-        while options.len() > 0 {
+        while !options.is_empty() {
             let (next_options, option) =
                 match TcpOption::parse(options) {
                     Ok(res) => res,