Bump lru, tokio-util. Update docs

Author: blackbeam

Cargo.toml

@@ -18,7 +18,7 @@ futures-core = "0.3"
 futures-util = "0.3"
 futures-sink = "0.3"
 lazy_static = "1"
-lru = "0.4.3"
+lru = "0.5.3"
 mio-named-pipes = "0.1.6"
 mysql_common = "0.22.0"
 native-tls = "0.2"
@@ -28,7 +28,7 @@ serde = "1"
 serde_json = "1"
 thiserror = "1.0.4"
 tokio = { version = "0.2.17", features = ["io-util", "net", "sync", "fs", "rt-core", "time", "stream", "macros"] }
-tokio-util = { version = "0.2", features = ["codec"] }
+tokio-util = { version = "0.3.1", features = ["codec"] }
 tokio-tls = "0.3"
 twox-hash = "1"
 url = "2.1"

src/conn/mod.rs

@@ -287,11 +287,13 @@ impl Conn {
         Ok(())
     }
 
+    /// Closes the connection.
     async fn close_conn(mut self) -> Result<()> {
         self = self.cleanup().await?;
         self.disconnect().await
     }
 
+    /// Returns true if io stream is encrypted.
     fn is_secure(&self) -> bool {
         if let Some(ref stream) = self.inner.stream {
             stream.is_secure()

src/conn/pool/futures/disconnect_pool.rs

@@ -21,7 +21,6 @@ use std::sync::{atomic, Arc};
 
 /// Future that disconnects this pool from a server and resolves to `()`.
 ///
-///
 /// **Note:** This Future won't resolve until all active connections, taken from it,
 /// are dropped or disonnected. Also all pending and new `GetConn`'s will resolve to error.
 #[derive(Debug)]

src/conn/pool/futures/get_conn.rs

@@ -19,6 +19,7 @@ use crate::{
     BoxFuture,
 };
 
+/// States of the GetConn future.
 #[derive(Debug)]
 pub(crate) enum GetConnInner {
     New,

src/conn/pool/mod.rs

@@ -86,6 +86,7 @@ impl Exchange {
     }
 }
 
+/// Connection pool data.
 #[derive(Debug)]
 pub struct Inner {
     close: atomic::AtomicBool,
@@ -133,18 +134,18 @@ impl Pool {
         Ok(Pool::new(opts))
     }
 
-    /// Returns a future that resolves to [`Conn`].
+    /// Async function that resolves to `Conn`.
     pub fn get_conn(&self) -> GetConn {
         GetConn::new(self)
     }
 
-    /// Returns a future that starts a new transaction.
+    /// Starts a new transaction.
     pub async fn start_transaction(&self, options: TxOpts) -> Result<Transaction<'static>> {
         let conn = self.get_conn().await?;
         Transaction::new(conn, options).await
     }
 
-    /// Returns a future that disconnects this pool from the server and resolves to `()`.
+    /// Async function that disconnects this pool from the server and resolves to `()`.
     ///
     /// **Note:** This Future won't resolve until all active connections, taken from it,
     /// are dropped or disonnected. Also all pending and new `GetConn`'s will resolve to error.

src/connection_like/mod.rs

@@ -11,8 +11,11 @@ use crate::{BoxFuture, Pool};
 /// Connection.
 #[derive(Debug)]
 pub enum Connection<'a, 't: 'a> {
+    /// Just a connection.
     Conn(crate::Conn),
+    /// Mutable reference to a connection.
     ConnMut(&'a mut crate::Conn),
+    /// Connection wrapped in a transaction.
     Tx(&'a mut crate::Transaction<'t>),
 }
 
@@ -56,8 +59,11 @@ impl std::ops::DerefMut for Connection<'_, '_> {
     }
 }
 
+/// Result of `ToConnection::to_connection` call.
 pub enum ToConnectionResult<'a, 't: 'a> {
+    /// Connection is immediately available.
     Immediate(Connection<'a, 't>),
+    /// We need some time to get a connection and the operation itself may fail.
     Mediate(BoxFuture<'a, Connection<'a, 't>>),
 }
 

src/io/mod.rs

@@ -67,11 +67,10 @@ impl Decoder for PacketCodec {
     }
 }
 
-impl Encoder for PacketCodec {
-    type Item = Vec<u8>;
+impl Encoder<Vec<u8>> for PacketCodec {
     type Error = IoError;
 
-    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> std::result::Result<(), IoError> {
+    fn encode(&mut self, item: Vec<u8>, dst: &mut BytesMut) -> std::result::Result<(), IoError> {
         Ok(self.0.encode(item, dst)?)
     }
 }

src/io/write_packet.rs

@@ -17,6 +17,9 @@ use std::{
 
 use crate::{connection_like::Connection, error::IoError};
 
+/// Writes a packet.
+#[derive(Debug)]
+#[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct WritePacket<'a, 't> {
     conn: Connection<'a, 't>,
     data: Option<Vec<u8>>,

src/queryable/mod.rs

@@ -102,11 +102,13 @@ impl Conn {
 }
 
 /// Methods of this trait are used to execute database queries.
+///
+/// `Conn` is a `Queryable` as well as `Transaction`.
 pub trait Queryable: Send {
     /// Executes `COM_PING`.
     fn ping(&mut self) -> BoxFuture<'_, ()>;
 
-    /// Performs the given query.
+    /// Performs the given query and returns the result.
     fn query_iter<'a, Q>(
         &'a mut self,
         query: Q,
@@ -129,7 +131,7 @@ pub trait Queryable: Send {
     /// Usually there is no need to explicitly close statements (see. [`stmt_cache_size`]).
     fn close(&mut self, stmt: Statement) -> BoxFuture<'_, ()>;
 
-    /// Executes the given statement with the given params.
+    /// Executes the given statement with given params.
     ///
     /// It'll prepare `stmt`, if necessary.
     fn exec_iter<'a: 's, 's, Q, P>(
@@ -174,9 +176,9 @@ pub trait Queryable: Send {
     where
         Q: AsRef<str> + Send + Sync + 'a;
 
-    /// Exectues the given statement with each item in the given params iterator.
+    /// Exectues the given statement for each item in the given params iterator.
     ///
-    /// It'll prepare `stmt`, if necessary.
+    /// It'll prepare `stmt` (once), if necessary.
     fn exec_batch<'a: 'b, 'b, S, P, I>(
         &'a mut self,
         stmt: &'b S,

src/queryable/query_result.rs

@@ -41,7 +41,7 @@ impl ResultSetMeta {
 
 /// Result of a query or statement execution.
 ///
-/// Represents an asyncronous query result, that may not be fully consumed. Note,
+/// Represents an asynchronous query result, that may not be fully consumed. Note,
 /// that unconsumed query results are dropped implicitly when corresponding connection
 /// is dropped or queried.
 #[derive(Debug)]