Struct ezra::dice::dice_collection::DiceCollection

pub struct DiceCollection<T: Die> { /* fields omitted */ }

A collection of dice.

Methods

impl<T: Die> DiceCollection<T>

fn new() -> Self

Pseudo-constructor for DiceCollection.

Return Value

An empty DiceCollection

Examples

use ezra::dice::{NumericDie,DiceCollection};

// Create a new dice collection and add a standard 6-sided die to it
let mut dice = DiceCollection::<NumericDie>::new();
dice.add(NumericDie::new(1, 1, 6, None));

assert_eq!(dice.size(), 1);

fn add(&mut self, die: T) -> &mut Self

Add a die to the collection.

Parameters

die : die to add to collection

Return value

A mutable reference to the collection

Examples

use ezra::dice::{NumericDie,DiceCollection};

let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie());
dice.add(mkdie());
dice.add(mkdie());

assert_eq!(dice.size(), 3);

This operation may also be chained:

let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie())
    .add(mkdie())
    .add(mkdie());

assert_eq!(dice.size(), 3);

fn clear(&mut self) -> &mut Self

Remove all dice from the collection.

Return value

A mutable reference to the DiceCollection

Examples

use ezra::dice::{NumericDie,DiceCollection};

let mut dice = DiceCollection::<NumericDie>::new();
dice.add(NumericDie::new(1, 1, 6, None));

assert_eq!(dice.size(), 1);

dice.clear();
assert!(dice.is_empty());

This operation may also be chained:

let mut dice = DiceCollection::<NumericDie>::new();
dice.add(NumericDie::new(1, 1, 6, None));

assert!(dice.clear().is_empty());

fn roll_all(&mut self) -> &mut Self

Roll all dice in the collection.

Return value

A mutable reference to the DiceCollection

Examples

use ezra::dice::{NumericDie,DiceCollection};
 
let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie())
    .add(mkdie())
    .add(mkdie())
    .roll_all();

println!("After 1 roll, the sum of the dice is {}", dice.total());

This operation may also be chained:

let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie()).roll_all().roll_all().roll_all();
 
println!("After 3 roll, the sum of the dice is {}", dice.total());

fn is_empty(&self) -> bool

Determine if the collection contains dice.

Return value

• true : no dice are in the collection
• false : the collection contains one or more dice

Examples

use ezra::dice::{NumericDie,DiceCollection};

let mut dice = DiceCollection::new();
assert!(dice.is_empty());

dice.add(NumericDie::new(1, 1, 6, None));
assert!(!dice.is_empty());

fn size(&self) -> usize

Obtain the number of dice in the collection.

Return value

The number of dice in the collection

Examples

use ezra::dice::{DiceCollection,NumericDie};

let mut dice = DiceCollection::new();
assert_eq!(dice.size(), 0);

dice.add(NumericDie::new(1, 1, 6, None));
assert_eq!(dice.size(), 1);

fn iter(&self) -> Iter<T>

Obtain an immutable iterator across all dice in the collection

Return value

An immutable iterator across all dice in the collection

Exampes

use ezra::dice::{Die,DiceCollection, NumericDie};

let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie())
    .add(mkdie())
    .add(mkdie());

for (i,die) in dice.iter().enumerate() {
    println!("Die {} has value {}.", i, die.get_value());
}

fn iter_mut(&mut self) -> IterMut<T>

Obtain a mutable iterator across all dice in the collection.

Return Value

A mutable iterator across all dice in the collection.

Examples

use ezra::dice::{Die,DiceCollection,NumericDie};

let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie())
    .add(mkdie())
    .add(mkdie());

for die in dice.iter_mut() {
    die.roll();
}

println!("After rolling each die once, their total is {}", dice.total());

impl<V: Add<V, Output=V>, T: Die<ValueType=V>> DiceCollection<T>

fn total(&self) -> V

Calculate the sum of all dice values.

In order to use this method, the associated ValueType of the dice in the collection must implement the Add trait.

Return value

The sum of all dice values

Examples

use ezra::dice::{NumericDie,DiceCollection};
 
let mkdie = || { NumericDie::new(1, 1, 6, None) };
let mut dice = DiceCollection::<NumericDie>::new();

dice.add(mkdie())
    .add(mkdie())
    .add(mkdie())
    .roll_all();

println!("After 1 roll, the sum of the dice is {}", dice.total());

impl<V: Eq + Hash, T: Die<ValueType=V>> DiceCollection<T>

fn summary(&self) -> HashMap<T::ValueType, usize>

Produce a summary of the state of all dice in the collection.

The summary is a table of value types and their occurence count within the dice values in the DiceCollection. In order to use this function, the associated ValueType of the dice in the collection must implement the Eq and Hash traits.

Return Value

A HashMap with keys for each possible die value, with values corresponding to the number of occurrences of that key in the multiset of die values in the collection.

Examples

use ezra::dice::{ValueDie,DiceCollection};

// Values a die may have
#[derive(Copy,Clone,Debug,Hash,Eq,PartialEq)]
enum DiceValues {
    Value1,
    Value2,
    Value3,
}

let values = vec![DiceValues::Value1, DiceValues::Value2, DiceValues::Value3];
let mkdie = || { ValueDie::new(values, None) };
let mut dice = DiceCollection::<ValueDie<DiceValues>>::new();
dice.roll_all();

let summary = dice.summary();
for key in summary.keys() {
    println!("Value {:?} occured {} time(s)", key, summary.get(key).unwrap()); 
}

Trait Implementations

impl<T: Die + Display> Display for DiceCollection<T>

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

Formats the value using the given formatter.