Struct StrangePartSet

Source

pub struct StrangePartSet { /* private fields */ }

Expand description

Contains up to 3 strange parts. Although the underlying data structure is an array, this structure behaves like a set. Most methods mimic those of HashSet.

This struct solves the following problems:

An item can only hold up to 3 strange parts.
An item cannot have duplicate strange parts.
Comparing strange parts for equality is order-agnostic.
Hashing is order-agnostic.
The type is Copy, allowing for cheap and easy duplication.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
// Create a set for strange parts with two strange parts.
let mut strange_parts = StrangePartSet::double(
    StrangePart::CriticalKills,
    StrangePart::DamageDealt,
);
 
// Check that strange parts contains Damage Dealt.
assert!(strange_parts.contains(&StrangePart::DamageDealt));
assert_eq!(strange_parts.len(), 2);
 
// Add a strange part.
strange_parts.insert(StrangePart::EngineersKilled);
 
assert_eq!(strange_parts.len(), 3);
 
// If a strange part is added when strange parts are full, the insert will fail.
assert!(!strange_parts.insert(StrangePart::MedicsKilled));
assert!(!strange_parts.contains(&StrangePart::MedicsKilled));
 
// Iterate over strange parts.
for strange_part in strange_parts {
    println!("{strange_part}");
}

Implementations§

Source §

impl StrangePartSet

Source

pub fn new() -> Self

Creates a set for strange parts.

§Examples

use tf2_enum::StrangePartSet;
 
let strange_parts = StrangePartSet::new();

Source

pub fn single(strange_part: StrangePart) -> Self

Creates a set for strange parts with one strange part.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts = StrangePartSet::single(
    StrangePart::DamageDealt,
);
 
assert_eq!(strange_parts.len(), 1);

Source

pub fn double(strange_part1: StrangePart, strange_part2: StrangePart) -> Self

Creates a set for strange parts with two strange parts.

If the same strange part is added multiple times, only one will be kept.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts = StrangePartSet::double(
    StrangePart::DamageDealt,
    StrangePart::CriticalKills,
);
 
assert_eq!(strange_parts.len(), 2);

Source

pub fn triple( strange_part1: StrangePart, strange_part2: StrangePart, strange_part3: StrangePart, ) -> Self

Creates a set for strange parts with two strange parts.

If the same strange part is added multiple times, only one will be kept.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts = StrangePartSet::triple(
    StrangePart::DamageDealt,
    StrangePart::CriticalKills,
    StrangePart::EngineersKilled,
);
 
assert_eq!(strange_parts.len(), 3);

Source

pub fn clear(&mut self)

Clears the set, removing all strange parts.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let mut strange_parts = StrangePartSet::double(
    StrangePart::CriticalKills,
    StrangePart::DamageDealt,
);
 
strange_parts.clear();
 
assert_eq!(strange_parts.len(), 0);

Source

pub fn insert(&mut self, strange_part: StrangePart) -> bool

Adds a strange part to the first available slot. If no slots are available, the new strange part will be ignored.

Returns false if:

The strange part is already in the set.
The set is full.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let mut strange_parts = StrangePartSet::double(
    StrangePart::CriticalKills,
    StrangePart::DamageDealt,
);
 
assert_eq!(strange_parts.len(), 2);
 
strange_parts.insert(StrangePart::EngineersKilled);
 
assert_eq!(strange_parts.len(), 3);
 
// Strange parts are full.
assert!(!strange_parts.insert(StrangePart::MedicsKilled));

Source

pub fn remove(&mut self, strange_part: &StrangePart) -> bool

Removes a strange part.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let mut strange_parts = StrangePartSet::single(StrangePart::CriticalKills);
 
assert!(strange_parts.remove(&StrangePart::CriticalKills));
assert!(!strange_parts.contains(&StrangePart::CriticalKills));

Source

pub fn take(&mut self, strange_part: &StrangePart) -> Option<StrangePart>

Removes and returns the strange part in the set, if any, that is equal to the given one.

Source

pub fn is_empty(&self) -> bool

Returns true if the set contains no strange parts.

Source

pub fn contains(&self, strange_part: &StrangePart) -> bool

Returns true if the set contains a strange part.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts = StrangePartSet::from([
    Some(StrangePart::CriticalKills),
    Some(StrangePart::DamageDealt),
    None,
]);
 
assert!(strange_parts.contains(&StrangePart::CriticalKills));

Source

pub fn len(&self) -> usize

Returns the number of strange parts in the set.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
 
assert_eq!(strange_parts.len(), 2);

Source

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

Returns the strange parts that are in self but not in other.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts1 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
let strange_parts2 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::EngineersKilled);
let difference = strange_parts1.difference(&strange_parts2);
 
assert_eq!(difference, StrangePartSet::single(StrangePart::CriticalKills));
 
let difference = strange_parts2.difference(&strange_parts1);
 
assert_eq!(difference, StrangePartSet::single(StrangePart::EngineersKilled));

Source

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

Returns the strange parts that are both in self and other.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts1 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
let strange_parts2 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::EngineersKilled);
let intersection = strange_parts1.intersection(&strange_parts2);
 
assert_eq!(intersection, StrangePartSet::single(StrangePart::DamageDealt));

Source

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

Returns true if self has no strange parts in common with other. This is equivalent to checking for an empty intersection.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};
 
let strange_parts1 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
let strange_parts2 = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::EngineersKilled);
 
assert!(!strange_parts1.is_disjoint(&strange_parts2));

Source

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

Returns true if the set is a subset of another, i.e., other contains at least all the values in self.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};

let sup = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
let mut strange_parts = StrangePartSet::single(StrangePart::DamageDealt);

assert!(strange_parts.is_subset(&sup));
 
strange_parts.insert(StrangePart::EngineersKilled);
 
assert!(!strange_parts.is_subset(&sup));

Source

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

Returns true if the set is a superset of another, i.e., self contains at least all the values in other.

§Examples

use tf2_enum::{StrangePartSet, StrangePart};

let sub = StrangePartSet::double(StrangePart::DamageDealt, StrangePart::CriticalKills);
let mut strange_parts = StrangePartSet::new();

assert!(!strange_parts.is_superset(&sub));
 
strange_parts.insert(StrangePart::DamageDealt);
 
assert!(!strange_parts.is_superset(&sub));
 
strange_parts.insert(StrangePart::CriticalKills);
 
assert!(strange_parts.is_superset(&sub));