fn try_update_epoch(&mut self) -> Result<Step<N>> {
        if self.decision.is_some() {
            // Avoid an infinite regression without making a Binary Agreement step.
            return Ok(Step::default());
        }
        let coin = match self.coin_state.value() {
            None => return Ok(Step::default()), // Still waiting for coin value.
            Some(coin) => coin,
        };
        let def_bin_value = match self.conf_values {
            None => return Ok(Step::default()), // Still waiting for conf value.
            Some(ref values) => values.definite(),
        };

        if Some(coin) == def_bin_value {
            Ok(self.decide(coin))
        } else {
            self.update_epoch(def_bin_value.unwrap_or(coin))
        }
    }
/// If this epoch's coin value or conf values are not known yet, does nothing, otherwise
/// updates the epoch or decides.
///
/// With two conf values, the next epoch's estimate is the coin value. If there is only one conf
/// value and that disagrees with the coin, the conf value is the next epoch's estimate. If
/// the unique conf value agrees with the coin, terminates and decides on that value.
If this epoch's coin value or conf values are not known yet, does nothing, otherwise
updates the epoch or decides.

With two conf values, the next epoch's estimate is the coin value. If there is only one conf
value and that disagrees with the coin, the conf value is the next epoch's estimate. If
the unique conf value agrees with the coin, terminates and decides on that value.
If this epoch ' s coin value or conf values are not known yet does nothing otherwise updates the epoch or decides . With two conf values the next epoch ' s estimate is the coin value . If there is only one conf value and that disagrees with the coin the conf value is the next epoch ' s estimate . If the unique conf value agrees with the coin terminates and decides on that value .
fn try_update_epoch(&mut self) -> Result<Step<N>> {
        if self.decision.is_some() {
            // Avoid an infinite regression without making a Binary Agreement step.
            return Ok(Step::default());
        }
        let coin = match self.coin_state.value() {
            None => return Ok(Step::default()), // Still waiting for coin value.
            Some(coin) => coin,
        };
        let def_bin_value = match self.conf_values {
            None => return Ok(Step::default()), // Still waiting for conf value.
            Some(ref values) => values.definite(),
        };
        if Some(coin) == def_bin_value {
            Ok(self.decide(coin))
        } else {
            self.update_epoch(def_bin_value.unwrap_or(coin))
        }
    }
fn try_update_epoch ( & mut self ) -> Result < Step < N > > { if self . decision . is_some ( ) { // Avoid an infinite regression without making a Binary Agreement step. return Ok ( Step :: default ( ) ) ; } let coin = match self . coin_state . value ( ) { None => return Ok ( Step :: default ( ) ) , // Still waiting for coin value. Some ( coin ) => coin , } ; let def_bin_value = match self . conf_values { None => return Ok ( Step :: default ( ) ) , // Still waiting for conf value. Some ( ref values ) => values . definite ( ) , } ; if Some ( coin ) == def_bin_value { Ok ( self . decide ( coin ) ) } else { self . update_epoch ( def_bin_value . unwrap_or ( coin ) ) } }
If this epoch's coin value or conf values are not known yet, does nothing, otherwise
updates the epoch or decides.
If this epoch ' s coin value or conf values are not known yet does nothing otherwise updates the epoch or decides .
&mut self
&mut self