Struct westend_runtime::NposCompactSolution16[−][src]

pub struct NposCompactSolution16 {Show 16 fields
    pub votes1: Vec<(u32, u16)>,
    pub votes2: Vec<(u32, [(u16, PerU16); 1], u16)>,
    pub votes3: Vec<(u32, [(u16, PerU16); 2], u16)>,
    pub votes4: Vec<(u32, [(u16, PerU16); 3], u16)>,
    pub votes5: Vec<(u32, [(u16, PerU16); 4], u16)>,
    pub votes6: Vec<(u32, [(u16, PerU16); 5], u16)>,
    pub votes7: Vec<(u32, [(u16, PerU16); 6], u16)>,
    pub votes8: Vec<(u32, [(u16, PerU16); 7], u16)>,
    pub votes9: Vec<(u32, [(u16, PerU16); 8], u16)>,
    pub votes10: Vec<(u32, [(u16, PerU16); 9], u16)>,
    pub votes11: Vec<(u32, [(u16, PerU16); 10], u16)>,
    pub votes12: Vec<(u32, [(u16, PerU16); 11], u16)>,
    pub votes13: Vec<(u32, [(u16, PerU16); 12], u16)>,
    pub votes14: Vec<(u32, [(u16, PerU16); 13], u16)>,
    pub votes15: Vec<(u32, [(u16, PerU16); 14], u16)>,
    pub votes16: Vec<(u32, [(u16, PerU16); 15], u16)>,
}

Fields

votes1: Vec<(u32, u16)>votes2: Vec<(u32, [(u16, PerU16); 1], u16)>votes3: Vec<(u32, [(u16, PerU16); 2], u16)>votes4: Vec<(u32, [(u16, PerU16); 3], u16)>votes5: Vec<(u32, [(u16, PerU16); 4], u16)>votes6: Vec<(u32, [(u16, PerU16); 5], u16)>votes7: Vec<(u32, [(u16, PerU16); 6], u16)>votes8: Vec<(u32, [(u16, PerU16); 7], u16)>votes9: Vec<(u32, [(u16, PerU16); 8], u16)>votes10: Vec<(u32, [(u16, PerU16); 9], u16)>votes11: Vec<(u32, [(u16, PerU16); 10], u16)>votes12: Vec<(u32, [(u16, PerU16); 11], u16)>votes13: Vec<(u32, [(u16, PerU16); 12], u16)>votes14: Vec<(u32, [(u16, PerU16); 13], u16)>votes15: Vec<(u32, [(u16, PerU16); 14], u16)>votes16: Vec<(u32, [(u16, PerU16); 15], u16)>

Struct westend_runtime::NposCompactSolution16[−][src]

Fields

Trait Implementations

impl Clone for NposCompactSolution16

fn clone(&self) -> NposCompactSolution16

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

impl Debug for NposCompactSolution16

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

impl Decode for NposCompactSolution16

fn decode<I: Input>(value: &mut I) -> Result<Self, Error>

fn skip<I>(input: &mut I) -> Result<(), Error> where I: Input,

fn encoded_fixed_size() -> Option<usize>

impl Default for NposCompactSolution16

fn default() -> NposCompactSolution16

impl Encode for NposCompactSolution16

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

fn size_hint(&self) -> usize

fn encode_to<T>(&self, dest: &mut T) where T: Output + ?Sized,

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

fn encoded_size(&self) -> usize

impl NposSolution for NposCompactSolution16

const LIMIT: usize

type VoterIndex = u32

type TargetIndex = u16

type Accuracy = PerU16

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

fn from_assignment<FV, FT, A>( assignments: &[Assignment<A, PerU16>], 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, PerU16>>, Error>

fn voter_count(&self) -> usize

fn edge_count(&self) -> usize

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

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<[u128; 3], Error> where FS: for<'r> Fn(&'r A) -> u64, A: IdentifierT,

impl Ord for NposCompactSolution16

fn cmp(&self, other: &NposCompactSolution16) -> Ordering

fn max(self, other: Self) -> Self

fn min(self, other: Self) -> Self

fn clamp(self, min: Self, max: Self) -> Self

impl PartialEq<NposCompactSolution16> for NposCompactSolution16

fn eq(&self, other: &NposCompactSolution16) -> bool

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

impl PartialOrd<NposCompactSolution16> for NposCompactSolution16

fn partial_cmp(&self, other: &NposCompactSolution16) -> Option<Ordering>

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

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

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

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

impl<'a> TryFrom<&'a [IndexAssignment<<NposCompactSolution16 as NposSolution>::VoterIndex, <NposCompactSolution16 as NposSolution>::TargetIndex, <NposCompactSolution16 as NposSolution>::Accuracy>]> for NposCompactSolution16

type Error = Error

fn try_from( index_assignments: &'a [IndexAssignment<<NposCompactSolution16 as NposSolution>::VoterIndex, <NposCompactSolution16 as NposSolution>::TargetIndex, <NposCompactSolution16 as NposSolution>::Accuracy>]) -> Result<Self, Self::Error>

impl TypeInfo for NposCompactSolution16

type Identity = Self

fn type_info() -> Type<MetaForm>

impl Eq for NposCompactSolution16

impl StructuralEq for NposCompactSolution16

impl StructuralPartialEq for NposCompactSolution16

Auto Trait Implementations

impl RefUnwindSafe for NposCompactSolution16

impl Send for NposCompactSolution16

impl Sync for NposCompactSolution16

impl Unpin for NposCompactSolution16

impl UnwindSafe for NposCompactSolution16

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized,

pub fn type_id(&self) -> TypeId

impl<T> Borrow<T> for T where T: ?Sized,

pub fn borrow(&self) -> &T

impl<T> BorrowMut<T> for T where T: ?Sized,

pub fn borrow_mut(&mut self) -> &mut T

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self> where Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where Self: TryInto<T>,

impl<T> Clear for T where T: Default + Eq + PartialEq<T>,

pub fn is_clear(&self) -> bool

pub fn clear() -> T

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

fn conv<T>(self) -> T where Self: Into<T>,

impl<T> DecodeAll for T where T: Decode,

fn skip<I>(input: &mut I) -> Result<(), Error> where
I: Input,

fn encode_to<T>(&self, dest: &mut T) where
T: Output + ?Sized,

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

fn from_assignment<FV, FT, A>(
assignments: &[Assignment<A, PerU16>],
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, PerU16>>, Error>

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<[u128 ; 3], Error> where
FS: for<'r> Fn(&'r A) -> u64,
A: IdentifierT,

fn try_from(
index_assignments: &'a [IndexAssignment<<NposCompactSolution16 as NposSolution>::VoterIndex, <NposCompactSolution16 as NposSolution>::TargetIndex, <NposCompactSolution16 as NposSolution>::Accuracy>]
) -> Result<Self, Self::Error>

impl<T> Any for T where
T: 'static + ?Sized,

impl<T> Borrow<T> for T where
T: ?Sized,

impl<T> BorrowMut<T> for T where
T: ?Sized,

fn checked_from<T>(t: T) -> Option<Self> where
Self: TryFrom<T>,

fn checked_into<T>(self) -> Option<T> where
Self: TryInto<T>,

impl<T> Clear for T where
T: Default + Eq + PartialEq<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

fn conv<T>(self) -> T where
Self: Into<T>,

impl<T> DecodeAll for T where
T: Decode,

pub fn decode_all(input: &[u8 ]) -> Result<T, Error>

impl<T> DecodeLimit for T where
T: Decode,

pub fn decode_all_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

pub fn decode_and_advance_with_depth_limit<I>(
limit: u32,
input: &mut I
) -> Result<T, Error> where
I: Input,

pub fn decode_with_depth_limit(limit: u32, input: &[u8 ]) -> Result<T, Error>

impl<T> Downcast for T where
T: Any,

impl<T> DowncastSync for T where
T: Any + Send + Sync,

impl<T> DynClone for T where
T: Clone,

impl<T> EncodeAs<T> for T where
T: Encode,

impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,

impl<T> FullLeaf for T where
T: Encode + Decode + Clone + PartialEq<T> + Debug,

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

impl<T> Hashable for T where
T: Codec,

pub fn blake2_128(&self) -> [u8 ; 16]

pub fn blake2_256(&self) -> [u8 ; 32]

pub fn twox_128(&self) -> [u8 ; 16]

pub fn twox_256(&self) -> [u8 ; 32]

impl<T, U> Into<U> for T where
U: From<T>,

impl<T, Outer> IsWrappedBy<Outer> for T where
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

impl<T> KeyedVec for T where
T: Codec,

pub fn to_keyed_vec(&self, prepend_key: &[u8 ]) -> Vec<u8, Global>

impl<T> Pipe for T where
T: ?Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,