Struct GameMods 

pub struct GameMods { /* private fields */ }

Combination of GameMods.

Implementations

impl GameMods

pub const fn new() -> Self

Returns empty mods i.e. “NoMod”

pub fn bits(&self) -> u32

Return the accumulated bit values of all contained mods.

Mods that don’t have bit values will be ignored. See https://github.com/ppy/osu-api/wiki#mods

Example

let hdhrdtwu = mods!(Osu: HD HR DT WU);
assert_eq!(hdhrdtwu.bits(), 8 + 16 + 64);

pub fn checked_bits(&self) -> Option<u32>

Return the accumulated bit values of all contained mods.

If any contained mod has no bit value None is returned. See https://github.com/ppy/osu-api/wiki#mods

Example

let hdhrdt = mods!(Osu: HD HR DT);
assert_eq!(hdhrdt.checked_bits(), Some(8 + 16 + 64));

let hdhrdtwu = mods!(Osu: HD HR DT WU);
assert_eq!(hdhrdtwu.checked_bits(), None);

pub fn is_empty(&self) -> bool

Returns true if no mods are contained.

Example

use rosu_mods::{GameMod, GameMods};

let mut mods = GameMods::new();
assert!(mods.is_empty());

mods.insert(GameMod::HiddenOsu(Default::default()));
assert!(!mods.is_empty());

pub fn len(&self) -> usize

Returns the amount of contained mods.

Example

use rosu_mods::{GameMod, GameMods};

let hdhrdt = mods!(Catch: HD HR DT);
assert_eq!(hdhrdt.len(), 3);

let mut nm = GameMods::new();
assert_eq!(nm.len(), 0);
assert_eq!(nm.to_string(), "NM");

pub fn insert(&mut self, gamemod: GameMod)

Add a GameMod

Example

use rosu_mods::{GameMod, GameMods};

let mut mods = GameMods::new();
assert_eq!(mods.to_string(), "NM");

mods.insert(GameMod::TraceableOsu(Default::default()));
assert_eq!(mods.to_string(), "TC");

mods.insert(GameMod::HardRockOsu(Default::default()));
assert_eq!(mods.to_string(), "HRTC");

pub fn contains(&self, gamemod: &GameMod) -> bool

Check whether a given GameMod is contained.

Example

use rosu_mods::GameMod;

let hd = mods!(Taiko: HD);
assert!(hd.contains(&GameMod::HiddenTaiko(Default::default())));
assert!(!hd.contains(&GameMod::HiddenOsu(Default::default())));

pub fn contains_intermode<M>(&self, gamemod: M) -> bool

where GameModIntermode: From<M>,

Check whether a given GameModIntermode is contained.

Example

use rosu_mods::GameModIntermode;

let hd = mods!(Taiko: HD);
assert!(hd.contains_intermode(GameModIntermode::Hidden));
assert!(!hd.contains_intermode(GameModIntermode::HardRock));

pub fn contains_any<I, M>(&self, mods: I) -> bool

where I: IntoIterator<Item = M>, GameModIntermode: From<M>,

Check whether any of the given mods are contained.

Note that this method does not consider the mods’ modes so it could return true even if it’s a different mode.

Example

use rosu_mods::mods;

let hd = mods!(Taiko: HD);

assert!(hd.contains_any(mods!(HD HR)));
assert!(!hd.contains_any(mods!(HR DT)));

// Careful: It returns `true` even if it's a different mode
assert!(hd.contains_any(mods!(Osu: HD)));

pub fn contains_acronym(&self, acronym: Acronym) -> bool

Check whether a given Acronym is contained.

Example

use rosu_mods::Acronym;

let mods = mods!(Osu: NF DT);

let nf = "NF".parse::<Acronym>().unwrap();
assert!(mods.contains_acronym(nf));

let hd = "HD".parse::<Acronym>().unwrap();
assert!(!mods.contains_acronym(hd));

pub fn remove(&mut self, gamemod: &GameMod) -> bool

Remove a GameMod and return whether it was contained.

Example

use rosu_mods::{GameMod, GameMods};

let mut mods: GameMods = mods!(Mania: DT MR);
#*/

assert!(mods.remove(&GameMod::MirrorMania(Default::default())));
assert_eq!(mods.to_string(), "DT");
assert!(!mods.remove(&GameMod::DoubleTimeCatch(Default::default())));

pub fn remove_intermode<M>(&mut self, gamemod: M) -> bool

where GameModIntermode: From<M>,

Remove a gamemod and return whether it was contained.

If the same gamemod is contained for multiple modes, only one of them will be removed.

Example

use rosu_mods::{mods, GameModIntermode, GameMod, GameMods};

let mut mods: GameMods = [
    GameMod::HiddenOsu(Default::default()),
    GameMod::HiddenTaiko(Default::default()),
    GameMod::HardRockOsu(Default::default()),
].into_iter().collect();

assert_eq!(mods.to_string(), "HDHRHD");

assert!(mods.remove_intermode(GameModIntermode::Hidden));
assert_eq!(mods.to_string(), "HRHD");
assert!(!mods.remove_intermode(GameModIntermode::DoubleTime));

pub fn remove_all<'m, I>(&mut self, mods: I)

where I: Iterator<Item = &'m GameMod>,

Remove all mods contained in the iterator.

Example

use rosu_mods::{mods, GameMod, GameMods};

let mut mods: GameMods = mods!(Osu: HD HR WG DT BR);

mods.remove_all([
    GameMod::HiddenOsu(Default::default()),
    GameMod::EasyOsu(Default::default())
].iter());
assert_eq!(mods.to_string(), "DTHRBRWG");

mods.remove_all(mods!(Osu: NF WG).iter());
assert_eq!(mods.to_string(), "DTHRBR")

pub fn remove_all_intermode<I, M>(&mut self, mods: I)

where I: IntoIterator<Item = M>, GameModIntermode: From<M>,

Remove all mods contained in the iterator.

If the same gamemod is contained for multiple modes, each occurence of the gamemod in the iterator will remove only one of the contained gamemods.

Example

use rosu_mods::{mods, GameMod, GameMods};

 let mut mods: GameMods = [
   GameMod::HiddenOsu(Default::default()),
   GameMod::HardRockOsu(Default::default()),
   GameMod::HardRockCatch(Default::default()),
   GameMod::WiggleOsu(Default::default()),
   GameMod::DoubleTimeOsu(Default::default()),
   GameMod::BarrelRollOsu(Default::default()),
 ].into_iter().collect();

assert_eq!(mods.to_string(), "DTHDHRBRWGHR");
mods.remove_all_intermode(mods!(HD HR WG));
assert_eq!(mods.to_string(), "DTBRHR");

pub fn intersection<'m>( &'m self, other: &'m GameMods, ) -> GameModsIntersection<'m>

Returns an iterator over all mods that appear in both GameMods.

Example

use rosu_mods::GameMods;

let hd = mods!(Catch: HD);
let hdhr = mods!(Catch: HD HR);
let mut intersection = hd.intersection(&hdhr);

assert_eq!(intersection.next(), Some(&GameMod::HiddenCatch(Default::default())));
assert_eq!(intersection.next(), None);

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

Check whether the two GameMods have any common mods.

Example

use rosu_mods::GameMods;

let hd = mods!(Catch: HD);
let hr = mods!(Catch: HR);
assert!(!hd.intersects(&hr));

let hdhr = mods!(Catch: HD HR);
assert!(hd.intersects(&hdhr));

pub fn clock_rate(&self) -> Option<f64>

The clock rate of the GameMods.

Returns None if any contained GameMod has no single clock rate.

Example

use rosu_mods::GameMod;

let hd = mods!(Osu: HD);
assert_eq!(hd.clock_rate(), Some(1.0));

let mut hddt = hd;
hddt.insert(GameMod::DoubleTimeOsu(Default::default()));
assert_eq!(hddt.clock_rate(), Some(1.5));

let mut hddtwu = hddt;
hddtwu.insert(GameMod::WindUpOsu(Default::default()));
assert_eq!(hddtwu.clock_rate(), None);

pub fn try_from_intermode( mods: &GameModsIntermode, mode: GameMode, ) -> Option<Self>

Tries to create GameMods from a GameModsIntermode.

Returns None if any contained GameModIntermode is unknown for the given GameMode.

Example

use rosu_mods::{mods, GameMods, GameModsIntermode, GameMode};

let intermode: GameModsIntermode = mods!(DT FI);
let mods = GameMods::try_from_intermode(&intermode, GameMode::Mania).unwrap();

// The FadeIn mod doesn't exist in Taiko
assert!(GameMods::try_from_intermode(&intermode, GameMode::Taiko).is_none());

pub fn from_intermode(mods: &GameModsIntermode, mode: GameMode) -> Self

Create GameMods from a GameModsIntermode.

Any contained GameModIntermode that’s unknown for the given GameMode will be replaced with GameModIntermode::Unknown.

Example

use rosu_mods::{mods, GameMods, GameModsIntermode, GameMode};

let intermode: GameModsIntermode = mods!(DT FI);
let mods = GameMods::from_intermode(&intermode, GameMode::Mania);

// The FadeIn mod doesn't exist in Taiko
let dt = GameMods::from_intermode(&intermode, GameMode::Taiko);

pub fn iter(&self) -> GameModsIter<'_>

Returns an iterator over all contained mods.

Note that the iterator will immediately yield None in case of “NoMod”.

pub fn iter_mut(&mut self) -> GameModsIterMut<'_>

Returns an iterator that allows modifying each contained mod.

Note that the iterator will immediately yield None in case of “NoMod”.

pub fn is_valid(&self) -> bool

Checks whether some contained mods exclude other contained mods.

Example

use rosu_mods::GameMod;

let mut mods = mods!(Osu: EZ);
assert!(mods.is_valid());

mods.insert(GameMod::HardRockOsu(Default::default()));
assert!(!mods.is_valid());

pub fn sanitize(&mut self)

Remove all mods that are excluded by other contained mods.

Example

let mut mods = mods!(Osu: EZ HR);
assert_eq!(mods.to_string(), "EZHR");

mods.sanitize();
assert_eq!(mods.to_string(), "EZ");

pub fn as_legacy(&self) -> GameModsLegacy

Turns GameMods into GameModsLegacy.

pub fn try_as_legacy(&self) -> Option<GameModsLegacy>

Attempts to turns GameMods into GameModsLegacy.

Returns None if any contained GameMod does not have a bit value.

Trait Implementations

impl Archive for GameMods

Available on crate feature rkyv only.

type Archived = <Vec<GameMod> as Archive>::Archived

The archived representation of this type.

type Resolver = VecResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Clone for GameMods

fn clone(&self) -> GameMods

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GameMods

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

Formats the value using the given formatter.

impl Default for GameMods

fn default() -> GameMods

Returns the “default value” for a type.

impl<D: Fallible + ?Sized> Deserialize<GameMods, D> for ArchivedVec<Archived<GameMod>>

Available on crate feature rkyv only.

fn deserialize(&self, deserializer: &mut D) -> Result<GameMods, D::Error>

Deserializes using the given deserializer

impl Display for GameMods

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

Formats the value using the given formatter.

impl Extend<GameMod> for GameMods

fn extend<T: IntoIterator<Item = GameMod>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<GameMod> for GameMods

fn from(gamemod: GameMod) -> Self

Converts to this type from the input type.

impl From<GameMods> for GameModsIntermode

fn from(mods: GameMods) -> Self

Converts to this type from the input type.

impl FromIterator<GameMod> for GameMods

fn from_iter<T: IntoIterator<Item = GameMod>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a GameMods

type Item = <GameModsIter<'a> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = GameModsIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut GameMods

type Item = <GameModsIterMut<'a> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = GameModsIterMut<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for GameMods

fn into_iter(self) -> Self::IntoIter

Turns GameMods into an iterator over all contained mods.

Note that the iterator will immediately yield None in case of “NoMod”.

type Item = GameMod

The type of the elements being iterated over.

type IntoIter = IntoGameModsIter

Which kind of iterator are we turning this into?

impl PartialEq for GameMods

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S: Fallible<Error: Source> + Allocator + Writer + ?Sized> Serialize<S> for GameMods

Available on crate feature rkyv only.

fn serialize(&self, s: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for GameMods

Available on crate feature serde only.

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for GameMods