Rename Pool::is_pending() to is_ready(); use u32 for read/write params

ntex-bytes/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [0.1.10] (2022-01-xx)
+
+* Rename Pool::is_pending() to is_ready()
+
+* Use u32 instead of u16 for read/write params
+
 ## [0.1.9] (2022-01-10)
 
 * Add optional simd utf8 validation

ntex-bytes/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-bytes"
-version = "0.1.9"
+version = "0.1.10"
 license = "MIT"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Carl Lerche <me@carllerche.com>"]
 description = "Types and traits for working with bytes (bytes crate fork)"
@@ -27,4 +27,4 @@ simdutf8 = { version = "0.1.3", optional = true }
 [dev-dependencies]
 serde_test = "1.0"
 serde_json = "1.0"
-ntex = "0.5.0"
+ntex = { version = "0.5", features = ["tokio"] }

ntex-bytes/src/bytes.rs

@@ -766,7 +766,7 @@ impl Bytes {
     ///
     /// assert_eq!(&a[..4], b"bary");
     /// ```
-    pub fn try_mut(mut self) -> Result<BytesMut, Bytes> {
+    pub fn try_mut(self) -> Result<BytesMut, Bytes> {
         if self.inner.is_mut_safe() {
             Ok(BytesMut { inner: self.inner })
         } else {
@@ -2252,7 +2252,7 @@ impl Inner {
     }
 
     /// Checks if it is safe to mutate the memory
-    fn is_mut_safe(&mut self) -> bool {
+    fn is_mut_safe(&self) -> bool {
         let kind = self.kind();
 
         // Always check `inline` first, because if the handle is using inline
@@ -2446,7 +2446,7 @@ impl Inner {
 
     /// Used for `debug_assert` statements
     #[inline]
-    fn is_static(&mut self) -> bool {
+    fn is_static(&self) -> bool {
         matches!(self.kind(), KIND_STATIC)
     }
 

ntex-bytes/src/lib.rs

@@ -56,7 +56,6 @@
 //    missing_debug_implementations,
     rust_2018_idioms
 )]
-#![allow(clippy::return_self_not_must_use)]
 #![doc(html_root_url = "https://docs.rs/ntex-bytes/")]
 
 pub mod buf;

ntex-bytes/src/pool.rs

@@ -21,8 +21,8 @@ pub struct PoolId(u8);
 
 #[derive(Copy, Clone)]
 pub struct BufParams {
-    pub high: u16,
+    pub high: u32,
-    pub low: u16,
+    pub low: u32,
 }
 
 bitflags::bitflags! {
@@ -99,14 +99,14 @@ impl PoolId {
 
     #[doc(hidden)]
     #[inline]
-    pub fn set_read_params(self, h: u16, l: u16) -> Self {
+    pub fn set_read_params(self, h: u32, l: u32) -> Self {
         self.pool_ref().set_read_params(h, l);
         self
     }
 
     #[doc(hidden)]
     #[inline]
-    pub fn set_write_params(self, h: u16, l: u16) -> Self {
+    pub fn set_write_params(self, h: u32, l: u32) -> Self {
         self.pool_ref().set_write_params(h, l);
         self
     }
@@ -246,7 +246,7 @@ impl PoolRef {
 
     #[doc(hidden)]
     #[inline]
-    pub fn set_read_params(self, h: u16, l: u16) -> Self {
+    pub fn set_read_params(self, h: u32, l: u32) -> Self {
         assert!(l < h);
         self.0.read_wm.set(BufParams { high: h, low: l });
         self
@@ -266,7 +266,7 @@ impl PoolRef {
 
     #[doc(hidden)]
     #[inline]
-    pub fn set_write_params(self, h: u16, l: u16) -> Self {
+    pub fn set_write_params(self, h: u32, l: u32) -> Self {
         assert!(l < h);
         self.0.write_wm.set(BufParams { high: h, low: l });
         self
@@ -459,7 +459,7 @@ impl fmt::Debug for Pool {
         f.debug_struct("Pool")
             .field("id", &self.id().0)
             .field("allocated", &self.inner.size.load(Relaxed))
-            .field("ready", &!self.is_pending())
+            .field("ready", &self.is_ready())
             .finish()
     }
 }
@@ -472,17 +472,25 @@ impl Pool {
     }
 
     #[inline]
-    /// Check if pool is pedning
+    /// Check if pool is ready
-    pub fn is_pending(&self) -> bool {
+    pub fn is_ready(&self) -> bool {
         let idx = self.idx.get();
         if idx > 0 {
             if let Some(Entry::Occupied(_)) =
                 self.inner.waiters.borrow().entries.get(idx - 1)
             {
-                return true;
+                return false;
             }
         }
-        false
+        true
+    }
+
+    #[inline]
+    #[doc(hidden)]
+    #[deprecated]
+    /// Check if pool is pedning
+    pub fn is_pending(&self) -> bool {
+        !self.is_ready()
     }
 
     #[doc(hidden)]

ntex-bytes/tests/test_bytes.rs

@@ -1,4 +1,4 @@
-//#![deny(warnings, rust_2018_idioms)]
+#![deny(warnings, rust_2018_idioms)]
 use std::task::Poll;
 
 use ntex_bytes::{Buf, BufMut, Bytes, BytesMut, PoolId};
@@ -665,15 +665,15 @@ async fn pool_usage() {
 
     let buf = BytesMut::with_capacity_in(11 * 1024, p_ref);
     assert_eq!(Poll::Pending, util::lazy(|cx| p1.poll_ready(cx)).await);
-    assert!(p1.is_pending());
+    assert!(!p1.is_ready());
     assert_eq!(Poll::Pending, util::lazy(|cx| p2.poll_ready(cx)).await);
-    assert!(p2.is_pending());
+    assert!(!p2.is_ready());
     time::sleep(time::Millis(50)).await;
     drop(buf);
 
     time::sleep(time::Millis(50)).await;
-    assert!(!p1.is_pending());
+    assert!(p1.is_ready());
-    assert!(!p2.is_pending());
+    assert!(p2.is_ready());
 
     assert_eq!(Poll::Ready(()), util::lazy(|cx| p1.poll_ready(cx)).await);
     assert_eq!(Poll::Ready(()), util::lazy(|cx| p2.poll_ready(cx)).await);
@@ -687,13 +687,13 @@ async fn pool_usage() {
     // pool has some space
     let buf = BytesMut::with_capacity_in(10100, p_ref);
     time::sleep(time::Millis(50)).await;
-    assert!(!p1.is_pending());
+    assert!(p1.is_ready());
-    assert!(p2.is_pending());
+    assert!(!p2.is_ready());
 
     // new pools should wait for next update
     assert_eq!(Poll::Pending, util::lazy(|cx| p1.poll_ready(cx)).await);
     drop(buf);
     time::sleep(time::Millis(50)).await;
-    assert!(!p1.is_pending());
+    assert!(p1.is_ready());
-    assert!(!p2.is_pending());
+    assert!(p2.is_ready());
 }