Struct WeightedBag

pub struct WeightedBag<T, W: Weight> { /* private fields */ }

Available on crate feature bag only.

A WeightedBag is a collection that holds entries of type T with associated weights of type W.
The weights determine the likelihood of selecting each entry when retrieving a random item from the bag.

Type Parameters

• T: The type of the entries stored in the bag.
• W: A type that implements the Weight trait, representing the weight of each entry.

Features

This struct can derive Serialize and Deserialize traits when the serde feature is enabled.
It can also be constructed from a vector of tuples Vec<(T, W)> containing entries and their corresponding weights.

Example

let mut bag: random::WeightedBag<&str, u32> = random::WeightedBag::default();
bag.add_entry("apple", 2);
bag.add_entry("banana", 1);
let random_fruit: Option<&&str> = bag.try_get_random();

Implementations

impl<T, W: Weight> WeightedBag<T, W>

pub fn add_entry(&mut self, t: T, weight: W)

Adds an entry with given weight to the bag

Panics if the weight is 0

pub fn try_get_random(&self) -> Option<&T>

Retrieve a random entry from the bag, chances are based on weight

pub fn get_random(&self) -> &T

Short hand for WeightedBag::try_get_random.unwrap()

Panics if:

• The bag is empty

Trait Implementations

impl<T: Clone, W: Weight> Clone for WeightedBag<T, W>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, W: Weight + Debug> Debug for WeightedBag<T, W>

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

Formats the value using the given formatter.

impl<T, W: Weight> Default for WeightedBag<T, W>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T, W> Deserialize<'de> for WeightedBag<T, W>

where T: Deserialize<'de>, W: Deserialize<'de> + Weight,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, W: Weight> From<Vec<(T, W)>> for WeightedBag<T, W>

fn from(items: Vec<(T, W)>) -> Self

Converts to this type from the input type.

impl<T, W> Serialize for WeightedBag<T, W>

where T: Serialize, W: Serialize + Weight,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.