Struct rosu_v2::model::matches::OsuMatch

pub struct OsuMatch {
    pub current_game_id: Option<u64>,
    pub end_time: Option<OffsetDateTime>,
    pub events: Vec<MatchEvent>,
    pub first_event_id: u64,
    pub latest_event_id: u64,
    pub match_id: u32,
    pub name: String,
    pub start_time: OffsetDateTime,
    pub users: HashMap<u32, UserCompact>,
}

Fields

current_game_id: Option<u64>

end_time: Option<OffsetDateTime>

events: Vec<MatchEvent>

first_event_id: u64

latest_event_id: u64

match_id: u32

name: String

start_time: OffsetDateTime

users: HashMap<u32, UserCompact>

Maps user ids to users

Implementations

impl OsuMatch

pub fn games(&self) -> MatchGameIter<'_>

Iterate over references of the match’s MatchGames.

pub fn drain_games(&mut self) -> MatchGameDrain<'_>

Return an iterator over all MatchGames of the match.

Note: The games are drained from the match’s events meaning the events field will be empty after this method is called.

Example

use rosu_v2::model::matches::{OsuMatch, MatchEvent, MatchGame};

let mut osu_match = OsuMatch {
    events: vec![
        MatchEvent::Create { ... },
        MatchEvent::Game {
            game: Box::new(MatchGame { game_id: 14, ... }),
            ...
        },
        MatchEvent::Joined { ... },
        MatchEvent::Game {
            game: Box::new(MatchGame { game_id: 52, ... }),
            ...
        },
    ],
    ...
};

assert_eq!(osu_match.events.len(), 4);

{
    // Borrows osu_match mutably, this smaller scope lifts that borrow
    let mut iter = osu_match.drain_games();

    assert!(matches!(iter.next(), Some(MatchGame { game_id: 14, .. })));
    assert!(matches!(iter.next(), Some(MatchGame { game_id: 52, .. })));
    assert!(matches!(iter.next(), None));
}

// Events were drained, hence empty
assert!(osu_match.events.is_empty());

pub async fn get_next(&self, osu: &Osu) -> OsuResult<OsuMatch>

Get the OsuMatch containing only data from some event id onwards.

If the latest game event is an in-progress game, the result will contain all events starting from this game event, inclusively. Otherwise it will contain all events after the currently last event.

Convenient to display a “live” update of the match, e.g. the way an mp link pulls the next result every 10 seconds.

pub fn has_previous(&self) -> bool

The API sends only up to 100 events per request. This method checks whether there are events before the currently first event.

pub async fn get_previous(&self, osu: &Osu) -> Option<OsuResult<OsuMatch>>

Get the OsuMatch containing only data before some event id.

This method returns None either if the events field is empty or if the first event is already contained.

Trait Implementations

impl Clone for OsuMatch

fn clone(&self) -> OsuMatch

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OsuMatch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OsuMatch

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq<OsuMatch> for OsuMatch

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for OsuMatch