👽️ Upgrade to Rust 2024

Cargo.toml

@@ -7,7 +7,7 @@ readme = "README.md"
 license = "MIT"
 description = "memcached client for rust"
 keywords = ["memcache", "memcached", "driver", "cache", "database"]
-edition = "2018"
+edition = "2024"
 
 [features]
 default = ["tls"]

src/client.rs

@@ -1,5 +1,5 @@
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
+use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::time::Duration;
 

src/connection.rs

@@ -111,7 +111,7 @@ impl TlsOptions {
             Some(_) => {
                 return Err(MemcacheError::BadURL(
                     "unknown verify_mode, expected 'none' or 'peer'".into(),
-                ))
+                ));
             }
             None => SslVerifyMode::PEER,
         };
@@ -165,7 +165,7 @@ impl Transport {
             _ => {
                 return Err(MemcacheError::BadURL(
                     "memcache URL's scheme should start with 'memcache'".into(),
-                ))
+                ));
             }
         }
 

src/error.rs

@@ -153,25 +153,25 @@ pub enum ParseError {
 impl error::Error for ParseError {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match self {
-            ParseError::Bool(ref e) => e.source(),
-            ParseError::Int(ref e) => e.source(),
-            ParseError::Float(ref e) => e.source(),
-            ParseError::String(ref e) => e.source(),
-            ParseError::Str(ref e) => e.source(),
-            ParseError::Url(ref e) => e.source(),
+            ParseError::Bool(e) => e.source(),
+            ParseError::Int(e) => e.source(),
+            ParseError::Float(e) => e.source(),
+            ParseError::String(e) => e.source(),
+            ParseError::Str(e) => e.source(),
+            ParseError::Url(e) => e.source(),
         }
     }
 }
 
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            ParseError::Bool(ref e) => e.fmt(f),
-            ParseError::Int(ref e) => e.fmt(f),
-            ParseError::Float(ref e) => e.fmt(f),
-            ParseError::String(ref e) => e.fmt(f),
-            ParseError::Str(ref e) => e.fmt(f),
-            ParseError::Url(ref e) => e.fmt(f),
+            ParseError::Bool(e) => e.fmt(f),
+            ParseError::Int(e) => e.fmt(f),
+            ParseError::Float(e) => e.fmt(f),
+            ParseError::String(e) => e.fmt(f),
+            ParseError::Str(e) => e.fmt(f),
+            ParseError::Url(e) => e.fmt(f),
         }
     }
 }

src/stream/mod.rs

@@ -24,24 +24,24 @@ pub enum Stream {
 impl Stream {
     pub(super) fn set_read_timeout(&mut self, timeout: Option<Duration>) -> Result<(), MemcacheError> {
         match self {
-            Stream::Tcp(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Tcp(ref conn) => conn.set_read_timeout(timeout)?,
             #[cfg(unix)]
-            Stream::Unix(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Unix(ref conn) => conn.set_read_timeout(timeout)?,
             #[cfg(feature = "tls")]
-            Stream::Tls(ref stream) => stream.get_ref().set_read_timeout(timeout)?,
-            Stream::Udp(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Tls(ref stream) => stream.get_ref().set_read_timeout(timeout)?,
+            &mut Stream::Udp(ref conn) => conn.set_read_timeout(timeout)?,
         }
         Ok(())
     }
 
     pub(super) fn set_write_timeout(&mut self, timeout: Option<Duration>) -> Result<(), MemcacheError> {
         match self {
-            Stream::Tcp(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Tcp(ref conn) => conn.set_write_timeout(timeout)?,
             #[cfg(unix)]
-            Stream::Unix(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Unix(ref conn) => conn.set_write_timeout(timeout)?,
             #[cfg(feature = "tls")]
-            Stream::Tls(ref stream) => stream.get_ref().set_write_timeout(timeout)?,
-            Stream::Udp(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Tls(ref stream) => stream.get_ref().set_write_timeout(timeout)?,
+            &mut Stream::Udp(ref conn) => conn.set_write_timeout(timeout)?,
         }
         Ok(())
     }
@@ -50,36 +50,36 @@ impl Stream {
 impl Read for Stream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.read(buf),
-            Stream::Udp(ref mut stream) => stream.read(buf),
+            Stream::Tcp(stream) => stream.read(buf),
+            Stream::Udp(stream) => stream.read(buf),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.read(buf),
+            Stream::Unix(stream) => stream.read(buf),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.read(buf),
+            Stream::Tls(stream) => stream.read(buf),
         }
     }
 }
 
 impl Write for Stream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.write(buf),
-            Stream::Udp(ref mut stream) => stream.write(buf),
+            Stream::Tcp(stream) => stream.write(buf),
+            Stream::Udp(stream) => stream.write(buf),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.write(buf),
+            Stream::Unix(stream) => stream.write(buf),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.write(buf),
+            Stream::Tls(stream) => stream.write(buf),
         }
     }
 
     fn flush(&mut self) -> io::Result<()> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.flush(),
-            Stream::Udp(ref mut stream) => stream.flush(),
+            Stream::Tcp(stream) => stream.flush(),
+            Stream::Udp(stream) => stream.flush(),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.flush(),
+            Stream::Unix(stream) => stream.flush(),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.flush(),
+            Stream::Tls(stream) => stream.flush(),
         }
     }
 }

tests/tests.rs

@@ -2,7 +2,7 @@ extern crate memcache;
 extern crate rand;
 
 use rand::distributions::Alphanumeric;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::iter;
 use std::thread;
 use std::thread::JoinHandle;