Struct ultra_tournament::Tournament

pub struct Tournament<E: Debug + Display + Clone, M: Debug + Display + Clone + Default, B: BattleSystem<E, M>> { /* fields omitted */ }

Tournament<E, M, B> is the core structure of the package. Creates a single-elimination tournament bracket.

• E - The entrant structs that will battle each other. Must implement Debug, Display and Clone.
  • Internally, these are cloned, then stored as Arc<RwLock<E>>, and are accessed through them after the tournament is created.
• M - The metadata struct that is added to rounds after being completed. Must implement Debug, Display, Clone and Default
• B - The battle system that solves rounds between two entrants of type E. Must implement BattleSystem<E, M>

Implementations

impl<E: Debug + Display + Clone, M: Debug + Display + Clone + Default, B: BattleSystem<E, M>> Tournament<E, M, B>

pub fn new(entrants: Vec<E>) -> Result<Self>

Create a new Tournament from a Vec<E> of entrant structs. Brackets are assigned in the Vec<E>'s order.

Example

Create a Tournament that battles a vec of u32s

use crate::{ MyBattleSystem, MyMetadata };

let entrants = vec![1, 2, 3, 23, 35, 483, 9494, 9, 0, 102, 48];

let t = Tournament::<u32, MyMetadata, MyBattleSystem>::new(entrants);

pub fn new_from_gen(size: usize, gen: fn() -> E) -> Result<Self>

Created a new Tournament of a specified number of entrants, using a generation closure that returns a new entrant.

Example

Create a Tournament that battles 200 randomly generated u32s

use rand::prelude::*;
use crate::{ MyBattleSystem, MyMetadata };

let t = Tournament::<u32, MyMetadata, MyBattleSystem>::new_from_gen(
	200,
	|| random::<u32>()
);

pub fn len_entrants(&self) -> usize

Get the number of entrants in the tournament.

pub fn len_rounds(&self) -> usize

Get the number of rounds in the tournament, complete and incomplete.

pub fn len_rounds_complete(&self) -> usize

Get the number of completed rounds in the tournament.

pub fn len_rounds_incomplete(&self) -> usize

Get the number of incomplete rounds in the tournament.

pub fn entrant(&self, id: EntrantId) -> Arc<RwLock<E>>

Get an Arc<RwLock<E>> encapsulating an entrant of specified EntrantId

pub fn grand_finals(&self) -> &NodeIndex

Get a ref to the NodeIndex of the tournament's final round.

pub fn graph(&self) -> &Graph<TournamentNode<M>, TournamentEdge>

Get a ref to the internal Graph used by the tournament. ultra_tournament is built using the petgraph crate.

pub fn child_node(
    &self,
    id: NodeIndex,
    target: TournamentEdge
) -> Result<NodeIndex>

Get the NodeIndex of a round leading to one with the index id. Uses the TournamentEdge to specify either A or B

pub fn child_nodes(&self, id: NodeIndex) -> Result<(NodeIndex, NodeIndex)>

Get a tuple of the NodeIndexes of the previous rounds that lead to one with the index id, in the order (A, B)

pub fn winner(&self, id: NodeIndex) -> Result<Option<EntrantId>>

Get the EntrantId of the solved winner of a particular round. Returns None if the round hasn't been calculated yet, or if the node is a TournamentNode::Entrant instead of a TournamentNode::Round.

pub fn winner_entrant(&self, id: NodeIndex) -> Result<Option<Arc<RwLock<E>>>>

Identical to the winner() function, but returns the Arc<RwLock<E>> encapsulating the entrant instead of its EntrantId.

pub fn solve(&mut self) -> Result<()>

Solves all rounds in the tournament, as per solve_round(), up to and including the returned by grand_finals()

pub fn solve_round(&mut self, id: NodeIndex) -> Result<TournamentRoundResult>

Solves rounds only up to the specified round.

Trait Implementations

impl<E: Debug + Display + Clone, M: Debug + Display + Clone + Default, B: Debug + BattleSystem<E, M>> Debug for Tournament<E, M, B>

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

Formats the value using the given formatter.

impl<E: Debug + Display + Clone, M: Debug + Display + Clone + Default, B: BattleSystem<E, M>> Display for Tournament<E, M, B>

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

Formats the value using the given formatter.