examples/musicbrainz_api/browse.rs

@@ -3,7 +3,7 @@ use std::{thread, time};
 use musichoard::{
     collection::musicbrainz::Mbid,
     external::musicbrainz::{
-        api::{browse::BrowseReleaseGroupRequest, MusicBrainzClient, PageSettings},
+        api::{browse::BrowseReleaseGroupRequest, MusicBrainzClient, NextPage, PageSettings},
         http::MusicBrainzHttp,
     },
 };
@@ -71,10 +71,10 @@ fn main() {
 
                     println!("Release groups in this response: {count}");
 
-                    paging = match response.page.next_page(paging, count) {
-                        Some(paging) => paging,
-                        None => break,
-                    };
+                    match response.page.next_page_offset(count) {
+                        NextPage::Offset(next_offset) => paging.set_offset(next_offset),
+                        NextPage::Complete => break,
+                    }
 
                     thread::sleep(time::Duration::from_secs(1));
                 }

src/external/musicbrainz/api/browse.rs

@@ -6,7 +6,7 @@ use crate::{
     collection::musicbrainz::Mbid,
     external::musicbrainz::{
         api::{
-            ApiDisplay, Error, MbReleaseGroupMeta, MusicBrainzClient, PageSettings,
+            ApiDisplay, Error, MbReleaseGroupMeta, MusicBrainzClient, NextPage, PageSettings,
             SerdeMbReleaseGroupMeta, MB_BASE_URL,
         },
         IMusicBrainzHttp,
@@ -21,8 +21,8 @@ pub struct BrowseReleaseGroupPage {
 }
 
 impl BrowseReleaseGroupPage {
-    pub fn next_page(&self, settings: PageSettings, page_count: usize) -> Option<PageSettings> {
-        settings.next_page(
+    pub fn next_page_offset(&self, page_count: usize) -> NextPage {
+        NextPage::next_page_offset(
             self.release_group_offset,
             self.release_group_count,
             page_count,
@@ -125,7 +125,7 @@ mod tests {
             release_group_count: 45,
         };
 
-        next_page_test(|val| page.next_page(PageSettings::default(), val));
+        next_page_test(|val| page.next_page_offset(val));
     }
 
     #[test]

src/external/musicbrainz/api/mod.rs

@@ -87,13 +87,25 @@ impl PageSettings {
     pub fn set_offset(&mut self, offset: usize) {
         self.offset = Some(offset);
     }
+}
 
-    pub fn next_page(self, offset: usize, total_count: usize, page_count: usize) -> Option<Self> {
+#[derive(Debug, PartialEq, Eq)]
+pub enum NextPage {
+    Offset(usize),
+    Complete,
+}
+
+impl NextPage {
+    pub fn new() -> NextPage {
+        NextPage::Offset(0)
+    }
+
+    pub fn next_page_offset(offset: usize, total_count: usize, page_count: usize) -> NextPage {
         let next_offset = offset + page_count;
         if next_offset < total_count {
-            Some(self.with_offset(next_offset))
+            NextPage::Offset(next_offset)
         } else {
-            None
+            NextPage::Complete
         }
     }
 }
@@ -358,21 +370,21 @@ mod tests {
 
     pub fn next_page_test<Fn>(mut f: Fn)
     where
-        Fn: FnMut(usize) -> Option<PageSettings>,
+        Fn: FnMut(usize) -> NextPage,
     {
         let next = f(20);
-        assert_eq!(next.unwrap().offset, Some(25));
+        assert_eq!(next, NextPage::Offset(25));
 
         let next = f(40);
-        assert!(next.is_none());
+        assert_eq!(next, NextPage::Complete);
 
         let next = f(100);
-        assert!(next.is_none());
+        assert_eq!(next, NextPage::Complete);
     }
 
     #[test]
     fn next_page() {
-        next_page_test(|val| PageSettings::default().next_page(5, 45, val));
+        next_page_test(|val| NextPage::next_page_offset(5, 45, val));
     }
 
     #[test]

src/external/musicbrainz/api/search/mod.rs

@@ -23,6 +23,8 @@ use crate::external::musicbrainz::{
     IMusicBrainzHttp,
 };
 
+use super::NextPage;
+
 #[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
 #[serde(rename_all(deserialize = "kebab-case"))]
 pub struct SearchPage {
@@ -31,8 +33,8 @@ pub struct SearchPage {
 }
 
 impl SearchPage {
-    pub fn next_page(&self, settings: PageSettings, page_count: usize) -> Option<PageSettings> {
-        settings.next_page(self.offset, self.count, page_count)
+    pub fn next_page_offset(&self, page_count: usize) -> NextPage {
+        NextPage::next_page_offset(self.offset, self.count, page_count)
     }
 }
 
@@ -76,6 +78,6 @@ mod tests {
             count: 45,
         };
 
-        next_page_test(|val| page.next_page(PageSettings::default(), val));
+        next_page_test(|val| page.next_page_offset(val));
     }
 }

src/tui/lib/external/musicbrainz/api/mod.rs

@@ -25,7 +25,7 @@ use musichoard::{
     },
 };
 
-use crate::tui::lib::interface::musicbrainz::api::{Entity, Error, IMusicBrainz};
+use crate::tui::lib::interface::musicbrainz::api::{Entity, Error, IMusicBrainz, Paged};
 
 // GRCOV_EXCL_START
 pub struct MusicBrainz<Http> {
@@ -97,17 +97,17 @@ impl<Http: IMusicBrainzHttp> IMusicBrainz for MusicBrainz<Http> {
     fn browse_release_group(
         &mut self,
         artist: &Mbid,
-        paging: &mut Option<PageSettings>,
-    ) -> Result<Vec<Entity<AlbumMeta>>, Error> {
+        paging: &mut PageSettings,
+    ) -> Result<Paged<Vec<Entity<AlbumMeta>>>, Error> {
         let request = BrowseReleaseGroupRequest::artist(artist);
 
-        let page = paging.take().unwrap_or_default();
-        let mb_response = self.client.browse_release_group(&request, &page)?;
+        let mb_response = self.client.browse_release_group(&request, paging)?;
 
         let page_count = mb_response.release_groups.len();
-        *paging = mb_response.page.next_page(page, page_count);
+        let next = mb_response.page.next_page_offset(page_count);
+        let item = from_browse_release_group_response(mb_response);
 
-        Ok(from_browse_release_group_response(mb_response))
+        Ok(Paged { item, next })
     }
 }
 

src/tui/lib/external/musicbrainz/daemon/mod.rs

@@ -1,12 +1,12 @@
 use std::{collections::VecDeque, sync::mpsc, thread, time};
 
-use musichoard::external::musicbrainz::api::PageSettings;
+use musichoard::external::musicbrainz::api::{NextPage, PageSettings};
 
 use crate::tui::{
     app::EntityMatches,
     event::IFetchCompleteEventSender,
     lib::interface::musicbrainz::{
-        api::{Error as ApiError, IMusicBrainz},
+        api::{Error as ApiError, IMusicBrainz, Paged},
         daemon::{
             BrowseParams, EntityList, Error, IMbJobSender, LookupParams, MbParams, MbReturn,
             ResultSender, SearchParams,
@@ -228,10 +228,13 @@ impl JobInstance {
         event_sender: &mut dyn IFetchCompleteEventSender,
     ) -> Result<JobInstanceStatus, JobInstanceError> {
         // self.requests can be empty if the caller submits an empty job.
-        if let Some(params) = self.requests.front() {
-            let result_sender = &mut self.result_sender;
-            let paging = &mut self.paging;
-            Self::execute(musicbrainz, result_sender, event_sender, &params, paging)?;
+        self.paging = match self.requests.front() {
+            Some(params) => {
+                let result_sender = &mut self.result_sender;
+                let paging = self.paging.take();
+                Self::execute(musicbrainz, result_sender, event_sender, &params, paging)?
+            }
+            None => None,
         };
 
         if self.paging.is_none() {
@@ -250,11 +253,13 @@ impl JobInstance {
         result_sender: &mut ResultSender,
         event_sender: &mut dyn IFetchCompleteEventSender,
         api_params: &MbParams,
-        paging: &mut Option<PageSettings>,
-    ) -> Result<(), JobInstanceError> {
-        if paging.is_none() {
-            *paging = Some(PageSettings::with_max_limit());
-        }
+        paging: Option<PageSettings>,
+    ) -> Result<Option<PageSettings>, JobInstanceError> {
+        let mut paging = match paging {
+            Some(paging) => paging,
+            None => PageSettings::with_max_limit(),
+        };
+        let mut next_page = NextPage::Complete;
 
         let result = match api_params {
             MbParams::Lookup(lookup) => match lookup {
@@ -280,13 +285,20 @@ impl JobInstance {
             }
             .map(MbReturn::Match),
             MbParams::Browse(browse) => match browse {
-                BrowseParams::ReleaseGroup(params) => musicbrainz
-                    .browse_release_group(&params.artist, paging)
-                    .map(|rv| EntityList::Album(rv.into_iter().map(|rg| rg.entity).collect())),
+                BrowseParams::ReleaseGroup(params) => Paged::map_paged_result(
+                    musicbrainz.browse_release_group(&params.artist, &mut paging),
+                    |ents| EntityList::Album(ents.into_iter().map(|rg| rg.entity).collect()),
+                    &mut next_page,
+                ),
             }
             .map(MbReturn::Fetch),
         };
-        Self::return_result(result_sender, event_sender, result)
+        Self::return_result(result_sender, event_sender, result)?;
+
+        Ok(match next_page {
+            NextPage::Offset(offset) => Some(paging.with_offset(offset)),
+            NextPage::Complete => None,
+        })
     }
 
     fn return_result(

src/tui/lib/interface/musicbrainz/api/mod.rs

@@ -1,11 +1,13 @@
 //! Module for accessing MusicBrainz metadata.
 
+use std::mem;
+
 #[cfg(test)]
 use mockall::automock;
 
 use musichoard::{
     collection::{album::AlbumMeta, artist::ArtistMeta, musicbrainz::Mbid},
-    external::musicbrainz::api::PageSettings,
+    external::musicbrainz::api::{NextPage, PageSettings},
 };
 
 #[cfg_attr(test, automock)]
@@ -21,8 +23,8 @@ pub trait IMusicBrainz {
     fn browse_release_group(
         &mut self,
         artist: &Mbid,
-        paging: &mut Option<PageSettings>,
-    ) -> Result<Vec<Entity<AlbumMeta>>, Error>;
+        paging: &mut PageSettings,
+    ) -> Result<Paged<Vec<Entity<AlbumMeta>>>, Error>;
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -42,4 +44,31 @@ impl<T> Entity<T> {
     }
 }
 
+pub struct Paged<T> {
+    pub item: T,
+    pub next: NextPage,
+}
+
+// pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U, E> {
+//     match self {
+//         Ok(t) => Ok(op(t)),
+//         Err(e) => Err(e),
+//     }
+// }
+
+impl<T> Paged<T> {
+    pub fn map_paged_result<E, U, F: FnOnce(T) -> U>(
+        result: Result<Paged<T>, E>,
+        op: F,
+        next: &mut NextPage,
+    ) -> Result<U, E> {
+        match result {
+            Ok(paged) => {
+                _ = mem::replace(next, paged.next);
+                Ok(op(paged.item))
+            }
+            Err(err) => Err(err),
+        }
+    }
+}
 pub type Error = musichoard::external::musicbrainz::api::Error;