Struct GameModsIntermode 

pub struct GameModsIntermode { /* private fields */ }

Combination of GameModIntermodes.

Implementations

impl GameModsIntermode

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

use rosu_mods::mods;

let hdhrdtwu = mods!(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

use rosu_mods::mods;

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

let hdhrdtwu = mods!(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::{GameModIntermode, GameModsIntermode};

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

mods.insert(GameModIntermode::Hidden);
assert!(!mods.is_empty());

pub fn len(&self) -> usize

Returns the amount of contained mods.

Example

use rosu_mods::{mods, GameModIntermode, GameModsIntermode};

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

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

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

Add a GameModIntermode

Example

use rosu_mods::{GameModIntermode, GameModsIntermode};

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

mods.insert(GameModIntermode::Traceable);
assert_eq!(mods.to_string(), "TC");

mods.insert(GameModIntermode::HardRock);
assert_eq!(mods.to_string(), "HRTC");

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

where GameModIntermode: From<M>,

Check whether a given mod is contained.

Example

use rosu_mods::{mods, GameModIntermode};

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

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

Check whether a given Acronym is contained.

Example

use rosu_mods::{mods, Acronym};

let nc = mods!(NC);
assert!(nc.contains_acronym("NC".parse::<Acronym>().unwrap()));
assert!(!nc.contains_acronym("DT".parse::<Acronym>().unwrap()));

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

where GameModIntermode: From<M>,

Remove a gamemod and return whether it was contained.

Example

use rosu_mods::{mods, GameModIntermode, GameModsIntermode};

let mut mods: GameModsIntermode = mods!(HD HR);

assert!(mods.remove(GameModIntermode::Hidden));
assert_eq!(mods.to_string(), "HR");
assert!(!mods.remove(GameModIntermode::DoubleTime));

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

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

Remove all mods contained in the iterator.

Example

use rosu_mods::{mods, GameModIntermode, GameModsIntermode};

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

mods.remove_all([GameModIntermode::Hidden, GameModIntermode::Easy]);
assert_eq!(mods.to_string(), "DTHRBRWG");

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

pub fn from_bits(bits: u32) -> Self

Parse bitflags into GameModsIntermode

Example

use rosu_mods::{mods, GameModsIntermode};

let bits = 8 + 64 + 512 + 1024;
assert_eq!(GameModsIntermode::from_bits(bits), mods!(FL HD NC))

pub fn try_from_acronyms(s: &str) -> Option<Self>

Try to parse a combination of mod acronyms into GameModsIntermode.

Returns None if an unknown acronym was encountered.

Example

use rosu_mods::GameModsIntermode;

let hdhrwu = GameModsIntermode::try_from_acronyms("HRWUHD").unwrap();
assert_eq!(hdhrwu.to_string(), "HDHRWU");

assert!(GameModsIntermode::try_from_acronyms("QQQ").is_none());

pub fn from_acronyms(s: &str) -> Self

Parse a combination of mod acronyms into GameModsIntermode.

Example

use rosu_mods::GameModsIntermode;

let hdhrwu = GameModsIntermode::from_acronyms("HRWUHD");
assert_eq!(hdhrwu.len(), 3);
assert_eq!(hdhrwu.to_string(), "HDHRWU");

let mut iter = GameModsIntermode::from_acronyms("QQhdQ").into_iter();
assert_eq!(iter.next().unwrap().to_string(), "HDQ"); // unknown mod
assert_eq!(iter.next().unwrap().to_string(), "QQ");  // unknown mod
assert!(iter.next().is_none());

pub fn intersection<'m>( &'m self, other: &'m GameModsIntermode, ) -> GameModsIntermodeIntersection<'m>

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

Example

use rosu_mods::{mods, GameModIntermode};

let hd = mods!(HD);
let hdhr = mods!(HD HR);
let mut intersection = hd.intersection(&hdhr);
assert_eq!(intersection.next(), Some(GameModIntermode::Hidden));
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::mods;

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

pub fn legacy_clock_rate(&self) -> f64

The legacy clock rate of the GameModsIntermode.

Looks for the first occurrence of DT, NC, HT, or DC and returns 1.5, 0.75, or 1.0 accordingly.

Example

use rosu_mods::{mods, GameModIntermode};

let hd = mods!(HD);
assert_eq!(hd.legacy_clock_rate(), 1.0);

let mut hddt = hd;
hddt.insert(GameModIntermode::DoubleTime);
assert_eq!(hddt.legacy_clock_rate(), 1.5);

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

Returns an iterator over all contained mods.

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

pub fn try_with_mode(&self, mode: GameMode) -> Option<GameMods>

Tries to turn a GameModsIntermode into a GameMods.

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

Example

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

let dtfi: GameMods = mods!(DT FI).try_with_mode(GameMode::Mania).unwrap();

// The FadeIn mod doesn't exist in Taiko
assert!(mods!(DT FI).try_with_mode(GameMode::Taiko).is_none());

pub fn with_mode(&self, mode: GameMode) -> GameMods

Turn a GameModsIntermode into a GameMods.

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

Example

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

let dtfi: GameMods = mods!(DT FI).with_mode(GameMode::Mania);

// The FadeIn mod doesn't exist in Taiko
let dt_unknown: GameMods = mods!(DT FI).with_mode(GameMode::Taiko);
assert_eq!(dt_unknown.to_string(), "DTFI");

pub fn as_legacy(&self) -> GameModsLegacy

Turns GameModsIntermode into GameModsLegacy.

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

Attempts to turns GameModsIntermode into GameModsLegacy.

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

Trait Implementations

impl Archive for GameModsIntermode

Available on crate feature rkyv only.

type Archived = <Vec<GameModIntermode> 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 BitOr<GameModIntermode> for GameModsIntermode

fn bitor(self, rhs: GameModIntermode) -> Self::Output

Adds a GameModIntermode to the GameModsIntermode.

type Output = GameModsIntermode

The resulting type after applying the | operator.

impl BitOrAssign<GameModIntermode> for GameModsIntermode

fn bitor_assign(&mut self, rhs: GameModIntermode)

Adds a GameModIntermode to the GameModsIntermode.

impl Clone for GameModsIntermode

fn clone(&self) -> GameModsIntermode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GameModsIntermode

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

Formats the value using the given formatter.

impl Default for GameModsIntermode

fn default() -> GameModsIntermode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GameModsIntermode

Available on crate feature serde only.

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

Deserialize this value from the given Serde deserializer.

impl<D: Fallible + ?Sized> Deserialize<GameModsIntermode, D> for ArchivedVec<Archived<GameModIntermode>>

Available on crate feature rkyv only.

fn deserialize(&self, _: &mut D) -> Result<GameModsIntermode, D::Error>

Deserializes using the given deserializer

impl Display for GameModsIntermode

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

Formats the value using the given formatter.

impl<M> Extend<M> for GameModsIntermode

where GameModIntermode: From<M>,

fn extend<T: IntoIterator<Item = M>>(&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<GameModIntermode> for GameModsIntermode

fn from(gamemod: GameModIntermode) -> 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 From<GameModsLegacy> for GameModsIntermode

fn from(mods: GameModsLegacy) -> Self

Converts to this type from the input type.

impl<M> FromIterator<M> for GameModsIntermode

where GameModIntermode: From<M>,

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

Creates a value from an iterator.

impl FromStr for GameModsIntermode

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for GameModsIntermode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a GameModsIntermode

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

The type of the elements being iterated over.

type IntoIter = GameModsIntermodeIter<'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 GameModsIntermode

fn into_iter(self) -> Self::IntoIter

Turns GameModsIntermode into an iterator over all contained mods.

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

type Item = GameModIntermode

The type of the elements being iterated over.

type IntoIter = IntoGameModsIntermodeIter

Which kind of iterator are we turning this into?

impl PartialEq for GameModsIntermode

fn eq(&self, other: &GameModsIntermode) -> 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 + Allocator + Writer + ?Sized> Serialize<S> for GameModsIntermode

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 GameModsIntermode

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 Sub<GameModIntermode> for GameModsIntermode

fn sub(self, rhs: GameModIntermode) -> Self::Output

Removes a GameModIntermode from the GameModsIntermode

type Output = GameModsIntermode

The resulting type after applying the - operator.

impl SubAssign<GameModIntermode> for GameModsIntermode

fn sub_assign(&mut self, rhs: GameModIntermode)

Removes a GameModIntermode from the GameModsIntermode

impl Eq for GameModsIntermode

impl StructuralPartialEq for GameModsIntermode