More clean-ups and cool template stuff

[invirt/third/libt4.git] / paxos.h

diff --git a/paxos.h b/paxos.h
index 9650de1..8561dd5 100644 (file)
--- a/paxos.h
+++ b/paxos.h
@@ -3,15 +3,19 @@
 
 #include <string>
 #include <vector>
+#include <map>
 #include "rpc/rpc.h"
 #include "paxos_protocol.h"
 #include "log.h"
 #include "lock.h"
 
+using std::string;
+using std::map;
+using std::vector;
 
 class paxos_change {
     public:
-        virtual void paxos_commit(unsigned instance, const std::string & v) = 0;
+        virtual void paxos_commit(unsigned instance, const string & v) = 0;
         virtual ~paxos_change() {}
 };
 
@@ -20,49 +24,49 @@ class acceptor {
         log *l;
         rpcs *pxs;
         paxos_change *cfg;
-        std::string me;
+        string me;
         mutex pxs_mutex;
 
         // Acceptor state
         prop_t n_h;            // number of the highest proposal seen in a prepare
         prop_t n_a;            // number of highest proposal accepted
-        std::string v_a;       // value of highest proposal accepted
+        string v_a;    // value of highest proposal accepted
         unsigned instance_h;   // number of the highest instance we have decided
-        std::map<unsigned,std::string> values; // vals of each instance
+        map<unsigned,string> values;   // vals of each instance
 
-        void commit(unsigned instance, const std::string & v, lock & pxs_mutex_lock);
+        void commit(unsigned instance, const string & v, lock & pxs_mutex_lock);
         paxos_protocol::status preparereq(paxos_protocol::prepareres & r,
-                const std::string & src, paxos_protocol::preparearg a);
-        paxos_protocol::status acceptreq(bool & r, const std::string & src,
+                const string & src, paxos_protocol::preparearg a);
+        paxos_protocol::status acceptreq(bool & r, const string & src,
                 paxos_protocol::acceptarg a);
-        paxos_protocol::status decidereq(int & r, const std::string & src,
+        paxos_protocol::status decidereq(int & r, const string & src,
                 paxos_protocol::decidearg a);
 
         friend class log;
 
     public:
-        acceptor(class paxos_change *cfg, bool _first, const std::string & _me,
-                const std::string & _value);
+        acceptor(class paxos_change *cfg, bool _first, const string & _me,
+                const string & _value);
         ~acceptor() {}
-        void commit(unsigned instance, const std::string & v);
+        void commit(unsigned instance, const string & v);
         unsigned instance() { return instance_h; }
-        const std::string & value(unsigned instance) { return values[instance]; }
-        std::string dump();
-        void restore(const std::string &);
+        const string & value(unsigned instance) { return values[instance]; }
+        string dump();
+        void restore(const string &);
         rpcs *get_rpcs() { return pxs; }
         prop_t get_n_h() { return n_h; }
         unsigned get_instance_h() { return instance_h; }
 };
 
-extern bool isamember(const std::string & m, const std::vector<std::string> & nodes);
-extern std::string print_members(const std::vector<std::string> & nodes);
+extern bool isamember(const string & m, const vector<string> & nodes);
+extern string print_members(const vector<string> & nodes);
 
 class proposer {
     private:
         log *l;
         paxos_change *cfg;
         acceptor *acc;
-        std::string me;
+        string me;
         bool break1;
         bool break2;
 
@@ -73,23 +77,23 @@ class proposer {
         prop_t my_n;           // number of the last proposal used in this instance
 
         void setn();
-        bool prepare(unsigned instance, std::vector<std::string> & accepts,
-                const std::vector<std::string> & nodes,
-                std::string & v);
-        void accept(unsigned instance, std::vector<std::string> & accepts,
-                const std::vector<std::string> & nodes, const std::string & v);
-        void decide(unsigned instance, const std::vector<std::string> & accepts,
-                const std::string & v);
+        bool prepare(unsigned instance, vector<string> & accepts,
+                const vector<string> & nodes,
+                string & v);
+        void accept(unsigned instance, vector<string> & accepts,
+                const vector<string> & nodes, const string & v);
+        void decide(unsigned instance, const vector<string> & accepts,
+                const string & v);
 
         void breakpoint1();
         void breakpoint2();
-        bool majority(const std::vector<std::string> & l1, const std::vector<std::string> & l2);
+        bool majority(const vector<string> & l1, const vector<string> & l2);
 
         friend class log;
     public:
-        proposer(class paxos_change *cfg, class acceptor *_acceptor, const std::string &_me);
+        proposer(class paxos_change *cfg, class acceptor *_acceptor, const string &_me);
         ~proposer() {}
-        bool run(unsigned instance, const std::vector<std::string> & cnodes, const std::string & v);
+        bool run(unsigned instance, const vector<string> & cnodes, const string & v);
         bool isrunning();
         void breakpoint(int b);
 };