Trait frame_election_provider_support::traits::NposSolution

pub trait NposSolutionwhere
    Self: Sized + for<'a> TryFrom<&'a [IndexAssignmentOf<Self>], Error = Error>,{
    type VoterIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + TypeInfo;
    type TargetIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + 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,
             for<'r> FV: Fn(&'r A) -> Option<Self::VoterIndex>,
             for<'r> FT: Fn(&'r A) -> Option<Self::TargetIndex>;
    fn into_assignment<A: IdentifierT>(
        self,
        voter_at: impl Fn(Self::VoterIndex) -> Option<A>,
        target_at: impl Fn(Self::TargetIndex) -> Option<A>
    ) -> Result<Vec<Assignment<A, Self::Accuracy>>, Error>;

    // 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 for<'r> FS: Fn(&'r A) -> VoteWeight,
             A: IdentifierT { ... }
}

An opaque index-based, NPoS solution type.

Required Associated Types

type VoterIndex: UniqueSaturatedInto<usize> + TryInto<usize> + TryFrom<usize> + Debug + Copy + Clone + Bounded + Encode + 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 + TypeInfo

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

type Accuracy: PerThing128

The weight/accuracy type of each vote.

Required Associated Constants

const LIMIT: usize

The maximum number of votes that are allowed.

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, for<'r> FV: Fn(&'r A) -> Option<Self::VoterIndex>, for<'r> FT: Fn(&'r A) -> Option<Self::TargetIndex>,

Build self from a list of assignments.

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

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

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 for<'r> FS: Fn(&'r A) -> VoteWeight, A: IdentifierT,

Compute the score of this solution type.

Implementors