Split vote crate into more modules

Code/consensus/src/executor.rs

@@ -11,9 +11,9 @@ use malachite_common::{
 use malachite_round::events::Event as RoundEvent;
 use malachite_round::message::Message as RoundMessage;
 use malachite_round::state::State as RoundState;
-use malachite_vote::count::Threshold;
 use malachite_vote::keeper::Message as VoteMessage;
 use malachite_vote::keeper::VoteKeeper;
+use malachite_vote::Threshold;
 
 /// Messages that can be received and broadcast by the consensus executor.
 #[derive(Clone, Debug, PartialEq, Eq)]

Code/test/tests/round_votes.rs

@@ -1,6 +1,6 @@
 use malachite_common::Round;
-use malachite_vote::count::Threshold;
-use malachite_vote::RoundVotes;
+use malachite_vote::round_votes::RoundVotes;
+use malachite_vote::Threshold;
 
 use malachite_test::{Address, Height, TestContext, ValueId, Vote};
 

Code/test/tests/vote_count.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::bool_assert_comparison)]
 
-use malachite_vote::count::{Threshold, VoteCount};
+use malachite_vote::count::VoteCount;
+use malachite_vote::Threshold;
 
 #[test]
 fn vote_count_nil() {

Code/vote/src/count.rs

@@ -1,51 +1,11 @@
-use alloc::collections::BTreeMap;
 use alloc::collections::BTreeSet;
 
-// TODO: Introduce newtype
-// QUESTION: Over what type? i64?
-pub type Weight = u64;
+use crate::value_weights::ValuesWeights;
+use crate::{Threshold, Weight};
 
-/// A value and the weight of votes for it.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ValuesWeights<Value> {
-    value_weights: BTreeMap<Value, Weight>,
-}
-
-impl<Value> ValuesWeights<Value> {
-    pub fn new() -> ValuesWeights<Value> {
-        ValuesWeights {
-            value_weights: BTreeMap::new(),
-        }
-    }
-
-    /// Add weight to the value and return the new weight.
-    pub fn add(&mut self, value: Value, weight: Weight) -> Weight
-    where
-        Value: Ord,
-    {
-        let entry = self.value_weights.entry(value).or_insert(0);
-        *entry += weight; // FIXME: Deal with overflows
-        *entry
-    }
-
-    /// Return the weight of the value, or 0 if it is not present.
-    pub fn get(&self, value: &Value) -> Weight
-    where
-        Value: Ord,
-    {
-        self.value_weights.get(value).copied().unwrap_or(0)
-    }
-
-    /// Return the sum of the weights of all values.
-    pub fn sum(&self) -> Weight {
-        self.value_weights.values().sum() // FIXME: Deal with overflows
-    }
-}
-
-impl<Value> Default for ValuesWeights<Value> {
-    fn default() -> Self {
-        Self::new()
-    }
+/// Returns whether or note `value > (2/3)*total`.
+fn is_quorum(value: Weight, total: Weight) -> bool {
+    3 * value > 2 * total
 }
 
 /// VoteCount tallys votes of the same type.
@@ -155,64 +115,11 @@ impl<Address, Value> VoteCount<Address, Value> {
     }
 }
 
-//-------------------------------------------------------------------------
-// Round votes
-//-------------------------------------------------------------------------
-
-// Thresh represents the different quorum thresholds.
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Threshold<ValueId> {
-    /// No quorum has been reached yet
-    Unreached,
-    /// Qorum of votes but not for the same value
-    Any,
-    /// Quorum for nil
-    Nil,
-    /// Quorum for a value
-    Value(ValueId),
-}
-
-/// Returns whether or note `value > (2/3)*total`.
-fn is_quorum(value: Weight, total: Weight) -> bool {
-    3 * value > 2 * total
-}
-
 #[cfg(test)]
 #[allow(clippy::bool_assert_comparison)]
 mod tests {
     use super::*;
 
-    #[test]
-    fn values_weights() {
-        let mut vw = ValuesWeights::new();
-
-        assert_eq!(vw.get(&None), 0);
-        assert_eq!(vw.get(&Some(1)), 0);
-
-        assert_eq!(vw.add(None, 1), 1);
-        assert_eq!(vw.get(&None), 1);
-        assert_eq!(vw.get(&Some(1)), 0);
-
-        assert_eq!(vw.add(Some(1), 1), 1);
-        assert_eq!(vw.get(&None), 1);
-        assert_eq!(vw.get(&Some(1)), 1);
-
-        assert_eq!(vw.add(None, 1), 2);
-        assert_eq!(vw.get(&None), 2);
-        assert_eq!(vw.get(&Some(1)), 1);
-
-        assert_eq!(vw.add(Some(1), 1), 2);
-        assert_eq!(vw.get(&None), 2);
-        assert_eq!(vw.get(&Some(1)), 2);
-
-        assert_eq!(vw.add(Some(2), 1), 1);
-        assert_eq!(vw.get(&None), 2);
-        assert_eq!(vw.get(&Some(1)), 2);
-        assert_eq!(vw.get(&Some(2)), 1);
-
-        // FIXME: Test for and deal with overflows
-    }
-
     #[test]
     fn vote_count_nil() {
         let mut vc = VoteCount::new(4);

Code/vote/src/keeper.rs

@@ -2,10 +2,8 @@ use alloc::collections::BTreeMap;
 
 use malachite_common::{Context, Round, ValueId, Vote, VoteType};
 
-use crate::{
-    count::{Threshold, Weight},
-    RoundVotes,
-};
+use crate::round_votes::RoundVotes;
+use crate::{Threshold, Weight};
 
 /// Messages emitted by the vote keeper
 #[derive(Clone, Debug, PartialEq, Eq)]

Code/vote/src/lib.rs

@@ -14,47 +14,22 @@ extern crate alloc;
 
 pub mod count;
 pub mod keeper;
-
-use malachite_common::{Context, Round, ValueId, Vote, VoteType};
-
-use crate::count::{Threshold, VoteCount, Weight};
-
-/// Tracks all the votes for a single round
-#[derive(Clone, Debug)]
-pub struct RoundVotes<Ctx>
-where
-    Ctx: Context,
-{
-    pub height: Ctx::Height,
-    pub round: Round,
-
-    pub prevotes: VoteCount<Ctx::Address, ValueId<Ctx>>,
-    pub precommits: VoteCount<Ctx::Address, ValueId<Ctx>>,
-}
-
-impl<Ctx> RoundVotes<Ctx>
-where
-    Ctx: Context,
-{
-    pub fn new(height: Ctx::Height, round: Round, total: Weight) -> Self {
-        RoundVotes {
-            height,
-            round,
-            prevotes: VoteCount::new(total),
-            precommits: VoteCount::new(total),
-        }
-    }
-
-    pub fn add_vote(&mut self, vote: Ctx::Vote, weight: Weight) -> Threshold<ValueId<Ctx>> {
-        match vote.vote_type() {
-            VoteType::Prevote => {
-                self.prevotes
-                    .add(vote.validator_address().clone(), vote.take_value(), weight)
-            }
-            VoteType::Precommit => {
-                self.precommits
-                    .add(vote.validator_address().clone(), vote.take_value(), weight)
-            }
-        }
-    }
+pub mod round_votes;
+pub mod value_weights;
+
+// TODO: Introduce newtype
+// QUESTION: Over what type? i64?
+pub type Weight = u64;
+
+/// Represents the different quorum thresholds.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Threshold<ValueId> {
+    /// No quorum has been reached yet
+    Unreached,
+    /// Qorum of votes but not for the same value
+    Any,
+    /// Quorum for nil
+    Nil,
+    /// Quorum for a value
+    Value(ValueId),
 }

Code/vote/src/round_votes.rs

@@ -0,0 +1,44 @@
+use malachite_common::{Context, Round, ValueId, Vote, VoteType};
+
+use crate::count::VoteCount;
+use crate::{Threshold, Weight};
+
+/// Tracks all the votes for a single round
+#[derive(Clone, Debug)]
+pub struct RoundVotes<Ctx>
+where
+    Ctx: Context,
+{
+    pub height: Ctx::Height,
+    pub round: Round,
+
+    pub prevotes: VoteCount<Ctx::Address, ValueId<Ctx>>,
+    pub precommits: VoteCount<Ctx::Address, ValueId<Ctx>>,
+}
+
+impl<Ctx> RoundVotes<Ctx>
+where
+    Ctx: Context,
+{
+    pub fn new(height: Ctx::Height, round: Round, total: Weight) -> Self {
+        RoundVotes {
+            height,
+            round,
+            prevotes: VoteCount::new(total),
+            precommits: VoteCount::new(total),
+        }
+    }
+
+    pub fn add_vote(&mut self, vote: Ctx::Vote, weight: Weight) -> Threshold<ValueId<Ctx>> {
+        match vote.vote_type() {
+            VoteType::Prevote => {
+                self.prevotes
+                    .add(vote.validator_address().clone(), vote.take_value(), weight)
+            }
+            VoteType::Precommit => {
+                self.precommits
+                    .add(vote.validator_address().clone(), vote.take_value(), weight)
+            }
+        }
+    }
+}

Code/vote/src/value_weights.rs

@@ -0,0 +1,82 @@
+use alloc::collections::BTreeMap;
+
+use crate::Weight;
+
+/// A value and the weight of votes for it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ValuesWeights<Value> {
+    value_weights: BTreeMap<Value, Weight>,
+}
+
+impl<Value> ValuesWeights<Value> {
+    pub fn new() -> ValuesWeights<Value> {
+        ValuesWeights {
+            value_weights: BTreeMap::new(),
+        }
+    }
+
+    /// Add weight to the value and return the new weight.
+    pub fn add(&mut self, value: Value, weight: Weight) -> Weight
+    where
+        Value: Ord,
+    {
+        let entry = self.value_weights.entry(value).or_insert(0);
+        *entry += weight; // FIXME: Deal with overflows
+        *entry
+    }
+
+    /// Return the weight of the value, or 0 if it is not present.
+    pub fn get(&self, value: &Value) -> Weight
+    where
+        Value: Ord,
+    {
+        self.value_weights.get(value).copied().unwrap_or(0)
+    }
+
+    /// Return the sum of the weights of all values.
+    pub fn sum(&self) -> Weight {
+        self.value_weights.values().sum() // FIXME: Deal with overflows
+    }
+}
+
+impl<Value> Default for ValuesWeights<Value> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn values_weights() {
+        let mut vw = ValuesWeights::new();
+
+        assert_eq!(vw.get(&None), 0);
+        assert_eq!(vw.get(&Some(1)), 0);
+
+        assert_eq!(vw.add(None, 1), 1);
+        assert_eq!(vw.get(&None), 1);
+        assert_eq!(vw.get(&Some(1)), 0);
+
+        assert_eq!(vw.add(Some(1), 1), 1);
+        assert_eq!(vw.get(&None), 1);
+        assert_eq!(vw.get(&Some(1)), 1);
+
+        assert_eq!(vw.add(None, 1), 2);
+        assert_eq!(vw.get(&None), 2);
+        assert_eq!(vw.get(&Some(1)), 1);
+
+        assert_eq!(vw.add(Some(1), 1), 2);
+        assert_eq!(vw.get(&None), 2);
+        assert_eq!(vw.get(&Some(1)), 2);
+
+        assert_eq!(vw.add(Some(2), 1), 1);
+        assert_eq!(vw.get(&None), 2);
+        assert_eq!(vw.get(&Some(1)), 2);
+        assert_eq!(vw.get(&Some(2)), 1);
+
+        // FIXME: Test for and deal with overflows
+    }
+}