Struct RecentTracksIterator

pub struct RecentTracksIterator<'a> { /* private fields */ }

Iterator for browsing a user’s recent tracks/scrobbles.

This iterator provides access to the user’s recent listening history with timestamps, which is essential for finding tracks that can be edited. It supports optional timestamp-based filtering to avoid reprocessing old data.

Examples

let mut client = LastFmEditClient::new(Box::new(http_client::native::NativeClient::new()));
// client.login(...).await?;

// Get recent tracks with timestamps
let mut recent = client.recent_tracks();
while let Some(track) = recent.next().await? {
    if let Some(timestamp) = track.timestamp {
        println!("{} - {} ({})", track.artist, track.name, timestamp);
    }
}

// Or stop at a specific timestamp to avoid reprocessing
let last_processed = 1640995200;
let mut recent = client.recent_tracks().with_stop_timestamp(last_processed);
let new_tracks = recent.collect_all().await?;

Implementations

impl<'a> RecentTracksIterator<'a>

pub fn new(client: &'a mut LastFmEditClient) -> Self

Create a new recent tracks iterator.

This is typically called via LastFmEditClient::recent_tracks.

pub fn with_stop_timestamp(self, timestamp: u64) -> Self

Set a timestamp to stop iteration at.

When this is set, the iterator will stop returning tracks once it encounters a track with a timestamp less than or equal to the specified value. This is useful for incremental processing to avoid reprocessing old data.

Arguments

• timestamp - Unix timestamp to stop at

Examples

let mut client = LastFmEditClient::new(Box::new(http_client::native::NativeClient::new()));
let last_processed = 1640995200; // Some previous timestamp

let mut recent = client.recent_tracks().with_stop_timestamp(last_processed);
let new_tracks = recent.collect_all().await?; // Only gets new tracks

Trait Implementations

impl<'a> AsyncPaginatedIterator for RecentTracksIterator<'a>

type Item = Track

The item type yielded by this iterator

async fn next(&mut self) -> Result<Option<Self::Item>>

Fetch the next item from the iterator.

fn current_page(&self) -> u32

Get the current page number (0-indexed).

async fn collect_all(&mut self) -> Result<Vec<Self::Item>>

Collect all remaining items into a Vec.

async fn take(&mut self, n: usize) -> Result<Vec<Self::Item>>

Take up to n items from the iterator.