Struct 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 duplicate 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, Vec<(AccountId, T)>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> 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, Vec<(AccountId, T)>: Encode,

fn encode_to<__CodecOutputEdqy: Output>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

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: PartialEq, T: PartialEq + PerThing> PartialEq for Assignment<AccountId, T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

where AccountId: Encode, Vec<(AccountId, T)>: Encode,

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

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