refactor: Cleanup pager related implementation

src/docs/internals/accessor.rs

@@ -124,7 +124,7 @@
 //!        use AccessorCapability::*;
 //!
 //!        let mut am = AccessorMetadata::default();
-//!        am.set_capabilities(Read | Write | List | Scan | Presign | Multipart | Batch);
+//!        am.set_capabilities(Read | Write | List | Scan | Presign | Batch);
 //!
 //!         am
 //!     }

src/layers/complete.rs

@@ -480,13 +480,13 @@ where
     A: Accessor<Pager = P>,
     P: output::Page,
 {
-    async fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         use CompletePager::*;
 
         match self {
-            AlreadyComplete(p) => p.next_page().await,
-            NeedFlat(p) => p.next_page().await,
-            NeedHierarchy(p) => p.next_page().await,
+            AlreadyComplete(p) => p.next().await,
+            NeedFlat(p) => p.next().await,
+            NeedHierarchy(p) => p.next().await,
         }
     }
 }
@@ -496,13 +496,13 @@ where
     A: Accessor<BlockingPager = P>,
     P: output::BlockingPage,
 {
-    fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         use CompletePager::*;
 
         match self {
-            AlreadyComplete(p) => p.next_page(),
-            NeedFlat(p) => p.next_page(),
-            NeedHierarchy(p) => p.next_page(),
+            AlreadyComplete(p) => p.next(),
+            NeedFlat(p) => p.next(),
+            NeedHierarchy(p) => p.next(),
         }
     }
 }

src/layers/concurrent_limit.rs

@@ -337,13 +337,13 @@ impl<R: output::BlockingWrite> output::BlockingWrite for ConcurrentLimitWrapper<
 
 #[async_trait]
 impl<R: output::Page> output::Page for ConcurrentLimitWrapper<R> {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page().await
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next().await
     }
 }
 
 impl<R: output::BlockingPage> output::BlockingPage for ConcurrentLimitWrapper<R> {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page()
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next()
     }
 }

src/layers/error_context.rs

@@ -296,8 +296,8 @@ pub struct ErrorContextWrapper<T> {
 
 #[async_trait::async_trait]
 impl<T: output::Page> output::Page for ErrorContextWrapper<T> {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page().await.map_err(|err| {
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next().await.map_err(|err| {
             err.with_operation("Page::next_page")
                 .with_context("service", self.scheme)
                 .with_context("path", &self.path)
@@ -306,8 +306,8 @@ impl<T: output::Page> output::Page for ErrorContextWrapper<T> {
 }
 
 impl<T: output::BlockingPage> output::BlockingPage for ErrorContextWrapper<T> {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page().map_err(|err| {
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next().map_err(|err| {
             err.with_operation("Page::next_page")
                 .with_context("service", self.scheme)
                 .with_context("path", &self.path)

src/layers/immutable_index.rs

@@ -254,13 +254,13 @@ impl ImmutableDir {
 
 #[async_trait]
 impl output::Page for ImmutableDir {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         Ok(self.inner_next_page())
     }
 }
 
 impl output::BlockingPage for ImmutableDir {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         Ok(self.inner_next_page())
     }
 }

src/layers/logging.rs

@@ -1244,8 +1244,8 @@ impl<P> LoggingPager<P> {
 
 #[async_trait]
 impl<P: output::Page> output::Page for LoggingPager<P> {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        let res = self.inner.next_page().await;
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        let res = self.inner.next().await;
 
         match &res {
             Ok(Some(des)) => {
@@ -1288,8 +1288,8 @@ impl<P: output::Page> output::Page for LoggingPager<P> {
 }
 
 impl<P: output::BlockingPage> output::BlockingPage for LoggingPager<P> {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        let res = self.inner.next_page();
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        let res = self.inner.next();
 
         match &res {
             Ok(Some(des)) => {

src/layers/retry.rs

@@ -681,11 +681,11 @@ impl<P> RetryPager<P> {
 
 #[async_trait]
 impl<P: output::Page> output::Page for RetryPager<P> {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         if let Some(sleep) = self.sleep.take() {
             tokio::time::sleep(sleep).await;
         }
-        match self.inner.next_page().await {
+        match self.inner.next().await {
             Ok(v) => {
                 // request successful, reset backoff
                 self.reset_backoff();
@@ -720,7 +720,7 @@ impl<P: output::Page> output::Page for RetryPager<P> {
                               "operation={} path={} -> pager retry after {}s: error={:?}",
                               Operation::List, self.path, dur.as_secs_f64(), e);
                         self.sleep = Some(dur);
-                        self.next_page().await
+                        self.next().await
                     }
                 }
             }
@@ -729,8 +729,8 @@ impl<P: output::Page> output::Page for RetryPager<P> {
 }
 
 impl<P: output::BlockingPage> output::BlockingPage for RetryPager<P> {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        { || self.inner.next_page() }
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        { || self.inner.next() }
             .retry(&self.policy)
             .when(|e| e.is_temporary())
             .notify(move |err, dur| {
@@ -859,7 +859,7 @@ mod tests {
     }
     #[async_trait]
     impl output::Page for MockPager {
-        async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
             self.attempt += 1;
             match self.attempt {
                 1 => Err(Error::new(

src/layers/tracing.rs

@@ -322,14 +322,14 @@ impl<R: input::BlockingRead> Read for TracingWrapper<R> {
 #[async_trait]
 impl<R: output::Page> output::Page for TracingWrapper<R> {
     #[tracing::instrument(parent = &self.span, level = "debug", skip_all)]
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page().await
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next().await
     }
 }
 
 impl<R: output::BlockingPage> output::BlockingPage for TracingWrapper<R> {
     #[tracing::instrument(parent = &self.span, level = "debug", skip_all)]
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
-        self.inner.next_page()
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        self.inner.next()
     }
 }

src/object/list.rs

@@ -77,7 +77,7 @@ impl ObjectLister {
                 .pager
                 .as_mut()
                 .expect("pager must be valid")
-                .next_page()
+                .next()
                 .await?
             {
                 // Ideally, the convert from `Vec` to `VecDeque` will not do reallocation.
@@ -124,7 +124,7 @@ impl Stream for ObjectLister {
 
         let mut pager = self.pager.take().expect("pager must be valid");
         let fut = async move {
-            let res = pager.next_page().await;
+            let res = pager.next().await;
 
             (pager, res)
         };
@@ -159,7 +159,7 @@ impl BlockingObjectLister {
         let entries = if !self.buf.is_empty() {
             mem::take(&mut self.buf)
         } else {
-            match self.pager.next_page()? {
+            match self.pager.next()? {
                 // Ideally, the convert from `Vec` to `VecDeque` will not do reallocation.
                 //
                 // However, this could be changed as described in [impl<T, A> From<Vec<T, A>> for VecDeque<T, A>](https://doc.rust-lang.org/std/collections/struct.VecDeque.html#impl-From%3CVec%3CT%2C%20A%3E%3E-for-VecDeque%3CT%2C%20A%3E)
@@ -186,7 +186,7 @@ impl Iterator for BlockingObjectLister {
             return Some(Ok(oe.into_object(self.operator())));
         }
 
-        self.buf = match self.pager.next_page() {
+        self.buf = match self.pager.next() {
             // Ideally, the convert from `Vec` to `VecDeque` will not do reallocation.
             //
             // However, this could be changed as described in [impl<T, A> From<Vec<T, A>> for VecDeque<T, A>](https://doc.rust-lang.org/std/collections/struct.VecDeque.html#impl-From%3CVec%3CT%2C%20A%3E%3E-for-VecDeque%3CT%2C%20A%3E)

src/object/writer.rs

@@ -15,12 +15,14 @@
 use std::fmt::Display;
 use std::io;
 use std::pin::Pin;
-use std::task::{Context, Poll};
+use std::task::Context;
+use std::task::Poll;
 
 use bytes::Bytes;
 use futures::future::BoxFuture;
+use futures::ready;
+use futures::AsyncWrite;
 use futures::FutureExt;
-use futures::{ready, AsyncWrite};
 
 use crate::ops::OpWrite;
 use crate::raw::*;

src/raw/adapters/kv/backend.rs

@@ -260,13 +260,13 @@ impl KvPager {
 
 #[async_trait]
 impl output::Page for KvPager {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         Ok(self.inner_next_page())
     }
 }
 
 impl output::BlockingPage for KvPager {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         Ok(self.inner_next_page())
     }
 }

src/raw/io/output/page.rs

@@ -24,32 +24,32 @@ pub trait Page: Send + Sync + 'static {
     /// Fetch a new page of [`Entry`]
     ///
     /// `Ok(None)` means all object pages have been returned. Any following call
-    /// to `next_page` will always get the same result.
-    async fn next_page(&mut self) -> Result<Option<Vec<Entry>>>;
+    /// to `next` will always get the same result.
+    async fn next(&mut self) -> Result<Option<Vec<Entry>>>;
 }
 
 /// The boxed version of [`Page`]
 pub type Pager = Box<dyn Page>;
 
 #[async_trait]
 impl Page for Pager {
-    async fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
-        self.as_mut().next_page().await
+    async fn next(&mut self) -> Result<Option<Vec<Entry>>> {
+        self.as_mut().next().await
     }
 }
 
 #[async_trait]
 impl Page for () {
-    async fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         Ok(None)
     }
 }
 
 #[async_trait]
 impl<P: Page> Page for Option<P> {
-    async fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         match self {
-            Some(p) => p.next_page().await,
+            Some(p) => p.next().await,
             None => Ok(None),
         }
     }
@@ -60,30 +60,30 @@ pub trait BlockingPage: 'static {
     /// Fetch a new page of [`Entry`]
     ///
     /// `Ok(None)` means all object pages have been returned. Any following call
-    /// to `next_page` will always get the same result.
-    fn next_page(&mut self) -> Result<Option<Vec<Entry>>>;
+    /// to `next` will always get the same result.
+    fn next(&mut self) -> Result<Option<Vec<Entry>>>;
 }
 
 /// BlockingPager is a boxed [`BlockingPage`]
 pub type BlockingPager = Box<dyn BlockingPage>;
 
 impl BlockingPage for BlockingPager {
-    fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
-        self.as_mut().next_page()
+    fn next(&mut self) -> Result<Option<Vec<Entry>>> {
+        self.as_mut().next()
     }
 }
 
 impl BlockingPage for () {
-    fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         Ok(None)
     }
 }
 
 #[async_trait]
 impl<P: BlockingPage> BlockingPage for Option<P> {
-    fn next_page(&mut self) -> Result<Option<Vec<Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<Entry>>> {
         match self {
-            Some(p) => p.next_page(),
+            Some(p) => p.next(),
             None => Ok(None),
         }
     }

src/raw/io/output/to_flat_pager.rs

@@ -98,7 +98,7 @@ where
     A: Accessor<Pager = P>,
     P: output::Page,
 {
-    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    async fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         loop {
             if let Some(de) = self.dirs.pop_back() {
                 let (_, op) = self.acc.list(de.path(), OpList::new()).await?;
@@ -116,7 +116,7 @@ where
             };
 
             if buf.is_empty() {
-                match pager.next_page().await? {
+                match pager.next().await? {
                     Some(v) => {
                         buf = v;
                     }
@@ -155,7 +155,7 @@ where
     A: Accessor<BlockingPager = P>,
     P: output::BlockingPage,
 {
-    fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+    fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
         loop {
             if let Some(de) = self.dirs.pop_back() {
                 let (_, op) = self.acc.blocking_list(de.path(), OpList::new())?;
@@ -173,7 +173,7 @@ where
             };
 
             if buf.is_empty() {
-                match pager.next_page()? {
+                match pager.next()? {
                     Some(v) => {
                         buf = v;
                     }
@@ -267,7 +267,7 @@ mod tests {
     }
 
     impl BlockingPage for MockPager {
-        fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        fn next(&mut self) -> Result<Option<Vec<output::Entry>>> {
             if self.done {
                 return Ok(None);
             }
@@ -298,7 +298,7 @@ mod tests {
 
         let mut entries = Vec::default();
 
-        while let Some(e) = pager.next_page()? {
+        while let Some(e) = pager.next()? {
             entries.extend_from_slice(&e)
         }