Struct tallystick::RankedWinners

pub struct RankedWinners<T: Clone> { /* fields omitted */ }

RankedWinners is a ranked list of winning candidates, sorted according to rank. Ranks are in ascending order. A 0 ranked winner is more significant than a 3 ranked winner. Winners with the same rank are tied.

Methods

impl<T: Clone + Eq> RankedWinners<T>

pub fn len(&self) -> usize

Get the number of winners.

pub fn is_empty(&self) -> bool

Check if it's empty

pub fn drain<R>(&mut self, range: R) -> Drain<(T, u32)> where
    R: RangeBounds<usize>, 

Clears the winners, returning all winner-rank pairs as an iterator.

pub fn into_vec(self) -> Vec<(T, u32)>

Transform winners into a vector of winner-rank pairs.

pub fn all(&self) -> Vec<T>

Get a list of all winners, without rank.

pub fn iter(&self) -> IterWinners<T>

Iterate over all winner->rank pairs.

pub fn contains(&self, candidate: &T) -> bool

Check if the given candidate exists in the set of ranked-winners.

pub fn rank(&self, candidate: &T) -> Option<u32>

Get the rank of a single winner.

pub fn into_unranked(self) -> Vec<T>

Get an unranked list of all winners, this consumes the winner list.

pub fn check_overflow(&self) -> bool

Check if the actual number of winners is more than the wanted number of winners. This can happen if there is a tie.

Not all ties result in an overflow. Only a tie of the least-significantly ranked winning candidates can result in an overflow. Consider an election that is trying to fill three seats. If only the top two candidates tie, then there is no overflow. However, if the 3rd place and 4th place candidates tie, then there will be an overflow with both candidates being equally ranked to fill the 3rd seat.

pub fn overflow(&self) -> Option<Vec<T>>

Get all tied least-significantly ranked winners that overflow the wanted number of winners.

If there is a tie in the least-significantly ranked winning candidates, then the actual number of winners may "overflow" the wanted number of winners, in which case this method will return a list of overlow candidates (or None if there is no overflow).

You should always check for an overflow so you can resolve this unfortunate situation.

Trait Implementations

impl<T: Debug + Clone> Debug for RankedWinners<T>

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

Formats the value using the given formatter.

impl<T: Default + Clone> Default for RankedWinners<T>

fn default() -> RankedWinners<T>

Returns the "default value" for a type.

impl<T: Eq + Clone> Eq for RankedWinners<T>

impl<T: Clone> From<(Vec<(T, u32)>, u32)> for RankedWinners<T>

fn from(original: (Vec<(T, u32)>, u32)) -> RankedWinners<T>

Performs the conversion.

impl<T: PartialEq + Clone> PartialEq<RankedWinners<T>> for RankedWinners<T>

fn eq(&self, other: &RankedWinners<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &RankedWinners<T>) -> bool

This method tests for !=.

impl<T: Clone> StructuralEq for RankedWinners<T>

impl<T: Clone> StructuralPartialEq for RankedWinners<T>