Improve Consensus interface and documentation (RIPD-1340):

- Add Consensus::Result, which represents the result of the
establish state and includes the consensus transaction set, final
proposed position and disputes.
- Add Consensus::Mode to track how we are participating in
consensus and ensures the onAccept callback can distinguish when
we entered the round with consensus versus when we recovered from
a wrong ledger during a round.
- Rename Consensus::Phase to Consensus::State and eliminate the
processing phase.  Instead, accept is a terminal phase which
notifies RCLConsensus via onAccept callbacks.  Even if clients
dispatch accepting to another thread, all future calls except to
startRound will not change the state of consensus.
- Move validate_ status from Consensus to RCLConsensus, since
generic implementation does not directly reference whether a node
is validating or not.
- Eliminate gotTxSetInternal and handle externally received
TxSets distinct from locally generated positions.
- Change ConsensusProposal::changePosition to always update the
internal close time and position even if we have bowed out. This
enforces the invariant that our proposal's position always
matches our transaction set.

src/test/csf/impl/UNL.cpp

@@ -16,10 +16,10 @@
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 //==============================================================================
-#include <test/csf/UNL.h>
 #include <boost/iterator/counting_iterator.hpp>
-#include <fstream>
 #include <algorithm>
+#include <fstream>
+#include <test/csf/UNL.h>
 
 namespace ripple {
 namespace test {
@@ -38,8 +38,8 @@ TrustGraph::canFork(double quorum) const
 
     for (int i = 0; i < assignment_.size(); ++i)
     {
-        auto const & myUNL = UNLs_[assignment_[i]];
-        if(myUNL.find(i) == myUNL.end())
+        auto const& myUNL = UNLs_[assignment_[i]];
+        if (myUNL.find(i) == myUNL.end())
         {
             auto myUNLcopy = myUNL;
             myUNLcopy.insert(i);
@@ -50,21 +50,20 @@ TrustGraph::canFork(double quorum) const
     // Loop over all pairs of uniqueUNLs
     for (int i = 0; i < uniqueUNLs.size(); ++i)
     {
-        for (int j = (i+1); j < uniqueUNLs.size(); ++j)
+        for (int j = (i + 1); j < uniqueUNLs.size(); ++j)
         {
-            auto const & unlA = uniqueUNLs[i];
-            auto const & unlB = uniqueUNLs[j];
+            auto const& unlA = uniqueUNLs[i];
+            auto const& unlB = uniqueUNLs[j];
 
-            double rhs = 2.0*(1.-quorum) *
-                std::max(unlA.size(), unlB.size() );
+            double rhs =
+                2.0 * (1. - quorum) * std::max(unlA.size(), unlB.size());
 
-            int intersectionSize =  std::count_if(unlA.begin(), unlA.end(),
-                [&](PeerID id)
-                {
+            int intersectionSize =
+                std::count_if(unlA.begin(), unlA.end(), [&](PeerID id) {
                     return unlB.find(id) != unlB.end();
                 });
 
-            if(intersectionSize < rhs)
+            if (intersectionSize < rhs)
                 return true;
         }
     }
@@ -80,56 +79,53 @@ TrustGraph::makeClique(int size, int overlap)
     // Clique A has nodes [0,endA) and Clique B has [startB,numPeers)
     // Note: Clique B will have an extra peer when numPeers - overlap
     //       is odd
-    int endA = (size + overlap)/2;
-    int startB = (size - overlap)/2;
+    int endA = (size + overlap) / 2;
+    int startB = (size - overlap) / 2;
 
     std::vector<UNL> unls;
     unls.emplace_back(bci(0), bci(endA));
     unls.emplace_back(bci(startB), bci(size));
     unls.emplace_back(bci(0), bci(size));
 
-    std::vector<int> assignment(size,0);
+    std::vector<int> assignment(size, 0);
 
     for (int i = 0; i < size; ++i)
     {
-        if(i < startB)
+        if (i < startB)
             assignment[i] = 0;
-        else if(i > endA)
+        else if (i > endA)
             assignment[i] = 1;
         else
             assignment[i] = 2;
     }
 
-
     return TrustGraph(unls, assignment);
 }
 
 TrustGraph
 TrustGraph::makeComplete(int size)
 {
-    UNL all{ boost::counting_iterator<PeerID>( 0 ),
-             boost::counting_iterator<PeerID>( size ) };
+    UNL all{boost::counting_iterator<PeerID>(0),
+            boost::counting_iterator<PeerID>(size)};
 
-    return TrustGraph(std::vector<UNL>(1,all),
-                      std::vector<int>(size, 0));
+    return TrustGraph(std::vector<UNL>(1, all), std::vector<int>(size, 0));
 }
 
-inline void TrustGraph::save_dot(std::string const & fileName)
+inline void
+TrustGraph::save_dot(std::string const& fileName)
 {
     std::ofstream out(fileName);
     out << "digraph {\n";
     for (int i = 0; i < assignment_.size(); ++i)
     {
-        for (auto & j : UNLs_[assignment_[i]])
+        for (auto& j : UNLs_[assignment_[i]])
         {
             out << i << " -> " << j << ";\n";
         }
-
     }
     out << "}\n";
-
 }
 
-} // csf
-} // test
-} // ripple
+}  // csf
+}  // test
+}  // ripple