pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-20 00:01:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/npos-elections/src/reduce.rs
+136 -314
View File
@@ -47,13 +47,15 @@
//!
//! 1. <https://hackmd.io/JOn9x98iS0e0DPWQ87zGWg?view>
use crate::node::{Node, NodeId, NodeRef, NodeRole};
use crate::{ExtendedBalance, IdentifierT, StakedAssignment};
use crate::{
node::{Node, NodeId, NodeRef, NodeRole},
ExtendedBalance, IdentifierT, StakedAssignment,
};
use sp_arithmetic::traits::{Bounded, Zero};
use sp_std::{
collections::btree_map::{BTreeMap, Entry::*},
vec,
prelude::*,
vec,
};
/// Map type used for reduce_4. Can be easily swapped with HashMap.
@@ -63,7 +65,7 @@ type Map<A> = BTreeMap<(A, A), A>;
fn combinations_2<T: Clone>(input: &[T]) -> Vec<(T, T)> {
let n = input.len();
if n < 2 {
return Default::default();
return Default::default()
}
let mut comb = Vec::with_capacity(n * (n - 1) / 2);
@@ -126,7 +128,7 @@ fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
match combination_map.entry((v1.clone(), v2.clone())) {
Vacant(entry) => {
entry.insert(who.clone());
}
},
Occupied(mut entry) => {
let other_who = entry.get_mut();
@@ -141,29 +143,30 @@ fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
.filter(|(t, _)| *t == v1 || *t == v2)
.count() != 2
{
continue;
continue
}
// check if other_who voted for the same pair v1, v2.
let maybe_other_assignments = assignments.iter().find(|a| a.who == *other_who);
if maybe_other_assignments.is_none() {
continue;
continue
}
let other_assignment =
maybe_other_assignments.expect("value is checked to be 'Some'");
// Collect potential cycle votes
let mut other_cycle_votes = other_assignment
.distribution
.iter()
.filter_map(|(t, w)| {
if *t == v1 || *t == v2 {
Some((t.clone(), *w))
} else {
None
}
})
.collect::<Vec<(A, ExtendedBalance)>>();
let mut other_cycle_votes =
other_assignment
.distribution
.iter()
.filter_map(|(t, w)| {
if *t == v1 || *t == v2 {
Some((t.clone(), *w))
} else {
None
}
})
.collect::<Vec<(A, ExtendedBalance)>>();
let other_votes_count = other_cycle_votes.len();
@@ -175,21 +178,18 @@ fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
if other_votes_count < 2 {
// This is not a cycle. Replace and continue.
*other_who = who.clone();
continue;
continue
} else if other_votes_count == 2 {
// This is a cycle.
let mut who_cycle_votes: Vec<(A, ExtendedBalance)> = Vec::with_capacity(2);
assignments[assignment_index]
.distribution
.iter()
.for_each(|(t, w)| {
if *t == v1 || *t == v2 {
who_cycle_votes.push((t.clone(), *w));
}
});
assignments[assignment_index].distribution.iter().for_each(|(t, w)| {
if *t == v1 || *t == v2 {
who_cycle_votes.push((t.clone(), *w));
}
});
if who_cycle_votes.len() != 2 {
continue;
continue
}
// Align the targets similarly. This helps with the circulation below.
@@ -240,53 +240,39 @@ fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
// apply changes
let mut remove_indices: Vec<usize> = Vec::with_capacity(1);
increase_indices.into_iter().for_each(|i| {
let voter = if i < 2 {
who.clone()
} else {
other_who.clone()
};
let voter = if i < 2 { who.clone() } else { other_who.clone() };
// Note: so this is pretty ambiguous. We should only look for one
// assignment that meets this criteria and if we find multiple then that
// is a corrupt input. Same goes for the next block.
assignments
.iter_mut()
.filter(|a| a.who == voter)
.for_each(|ass| {
ass.distribution
.iter_mut()
.position(|(t, _)| *t == cycle[i].0)
.map(|idx| {
let next_value =
ass.distribution[idx].1.saturating_add(min_value);
ass.distribution[idx].1 = next_value;
});
});
assignments.iter_mut().filter(|a| a.who == voter).for_each(|ass| {
ass.distribution
.iter_mut()
.position(|(t, _)| *t == cycle[i].0)
.map(|idx| {
let next_value =
ass.distribution[idx].1.saturating_add(min_value);
ass.distribution[idx].1 = next_value;
});
});
});
decrease_indices.into_iter().for_each(|i| {
let voter = if i < 2 {
who.clone()
} else {
other_who.clone()
};
assignments
.iter_mut()
.filter(|a| a.who == voter)
.for_each(|ass| {
ass.distribution
.iter_mut()
.position(|(t, _)| *t == cycle[i].0)
.map(|idx| {
let next_value =
ass.distribution[idx].1.saturating_sub(min_value);
if next_value.is_zero() {
ass.distribution.remove(idx);
remove_indices.push(i);
num_changed += 1;
} else {
ass.distribution[idx].1 = next_value;
}
});
});
let voter = if i < 2 { who.clone() } else { other_who.clone() };
assignments.iter_mut().filter(|a| a.who == voter).for_each(|ass| {
ass.distribution
.iter_mut()
.position(|(t, _)| *t == cycle[i].0)
.map(|idx| {
let next_value =
ass.distribution[idx].1.saturating_sub(min_value);
if next_value.is_zero() {
ass.distribution.remove(idx);
remove_indices.push(i);
num_changed += 1;
} else {
ass.distribution[idx].1 = next_value;
}
});
});
});
// remove either one of them.
@@ -297,21 +283,21 @@ fn reduce_4<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32 {
match (who_removed, other_removed) {
(false, true) => {
*other_who = who.clone();
}
},
(true, false) => {
// nothing, other_who can stay there.
}
},
(true, true) => {
// remove and don't replace
entry.remove();
}
},
(false, false) => {
// Neither of the edges was removed? impossible.
panic!("Duplicate voter (or other corrupt input).");
}
},
}
}
}
},
}
}
}
@@ -350,7 +336,7 @@ fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32
let maybe_dist = assignments[assignment_index].distribution.get(dist_index);
if maybe_dist.is_none() {
// The rest of this loop is moot.
break;
break
}
let (target, _) = maybe_dist.expect("Value checked to be some").clone();
@@ -377,19 +363,19 @@ fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32
(false, false) => {
Node::set_parent_of(&target_node, &voter_node);
dist_index += 1;
continue;
}
continue
},
(false, true) => {
Node::set_parent_of(&voter_node, &target_node);
dist_index += 1;
continue;
}
continue
},
(true, false) => {
Node::set_parent_of(&target_node, &voter_node);
dist_index += 1;
continue;
}
(true, true) => { /* don't continue and execute the rest */ }
continue
},
(true, true) => { /* don't continue and execute the rest */ },
};
let (voter_root, voter_root_path) = Node::root(&voter_node);
@@ -405,10 +391,7 @@ fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32
// because roots are the same.
#[cfg(feature = "std")]
debug_assert_eq!(
target_root_path.last().unwrap(),
voter_root_path.last().unwrap()
);
debug_assert_eq!(target_root_path.last().unwrap(), voter_root_path.last().unwrap());
debug_assert!(common_count > 0);
// cycle part of each path will be `path[path.len() - common_count - 1 : 0]`
@@ -602,7 +585,7 @@ fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32
let current = voter_root_path[i].clone().borrow().id.who.clone();
let next = voter_root_path[i + 1].clone().borrow().id.who.clone();
if min_edge.contains(&current) && min_edge.contains(&next) {
break;
break
}
Node::set_parent_of(&voter_root_path[i + 1], &voter_root_path[i]);
}
@@ -613,7 +596,7 @@ fn reduce_all<A: IdentifierT>(assignments: &mut Vec<StakedAssignment<A>>) -> u32
let current = target_root_path[i].clone().borrow().id.who.clone();
let next = target_root_path[i + 1].clone().borrow().id.who.clone();
if min_edge.contains(&current) && min_edge.contains(&next) {
break;
break
}
Node::set_parent_of(&target_root_path[i + 1], &target_root_path[i]);
}
@@ -663,9 +646,9 @@ mod tests {
#[test]
fn merging_works() {
// D <-- A <-- B <-- C
// D <-- A <-- B <-- C
//
// F <-- E
// F <-- E
let d = Node::new(NodeId::from(1, NodeRole::Target)).into_ref();
let a = Node::new(NodeId::from(2, NodeRole::Target)).into_ref();
let b = Node::new(NodeId::from(3, NodeRole::Target)).into_ref();
@@ -682,17 +665,17 @@ mod tests {
let path2 = vec![e.clone(), f.clone()];
merge(path1, path2);
// D <-- A <-- B <-- C
// |
// F --> E --> -->
// D <-- A <-- B <-- C
// |
// F --> E --> -->
assert_eq!(e.borrow().clone().parent.unwrap().borrow().id.who, 4u32); // c
}
#[test]
fn merge_with_len_one() {
// D <-- A <-- B <-- C
// D <-- A <-- B <-- C
//
// F <-- E
// F <-- E
let d = Node::new(NodeId::from(1, NodeRole::Target)).into_ref();
let a = Node::new(NodeId::from(2, NodeRole::Target)).into_ref();
let b = Node::new(NodeId::from(3, NodeRole::Target)).into_ref();
@@ -707,9 +690,9 @@ mod tests {
let path2 = vec![f.clone()];
merge(path1, path2);
// D <-- A <-- B <-- C
// |
// F --> -->
// D <-- A <-- B <-- C
// |
// F --> -->
assert_eq!(f.borrow().clone().parent.unwrap().borrow().id.who, 4u32); // c
}
@@ -718,14 +701,8 @@ mod tests {
use super::*;
let assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 25), (20, 75)],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 50), (20, 50)],
},
StakedAssignment { who: 1, distribution: vec![(10, 25), (20, 75)] },
StakedAssignment { who: 2, distribution: vec![(10, 50), (20, 50)] },
];
let mut new_assignments = assignments.clone();
@@ -735,14 +712,8 @@ mod tests {
assert_eq!(
new_assignments,
vec![
StakedAssignment {
who: 1,
distribution: vec![(20, 100),],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 75), (20, 25),],
},
StakedAssignment { who: 1, distribution: vec![(20, 100),] },
StakedAssignment { who: 2, distribution: vec![(10, 75), (20, 25),] },
],
);
}
@@ -750,26 +721,11 @@ mod tests {
#[test]
fn basic_reduce_all_cycles_works() {
let mut assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10)],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5)],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 15), (40, 15)],
},
StakedAssignment {
who: 4,
distribution: vec![(20, 10), (30, 10), (40, 20)],
},
StakedAssignment {
who: 5,
distribution: vec![(20, 20), (30, 10), (40, 20)],
},
StakedAssignment { who: 1, distribution: vec![(10, 10)] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
];
assert_eq!(3, reduce_all(&mut assignments));
@@ -777,26 +733,11 @@ mod tests {
assert_eq!(
assignments,
vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10),]
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5),],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 30),],
},
StakedAssignment {
who: 4,
distribution: vec![(40, 40),]
},
StakedAssignment {
who: 5,
distribution: vec![(20, 15), (30, 20), (40, 15),],
},
StakedAssignment { who: 1, distribution: vec![(10, 10),] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
StakedAssignment { who: 3, distribution: vec![(20, 30),] },
StakedAssignment { who: 4, distribution: vec![(40, 40),] },
StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
],
)
}
@@ -804,26 +745,11 @@ mod tests {
#[test]
fn basic_reduce_works() {
let mut assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10)],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5)],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 15), (40, 15)],
},
StakedAssignment {
who: 4,
distribution: vec![(20, 10), (30, 10), (40, 20)],
},
StakedAssignment {
who: 5,
distribution: vec![(20, 20), (30, 10), (40, 20)],
},
StakedAssignment { who: 1, distribution: vec![(10, 10)] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
];
assert_eq!(3, reduce(&mut assignments));
@@ -831,26 +757,11 @@ mod tests {
assert_eq!(
assignments,
vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10),]
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5),],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 30),],
},
StakedAssignment {
who: 4,
distribution: vec![(40, 40),]
},
StakedAssignment {
who: 5,
distribution: vec![(20, 15), (30, 20), (40, 15),],
},
StakedAssignment { who: 1, distribution: vec![(10, 10),] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
StakedAssignment { who: 3, distribution: vec![(20, 30),] },
StakedAssignment { who: 4, distribution: vec![(40, 40),] },
StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
],
)
}
@@ -858,35 +769,14 @@ mod tests {
#[test]
fn should_deal_with_self_vote() {
let mut assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10)],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5)],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 15), (40, 15)],
},
StakedAssignment {
who: 4,
distribution: vec![(20, 10), (30, 10), (40, 20)],
},
StakedAssignment {
who: 5,
distribution: vec![(20, 20), (30, 10), (40, 20)],
},
StakedAssignment { who: 1, distribution: vec![(10, 10)] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5)] },
StakedAssignment { who: 3, distribution: vec![(20, 15), (40, 15)] },
StakedAssignment { who: 4, distribution: vec![(20, 10), (30, 10), (40, 20)] },
StakedAssignment { who: 5, distribution: vec![(20, 20), (30, 10), (40, 20)] },
// self vote from 10 and 20 to itself.
StakedAssignment {
who: 10,
distribution: vec![(10, 100)],
},
StakedAssignment {
who: 20,
distribution: vec![(20, 200)],
},
StakedAssignment { who: 10, distribution: vec![(10, 100)] },
StakedAssignment { who: 20, distribution: vec![(20, 200)] },
];
assert_eq!(3, reduce(&mut assignments));
@@ -894,35 +784,14 @@ mod tests {
assert_eq!(
assignments,
vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10),]
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 5),],
},
StakedAssignment {
who: 3,
distribution: vec![(20, 30),],
},
StakedAssignment {
who: 4,
distribution: vec![(40, 40),]
},
StakedAssignment {
who: 5,
distribution: vec![(20, 15), (30, 20), (40, 15),],
},
StakedAssignment { who: 1, distribution: vec![(10, 10),] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 5),] },
StakedAssignment { who: 3, distribution: vec![(20, 30),] },
StakedAssignment { who: 4, distribution: vec![(40, 40),] },
StakedAssignment { who: 5, distribution: vec![(20, 15), (30, 20), (40, 15),] },
// should stay untouched.
StakedAssignment {
who: 10,
distribution: vec![(10, 100)]
},
StakedAssignment {
who: 20,
distribution: vec![(20, 200)]
},
StakedAssignment { who: 10, distribution: vec![(10, 100)] },
StakedAssignment { who: 20, distribution: vec![(20, 200)] },
],
)
}
@@ -930,55 +799,23 @@ mod tests {
#[test]
fn reduce_3_common_votes_same_weight() {
let mut assignments = vec![
StakedAssignment {
who: 4,
distribution: vec![
(
1000000,
100,
),
(
1000002,
100,
),
(
1000004,
100,
),
],
},
StakedAssignment {
who: 5,
distribution: vec![
(
1000000,
100,
),
(
1000002,
100,
),
(
1000004,
100,
),
],
},
];
StakedAssignment {
who: 4,
distribution: vec![(1000000, 100), (1000002, 100), (1000004, 100)],
},
StakedAssignment {
who: 5,
distribution: vec![(1000000, 100), (1000002, 100), (1000004, 100)],
},
];
reduce_4(&mut assignments);
assert_eq!(
assignments,
vec![
StakedAssignment {
who: 4,
distribution: vec![(1000000, 200,), (1000004, 100,),],
},
StakedAssignment {
who: 5,
distribution: vec![(1000002, 200,), (1000004, 100,),],
},
StakedAssignment { who: 4, distribution: vec![(1000000, 200,), (1000004, 100,),] },
StakedAssignment { who: 5, distribution: vec![(1000002, 200,), (1000004, 100,),] },
],
)
}
@@ -987,18 +824,9 @@ mod tests {
#[should_panic]
fn reduce_panics_on_duplicate_voter() {
let mut assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 10), (20, 10)],
},
StakedAssignment {
who: 1,
distribution: vec![(10, 15), (20, 5)],
},
StakedAssignment {
who: 2,
distribution: vec![(10, 15), (20, 15)],
},
StakedAssignment { who: 1, distribution: vec![(10, 10), (20, 10)] },
StakedAssignment { who: 1, distribution: vec![(10, 15), (20, 5)] },
StakedAssignment { who: 2, distribution: vec![(10, 15), (20, 15)] },
];
reduce(&mut assignments);
@@ -1007,10 +835,7 @@ mod tests {
#[test]
fn should_deal_with_duplicates_target() {
let mut assignments = vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 15), (20, 5)],
},
StakedAssignment { who: 1, distribution: vec![(10, 15), (20, 5)] },
StakedAssignment {
who: 2,
distribution: vec![
@@ -1029,10 +854,7 @@ mod tests {
assert_eq!(
assignments,
vec![
StakedAssignment {
who: 1,
distribution: vec![(10, 20),],
},
StakedAssignment { who: 1, distribution: vec![(10, 20),] },
StakedAssignment {
who: 2,
distribution: vec![