Struct sp_phragmen::Assignment

pub struct Assignment<AccountId, T: PerThing> {
    pub who: AccountId,
    pub distribution: Vec<(AccountId, T)>,
}

A voter's stake assignment among a set of targets, represented as ratios.

Fields

who: AccountId

Voter's identifier.

distribution: Vec<(AccountId, T)>

The distribution of the voter's stake.

Implementations

impl<AccountId, T: PerThing> Assignment<AccountId, T> where
    ExtendedBalance: From<<T as PerThing>::Inner>, 

pub fn into_staked(
    self,
    stake: ExtendedBalance,
    fill: bool
) -> StakedAssignment<AccountId> where
    T: Mul<ExtendedBalance, Output = ExtendedBalance>, 

Convert from a ratio assignment into one with absolute values aka. StakedAssignment.

It needs stake which is the total budget of the voter. If fill is set to true, it tries to ensure that all the potential rounding errors are compensated and the distribution's sum is exactly equal to the total budget, by adding or subtracting the remainder from the last distribution.

If an edge ratio is Bounded::max_value(), it is dropped. This edge can never mean anything useful.

Trait Implementations

impl<AccountId: Clone, T: Clone + PerThing> Clone for Assignment<AccountId, T>

fn clone(&self) -> Assignment<AccountId, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<AccountId: Debug, T: Debug + PerThing> Debug for Assignment<AccountId, T>

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

Formats the value using the given formatter.

impl<AccountId, T: PerThing> Decode for Assignment<AccountId, T> where
    AccountId: Decode,
    AccountId: Decode,
    Vec<(AccountId, T)>: Decode,
    Vec<(AccountId, T)>: Decode, 

fn decode<DecIn: Input>(input: &mut DecIn) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl<AccountId: Default, T: Default + PerThing> Default for Assignment<AccountId, T>

fn default() -> Assignment<AccountId, T>

Returns the "default value" for a type.

impl<AccountId, T: PerThing> Encode for Assignment<AccountId, T> where
    AccountId: Encode,
    AccountId: Encode,
    Vec<(AccountId, T)>: Encode,
    Vec<(AccountId, T)>: Encode, 

fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

impl<AccountId, T: PerThing> EncodeLike<Assignment<AccountId, T>> for Assignment<AccountId, T> where
    AccountId: Encode,
    AccountId: Encode,
    Vec<(AccountId, T)>: Encode,
    Vec<(AccountId, T)>: Encode, 

impl<AccountId: Eq, T: Eq + PerThing> Eq for Assignment<AccountId, T>

impl<AccountId: PartialEq, T: PartialEq + PerThing> PartialEq<Assignment<AccountId, T>> for Assignment<AccountId, T>

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

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

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

This method tests for !=.

impl<AccountId, T: PerThing> StructuralEq for Assignment<AccountId, T>

impl<AccountId, T: PerThing> StructuralPartialEq for Assignment<AccountId, T>