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 <string>
 #include <vector>

+#include <map>

 #include "rpc/rpc.h"
 #include "paxos_protocol.h"
 #include "log.h"
 #include "lock.h"
 
 #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:
 
 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() {}
 };
 
         virtual ~paxos_change() {}
 };
 

@@ -20,49 +24,49 @@ class acceptor {
         log *l;
         rpcs *pxs;
         paxos_change *cfg;
         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
         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
         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,
         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::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:
                 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() {}
         ~acceptor() {}

-        void commit(unsigned instance, const std::string & v);
+        void commit(unsigned instance, const string & v);

         unsigned instance() { return instance_h; }
         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; }
 };
 
         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;
 
 class proposer {
     private:
         log *l;
         paxos_change *cfg;
         acceptor *acc;

-        std::string me;
+        string me;

         bool break1;
         bool break2;
 
         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();
         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();
 
         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:
 
         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() {}
         ~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);
 };
         bool isrunning();
         void breakpoint(int b);
 };