updated protobuf serialisation

src/agreement/mod.rs

@@ -1,6 +1,6 @@
 //! Binary Byzantine agreement protocol from a common coin protocol.
 
-mod bin_values;
+pub mod bin_values;
 
 use std::collections::{BTreeMap, BTreeSet, VecDeque};
 use std::fmt::Debug;
@@ -38,26 +38,26 @@ pub enum AgreementContent {
 #[cfg_attr(feature = "serialization-serde", derive(Serialize))]
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct AgreementMessage {
-    epoch: u32,
-    content: AgreementContent,
+    pub epoch: u32,
+    pub content: AgreementContent,
 }
 
 impl AgreementMessage {
-    fn bval(epoch: u32, b: bool) -> Self {
+    pub fn bval(epoch: u32, b: bool) -> Self {
         AgreementMessage {
             epoch,
             content: AgreementContent::BVal(b),
         }
     }
 
-    fn aux(epoch: u32, b: bool) -> Self {
+    pub fn aux(epoch: u32, b: bool) -> Self {
         AgreementMessage {
             epoch,
             content: AgreementContent::Aux(b),
         }
     }
 
-    fn conf(epoch: u32, v: BinValues) -> Self {
+    pub fn conf(epoch: u32, v: BinValues) -> Self {
         AgreementMessage {
             epoch,
             content: AgreementContent::Conf(v),

src/proto/mod.rs

@@ -1,12 +1,14 @@
 //! Construction of messages from protobuf buffers.
 pub mod message;
 
-use agreement::{AgreementMessage, BinValues};
-use broadcast::BroadcastMessage;
 use merkle::proof::{Lemma, Positioned, Proof};
-use proto::message::*;
 use ring::digest::Algorithm;
 
+use agreement::{AgreementContent, AgreementMessage};
+use agreement::bin_values::BinValues;
+use broadcast::BroadcastMessage;
+use proto::message::*;
+
 impl From<message::BroadcastProto> for BroadcastMessage {
     fn from(proto: message::BroadcastProto) -> BroadcastMessage {
         BroadcastMessage::from_proto(proto, &::ring::digest::SHA256)
@@ -66,17 +68,15 @@ impl BroadcastMessage {
 impl AgreementMessage {
     pub fn into_proto(self) -> message::AgreementProto {
         let mut p = message::AgreementProto::new();
-        match self {
-            AgreementMessage::BVal(e, b) => {
-                p.set_epoch(e);
+        p.set_epoch(self.epoch);
+        match self.content {
+            AgreementContent::BVal(b) => {
                 p.set_bval(b);
             }
-            AgreementMessage::Aux(e, b) => {
-                p.set_epoch(e);
+            AgreementContent::Aux(b) => {
                 p.set_aux(b);
             }
-            AgreementMessage::Conf(e, v) => {
-                p.set_epoch(e);
+            AgreementContent::Conf(v) => {
                 let bin_values = match v {
                     BinValues::None => 0,
                     BinValues::False => 1,
@@ -94,9 +94,9 @@ impl AgreementMessage {
     pub fn from_proto(mp: message::AgreementProto) -> Option<Self> {
         let epoch = mp.get_epoch();
         if mp.has_bval() {
-            Some(AgreementMessage::BVal(epoch, mp.get_bval()))
+            Some(AgreementMessage::bval(epoch, mp.get_bval()))
         } else if mp.has_aux() {
-            Some(AgreementMessage::Aux(epoch, mp.get_aux()))
+            Some(AgreementMessage::aux(epoch, mp.get_aux()))
         } else if mp.has_conf() {
             match mp.get_conf() {
                 0 => Some(BinValues::None),
@@ -104,7 +104,7 @@ impl AgreementMessage {
                 2 => Some(BinValues::True),
                 3 => Some(BinValues::Both),
                 _ => None,
-            }.map(|bin_values| AgreementMessage::Conf(epoch, bin_values))
+            }.map(|bin_values| AgreementMessage::conf(epoch, bin_values))
         } else {
             None
         }