Trait NposSolution

pub trait NposSolution: Sized + for<'a> TryFrom<&'a [IndexAssignment<Self::VoterIndex, Self::TargetIndex, Self::Accuracy>], Error = Error> {
    type VoterIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + Ord + PartialOrd + TypeInfo;
    type TargetIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + Ord + PartialOrd + TypeInfo;
    type Accuracy: PerThing128;

    const LIMIT: usize;

    // Required methods
    fn voter_count(&self) -> usize;
    fn edge_count(&self) -> usize;
    fn unique_targets(&self) -> Vec<Self::TargetIndex>;
    fn remove_voter(&mut self, to_remove: Self::VoterIndex) -> bool;
    fn from_assignment<FV, FT, A>(
        assignments: &[Assignment<A, Self::Accuracy>],
        voter_index: FV,
        target_index: FT,
    ) -> Result<Self, Error>
       where A: IdentifierT,
             FV: for<'r> Fn(&'r A) -> Option<Self::VoterIndex>,
             FT: for<'r> Fn(&'r A) -> Option<Self::TargetIndex>;
    fn into_assignment<A>(
        self,
        voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
        target_at: impl Fn(Self::TargetIndex) -> Option<A>,
    ) -> Result<Vec<Assignment<A, Self::Accuracy>>, Error>
       where A: IdentifierT;
    fn sort<F>(&mut self, voter_stake: F)
       where F: FnMut(&Self::VoterIndex) -> u64;
    fn remove_weakest_sorted<F>(
        &mut self,
        voter_stake: F,
    ) -> Option<Self::VoterIndex>
       where F: FnMut(&Self::VoterIndex) -> u64;
    fn corrupt(&mut self);

    // Provided methods
    fn average_edge_count(&self) -> usize { ... }
    fn score<A, FS>(
        self,
        stake_of: FS,
        voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
        target_at: impl Fn(Self::TargetIndex) -> Option<A>,
    ) -> Result<ElectionScore, Error>
       where FS: for<'r> Fn(&'r A) -> u64,
             A: IdentifierT { ... }
}

An opaque index-based, NPoS solution type.

Required Associated Constants

const LIMIT: usize

The maximum number of votes that are allowed.

Required Associated Types

type VoterIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + Ord + PartialOrd + TypeInfo

The voter type. Needs to be an index (convert to usize).

type TargetIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + Ord + PartialOrd + TypeInfo

The target type. Needs to be an index (convert to usize).

type Accuracy: PerThing128

The weight/accuracy type of each vote.

Required Methods

fn voter_count(&self) -> usize

Get the length of all the voters that this type is encoding.

This is basically the same as the number of assignments, or number of active voters.

fn edge_count(&self) -> usize

Get the total count of edges.

This is effectively in the range of {Self::voter_count, Self::voter_count * Self::LIMIT}.

fn unique_targets(&self) -> Vec<Self::TargetIndex>

Get the number of unique targets in the whole struct.

Once presented with a list of winners, this set and the set of winners must be equal.

fn remove_voter(&mut self, to_remove: Self::VoterIndex) -> bool

Remove a certain voter.

This will only search until the first instance of to_remove, and return true. If no instance is found (no-op), then it returns false.

In other words, if this return true, exactly one element must have been removed self.

fn from_assignment<FV, FT, A>( assignments: &[Assignment<A, Self::Accuracy>], voter_index: FV, target_index: FT, ) -> Result<Self, Error>

where A: IdentifierT, FV: for<'r> Fn(&'r A) -> Option<Self::VoterIndex>, FT: for<'r> Fn(&'r A) -> Option<Self::TargetIndex>,

Build self from a list of assignments.

fn into_assignment<A>( self, voter_at: impl Fn(Self::VoterIndex) -> Option<A>, target_at: impl Fn(Self::TargetIndex) -> Option<A>, ) -> Result<Vec<Assignment<A, Self::Accuracy>>, Error>

where A: IdentifierT,

Convert self into a Vec<Assignment<A, Self::Accuracy>>

fn sort<F>(&mut self, voter_stake: F)

where F: FnMut(&Self::VoterIndex) -> u64,

Sort self by the means of the given function.

This might be helpful to allow for easier trimming.

fn remove_weakest_sorted<F>( &mut self, voter_stake: F, ) -> Option<Self::VoterIndex>

where F: FnMut(&Self::VoterIndex) -> u64,

Remove the least staked voter.

This is ONLY sensible to do if Self::sort has been called on the struct at least once.

fn corrupt(&mut self)

Make this solution corrupt. This should set the index of a voter to Bounded::max_value().

Obviously, this is only useful for testing.

Provided Methods

fn average_edge_count(&self) -> usize

Get the average edge count.

fn score<A, FS>( self, stake_of: FS, voter_at: impl Fn(Self::VoterIndex) -> Option<A>, target_at: impl Fn(Self::TargetIndex) -> Option<A>, ) -> Result<ElectionScore, Error>

where FS: for<'r> Fn(&'r A) -> u64, A: IdentifierT,

Compute the score of this solution type.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors