[−][src]Struct pallet_staking::GenericCompactAssignments
A struct to encode a election assignment in a compact way.
Implementations
impl<V, T, W> GenericCompactAssignments<V, T, W>
[src]
pub fn len(&self) -> usize
[src]
Get the length of all the assignments that this type is encoding. This is basically the same as the number of assignments, or the number of voters in total.
pub fn edge_count(&self) -> usize
[src]
Get the total count of edges.
pub fn average_edge_count(&self) -> usize
[src]
Get the average edge count.
impl<V: Codec + Default + Copy, T: Codec + Default + Copy, Accuracy: Codec + Default + Clone + PerThing + PartialOrd> GenericCompactAssignments<V, T, Accuracy>
[src]
pub fn from_assignment<FV, FT, A>(
assignments: Vec<Assignment<A, Accuracy>>,
index_of_voter: FV,
index_of_target: FT
) -> Result<Self, Error> where
FV: Fn(&'r A) -> Option<V>,
FT: Fn(&'r A) -> Option<T>,
A: IdentifierT,
[src]
assignments: Vec<Assignment<A, Accuracy>>,
index_of_voter: FV,
index_of_target: FT
) -> Result<Self, Error> where
FV: Fn(&'r A) -> Option<V>,
FT: Fn(&'r A) -> Option<T>,
A: IdentifierT,
pub fn into_assignment<A: IdentifierT>(
self,
voter_at: impl Fn(V) -> Option<A>,
target_at: impl Fn(T) -> Option<A>
) -> Result<Vec<Assignment<A, Accuracy>>, Error>
[src]
self,
voter_at: impl Fn(V) -> Option<A>,
target_at: impl Fn(T) -> Option<A>
) -> Result<Vec<Assignment<A, Accuracy>>, Error>
impl<V: Codec + Default + Copy, T: Codec + Default + Copy> GenericCompactAssignments<V, T, u128>
[src]
pub fn from_staked<FV, FT, A>(
assignments: Vec<StakedAssignment<A>>,
index_of_voter: FV,
index_of_target: FT
) -> Result<Self, Error> where
FV: Fn(&'r A) -> Option<V>,
FT: Fn(&'r A) -> Option<T>,
A: IdentifierT,
[src]
assignments: Vec<StakedAssignment<A>>,
index_of_voter: FV,
index_of_target: FT
) -> Result<Self, Error> where
FV: Fn(&'r A) -> Option<V>,
FT: Fn(&'r A) -> Option<T>,
A: IdentifierT,
Generate self from a vector of StakedAssignment
.
pub fn into_staked<FM, A>(
self,
max_of: FM,
voter_at: impl Fn(V) -> Option<A>,
target_at: impl Fn(T) -> Option<A>
) -> Result<Vec<StakedAssignment<A>>, Error> where
FM: Fn(&'r A) -> u64,
A: IdentifierT,
[src]
self,
max_of: FM,
voter_at: impl Fn(V) -> Option<A>,
target_at: impl Fn(T) -> Option<A>
) -> Result<Vec<StakedAssignment<A>>, Error> where
FM: Fn(&'r A) -> u64,
A: IdentifierT,
Convert self into StakedAssignment
. The given function should return the total
weight of a voter. It is used to subtract the sum of all the encoded weights to
infer the last one.
Trait Implementations
impl<V: Clone, T: Clone, W: Clone> Clone for GenericCompactAssignments<V, T, W>
[src]
fn clone(&self) -> GenericCompactAssignments<V, T, W>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<V: Debug, T: Debug, W: Debug> Debug for GenericCompactAssignments<V, T, W>
[src]
impl<V, T, W> Decode for GenericCompactAssignments<V, T, W> where
Vec<(V, T)>: Decode,
Vec<(V, T)>: Decode,
Vec<(V, (T, W), T)>: Decode,
Vec<(V, (T, W), T)>: Decode,
Vec<(V, [(T, W); 2], T)>: Decode,
Vec<(V, [(T, W); 2], T)>: Decode,
Vec<(V, [(T, W); 3], T)>: Decode,
Vec<(V, [(T, W); 3], T)>: Decode,
Vec<(V, [(T, W); 4], T)>: Decode,
Vec<(V, [(T, W); 4], T)>: Decode,
Vec<(V, [(T, W); 5], T)>: Decode,
Vec<(V, [(T, W); 5], T)>: Decode,
Vec<(V, [(T, W); 6], T)>: Decode,
Vec<(V, [(T, W); 6], T)>: Decode,
Vec<(V, [(T, W); 7], T)>: Decode,
Vec<(V, [(T, W); 7], T)>: Decode,
Vec<(V, [(T, W); 8], T)>: Decode,
Vec<(V, [(T, W); 8], T)>: Decode,
Vec<(V, [(T, W); 9], T)>: Decode,
Vec<(V, [(T, W); 9], T)>: Decode,
Vec<(V, [(T, W); 10], T)>: Decode,
Vec<(V, [(T, W); 10], T)>: Decode,
Vec<(V, [(T, W); 11], T)>: Decode,
Vec<(V, [(T, W); 11], T)>: Decode,
Vec<(V, [(T, W); 12], T)>: Decode,
Vec<(V, [(T, W); 12], T)>: Decode,
Vec<(V, [(T, W); 13], T)>: Decode,
Vec<(V, [(T, W); 13], T)>: Decode,
Vec<(V, [(T, W); 14], T)>: Decode,
Vec<(V, [(T, W); 14], T)>: Decode,
Vec<(V, [(T, W); 15], T)>: Decode,
Vec<(V, [(T, W); 15], T)>: Decode,
[src]
Vec<(V, T)>: Decode,
Vec<(V, T)>: Decode,
Vec<(V, (T, W), T)>: Decode,
Vec<(V, (T, W), T)>: Decode,
Vec<(V, [(T, W); 2], T)>: Decode,
Vec<(V, [(T, W); 2], T)>: Decode,
Vec<(V, [(T, W); 3], T)>: Decode,
Vec<(V, [(T, W); 3], T)>: Decode,
Vec<(V, [(T, W); 4], T)>: Decode,
Vec<(V, [(T, W); 4], T)>: Decode,
Vec<(V, [(T, W); 5], T)>: Decode,
Vec<(V, [(T, W); 5], T)>: Decode,
Vec<(V, [(T, W); 6], T)>: Decode,
Vec<(V, [(T, W); 6], T)>: Decode,
Vec<(V, [(T, W); 7], T)>: Decode,
Vec<(V, [(T, W); 7], T)>: Decode,
Vec<(V, [(T, W); 8], T)>: Decode,
Vec<(V, [(T, W); 8], T)>: Decode,
Vec<(V, [(T, W); 9], T)>: Decode,
Vec<(V, [(T, W); 9], T)>: Decode,
Vec<(V, [(T, W); 10], T)>: Decode,
Vec<(V, [(T, W); 10], T)>: Decode,
Vec<(V, [(T, W); 11], T)>: Decode,
Vec<(V, [(T, W); 11], T)>: Decode,
Vec<(V, [(T, W); 12], T)>: Decode,
Vec<(V, [(T, W); 12], T)>: Decode,
Vec<(V, [(T, W); 13], T)>: Decode,
Vec<(V, [(T, W); 13], T)>: Decode,
Vec<(V, [(T, W); 14], T)>: Decode,
Vec<(V, [(T, W); 14], T)>: Decode,
Vec<(V, [(T, W); 15], T)>: Decode,
Vec<(V, [(T, W); 15], T)>: Decode,
impl<V: Default, T: Default, W: Default> Default for GenericCompactAssignments<V, T, W>
[src]
fn default() -> GenericCompactAssignments<V, T, W>
[src]
impl<V, T, W> Encode for GenericCompactAssignments<V, T, W> where
Vec<(V, T)>: Encode,
Vec<(V, T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
[src]
Vec<(V, T)>: Encode,
Vec<(V, T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
fn encode_to<EncOut: Output>(&self, dest: &mut EncOut)
[src]
fn size_hint(&self) -> usize
[src]
fn encode(&self) -> Vec<u8>
[src]
fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8]) -> R,
[src]
F: FnOnce(&[u8]) -> R,
impl<V, T, W> EncodeLike<GenericCompactAssignments<V, T, W>> for GenericCompactAssignments<V, T, W> where
Vec<(V, T)>: Encode,
Vec<(V, T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
[src]
Vec<(V, T)>: Encode,
Vec<(V, T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, (T, W), T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 2], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 3], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 4], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 5], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 6], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 7], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 8], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 9], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 10], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 11], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 12], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 13], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 14], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
Vec<(V, [(T, W); 15], T)>: Encode,
impl<V: Eq, T: Eq, W: Eq> Eq for GenericCompactAssignments<V, T, W>
[src]
impl<V: PartialEq, T: PartialEq, W: PartialEq> PartialEq<GenericCompactAssignments<V, T, W>> for GenericCompactAssignments<V, T, W>
[src]
fn eq(&self, other: &GenericCompactAssignments<V, T, W>) -> bool
[src]
fn ne(&self, other: &GenericCompactAssignments<V, T, W>) -> bool
[src]
impl<V, T, W> StructuralEq for GenericCompactAssignments<V, T, W>
[src]
impl<V, T, W> StructuralPartialEq for GenericCompactAssignments<V, T, W>
[src]
impl<V, T, W> VotingLimit for GenericCompactAssignments<V, T, W>
[src]
Auto Trait Implementations
impl<V, T, W> RefUnwindSafe for GenericCompactAssignments<V, T, W> where
T: RefUnwindSafe,
V: RefUnwindSafe,
W: RefUnwindSafe,
T: RefUnwindSafe,
V: RefUnwindSafe,
W: RefUnwindSafe,
impl<V, T, W> Send for GenericCompactAssignments<V, T, W> where
T: Send,
V: Send,
W: Send,
T: Send,
V: Send,
W: Send,
impl<V, T, W> Sync for GenericCompactAssignments<V, T, W> where
T: Sync,
V: Sync,
W: Sync,
T: Sync,
V: Sync,
W: Sync,
impl<V, T, W> Unpin for GenericCompactAssignments<V, T, W> where
T: Unpin,
V: Unpin,
W: Unpin,
T: Unpin,
V: Unpin,
W: Unpin,
impl<V, T, W> UnwindSafe for GenericCompactAssignments<V, T, W> where
T: UnwindSafe,
V: UnwindSafe,
W: UnwindSafe,
T: UnwindSafe,
V: UnwindSafe,
W: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CheckedConversion for T
[src]
fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,
[src]
Self: TryFrom<T>,
fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,
[src]
Self: TryInto<T>,
impl<T> Clear for T where
T: PartialEq<T> + Eq + Default,
[src]
T: PartialEq<T> + Eq + Default,
impl<T> Clear for T where
T: InitializableFromZeroed + ?Sized,
T: InitializableFromZeroed + ?Sized,
fn clear(&mut self)
impl<S> Codec for S where
S: Encode + Decode,
[src]
S: Encode + Decode,
impl<T, X> Decode for X where
T: Decode + Into<X>,
X: WrapperTypeDecode<Wrapped = T>,
[src]
T: Decode + Into<X>,
X: WrapperTypeDecode<Wrapped = T>,
impl<T> DecodeAll for T where
T: Decode,
[src]
T: Decode,
impl<T> DecodeLimit for T where
T: Decode,
[src]
T: Decode,
fn decode_all_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>
[src]
fn decode_with_depth_limit(limit: u32, input: &[u8]) -> Result<T, Error>
[src]
impl<T, X> Encode for X where
T: Encode + ?Sized,
X: WrapperTypeEncode<Target = T>,
[src]
T: Encode + ?Sized,
X: WrapperTypeEncode<Target = T>,
fn size_hint(&self) -> usize
[src]
fn using_encoded<R, F>(&self, f: F) -> R where
F: FnOnce(&[u8]) -> R,
[src]
F: FnOnce(&[u8]) -> R,
fn encode(&self) -> Vec<u8>
[src]
fn encode_to<W>(&self, dest: &mut W) where
W: Output,
[src]
W: Output,
impl<'_, '_, T> EncodeLike<&'_ &'_ T> for T where
T: Encode,
[src]
T: Encode,
impl<'_, T> EncodeLike<&'_ T> for T where
T: Encode,
[src]
T: Encode,
impl<'_, T> EncodeLike<&'_ mut T> for T where
T: Encode,
[src]
T: Encode,
impl<T> EncodeLike<Arc<T>> for T where
T: Encode,
[src]
T: Encode,
impl<T> EncodeLike<Box<T>> for T where
T: Encode,
[src]
T: Encode,
impl<'a, T> EncodeLike<Cow<'a, T>> for T where
T: Encode + ToOwned,
[src]
T: Encode + ToOwned,
impl<T> EncodeLike<Rc<T>> for T where
T: Encode,
[src]
T: Encode,
impl<T> From<T> for T
[src]
impl<S> FullCodec for S where
S: Decode + FullEncode,
[src]
S: Decode + FullEncode,
impl<S> FullEncode for S where
S: Encode + EncodeLike<S>,
[src]
S: Encode + EncodeLike<S>,
impl<T> Hashable for T where
T: Codec,
[src]
T: Codec,
fn blake2_128(&self) -> [u8; 16]
[src]
fn blake2_256(&self) -> [u8; 32]
[src]
fn blake2_128_concat(&self) -> Vec<u8>
[src]
fn twox_128(&self) -> [u8; 16]
[src]
fn twox_256(&self) -> [u8; 32]
[src]
fn twox_64_concat(&self) -> Vec<u8>
[src]
fn identity(&self) -> Vec<u8>
[src]
impl<T> InitializableFromZeroed for T where
T: Default,
T: Default,
unsafe fn initialize(place: *mut T)
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IsType<T> for T
[src]
fn from_ref(t: &T) -> &T
[src]
fn into_ref(&self) -> &T
[src]
fn from_mut(t: &mut T) -> &mut T
[src]
fn into_mut(&mut self) -> &mut T
[src]
impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
fn from_ref(outer: &Outer) -> &T
Get a reference to the inner from the outer.
fn from_mut(outer: &mut Outer) -> &mut T
Get a mutable reference to the inner from the outer.
impl<T> KeyedVec for T where
T: Codec,
[src]
T: Codec,
impl<T> MaybeDebug for T where
T: Debug,
T: Debug,
impl<T> MaybeDebug for T where
T: Debug,
T: Debug,
impl<T> MaybeRefUnwindSafe for T where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Member for T where
T: 'static + Clone + PartialEq<T> + Eq + Send + Sync + Debug,
[src]
T: 'static + Clone + PartialEq<T> + Eq + Send + Sync + Debug,
impl<T> Parameter for T where
T: Codec + EncodeLike<T> + Clone + Eq + Debug,
[src]
T: Codec + EncodeLike<T> + Clone + Eq + Debug,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> SaturatedConversion for T
fn saturated_from<T>(t: T) -> Self where
Self: UniqueSaturatedFrom<T>,
Self: UniqueSaturatedFrom<T>,
fn saturated_into<T>(self) -> T where
Self: UniqueSaturatedInto<T>,
Self: UniqueSaturatedInto<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<S, T> UncheckedInto<T> for S where
T: UncheckedFrom<S>,
T: UncheckedFrom<S>,
fn unchecked_into(self) -> T
impl<T, S> UniqueSaturatedInto<T> for S where
S: TryInto<T>,
T: Bounded,
S: TryInto<T>,
T: Bounded,
fn unique_saturated_into(self) -> T
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,