Actually, you know, build.

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

diff --git a/rsm.h b/rsm.h
index c5bf4fc..517316a 100644 (file)
--- a/rsm.h
+++ b/rsm.h
@@ -7,11 +7,10 @@
 #include <vector>
 #include "rsm_protocol.h"
 #include "rsm_state_transfer.h"
 #include <vector>
 #include "rsm_protocol.h"
 #include "rsm_state_transfer.h"

-#include "rpc.h"
+#include "rpc/rpc.h"

 #include <arpa/inet.h>
 #include "config.h"
 
 #include <arpa/inet.h>
 #include "config.h"
 

-

 class rsm : public config_view_change {
     private:
         void reg1(int proc, handler *);
 class rsm : public config_view_change {
     private:
         void reg1(int proc, handler *);

@@ -39,26 +38,24 @@ class rsm : public config_view_change {
         bool break2;
 
 
         bool break2;
 
 

-        rsm_client_protocol::status client_members(int i,
-                std::vector<std::string> &r);
-        rsm_protocol::status invoke(int proc, viewstamp vs, std::string mreq,
-                int &dummy);
-        rsm_protocol::status transferreq(std::string src, viewstamp last, unsigned vid,
-                rsm_protocol::transferres &r);
-        rsm_protocol::status transferdonereq(std::string m, unsigned vid, int &);
-        rsm_protocol::status joinreq(std::string src, viewstamp last,
-                rsm_protocol::joinres &r);
-        rsm_test_protocol::status test_net_repairreq(int heal, int &r);
-        rsm_test_protocol::status breakpointreq(int b, int &r);
+        rsm_client_protocol::status client_members(std::vector<std::string> &r, int i);
+        rsm_protocol::status invoke(int &, int proc, viewstamp vs, std::string mreq);
+        rsm_protocol::status transferreq(rsm_protocol::transferres &r, std::string src,
+                viewstamp last, unsigned vid);
+        rsm_protocol::status transferdonereq(int &, std::string m, unsigned vid);
+        rsm_protocol::status joinreq(rsm_protocol::joinres &r, std::string src,
+                viewstamp last);
+        rsm_test_protocol::status test_net_repairreq(int &r, int heal);
+        rsm_test_protocol::status breakpointreq(int &r, int b);

 
 

-        mutex rsm_mutex;
-        mutex invoke_mutex;
-        cond recovery_cond;
-        cond sync_cond;
+        std::mutex rsm_mutex;
+        std::mutex invoke_mutex;
+        std::condition_variable recovery_cond;
+        std::condition_variable sync_cond;

 
         void execute(int procno, std::string req, std::string &r);
 
         void execute(int procno, std::string req, std::string &r);

-        rsm_client_protocol::status client_invoke(int procno, std::string req,
-                std::string &r);
+        rsm_client_protocol::status client_invoke(std::string &r, int procno,
+                std::string req);

         bool statetransfer(std::string m);
         bool statetransferdone(std::string m);
         bool join(std::string m);
         bool statetransfer(std::string m);
         bool statetransferdone(std::string m);
         bool join(std::string m);

@@ -80,157 +77,11 @@ class rsm : public config_view_change {
         void recovery();
         void commit_change(unsigned vid);
 
         void recovery();
         void commit_change(unsigned vid);
 

-        template<class S, class A1, class R>
-        void reg(int proc, S*, int (S::*meth)(const A1 a1, R &));
-        template<class S, class A1, class A2, class R>
-        void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2, R &));
-        template<class S, class A1, class A2, class A3, class R>
-        void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
-                    const A3 a3, R &));
-        template<class S, class A1, class A2, class A3, class A4, class R>
-        void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
-                    const A3 a3, const A4 a4, R &));
-        template<class S, class A1, class A2, class A3, class A4, class A5, class R>
-        void reg(int proc, S*, int (S::*meth)(const A1 a1, const A2 a2,
-                    const A3 a3, const A4 a4, const A5 a5, R &));
+        template<class F, class C=void> void reg(int proc, F f, C *c=nullptr);

 };
 
 };
 

-template<class S, class A1, class R>
-void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, R & r)) {
-  class h1 : public handler {
-  private:
-    S * sob;
-    int (S::*meth)(const A1 a1, R & r);
-  public:
-  h1(S *xsob, int (S::*xmeth)(const A1 a1, R & r))
-      : sob(xsob), meth(xmeth) { }
-    int fn(unmarshall &args, marshall &ret) {
-      A1 a1;
-      R r;
-      args >> a1;
-      VERIFY(args.okdone());
-      int b = (sob->*meth)(a1,r);
-      ret << r;
-      return b;
-    }
-  };
-  reg1(proc, new h1(sob, meth));
-}
-
-template<class S, class A1, class A2, class R>
-void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2, R & r)) {
- class h1 : public handler {
-  private:
-    S * sob;
-    int (S::*meth)(const A1 a1, const A2 a2, R & r);
-  public:
-  h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, R & r))
-    : sob(xsob), meth(xmeth) { }
-    int fn(unmarshall &args, marshall &ret) {
-      A1 a1;
-      A2 a2;
-      R r;
-      args >> a1;
-      args >> a2;
-      VERIFY(args.okdone());
-      int b = (sob->*meth)(a1,a2,r);
-      ret << r;
-      return b;
-    }
-  };
-  reg1(proc, new h1(sob, meth));
-}
-
-template<class S, class A1, class A2, class A3, class R>
-void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
-             const A3 a3, R & r)) {
- class h1 : public handler {
-  private:
-    S * sob;
-    int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, R & r);
-  public:
-  h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3, R & r))
-    : sob(xsob), meth(xmeth) { }
-    int fn(unmarshall &args, marshall &ret) {
-      A1 a1;
-      A2 a2;
-      A3 a3;
-      R r;
-      args >> a1;
-      args >> a2;
-      args >> a3;
-      VERIFY(args.okdone());
-      int b = (sob->*meth)(a1,a2,a3,r);
-      ret << r;
-      return b;
-    }
-  };
-  reg1(proc, new h1(sob, meth));
-}
-
-template<class S, class A1, class A2, class A3, class A4, class R>
-void rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
-             const A3 a3, const A4 a4, R & r)) {
- class h1 : public handler {
-  private:
-    S * sob;
-    int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4, R & r);
-  public:
-  h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
-            const A4 a4, R & r))
-    : sob(xsob), meth(xmeth) { }
-    int fn(unmarshall &args, marshall &ret) {
-      A1 a1;
-      A2 a2;
-      A3 a3;
-      A4 a4;
-      R r;
-      args >> a1;
-      args >> a2;
-      args >> a3;
-      args >> a4;
-      VERIFY(args.okdone());
-      int b = (sob->*meth)(a1,a2,a3,a4,r);
-      ret << r;
-      return b;
-    }
-  };
-  reg1(proc, new h1(sob, meth));
-}
-
-
-template<class S, class A1, class A2, class A3, class A4, class A5, class R> void
-  rsm::reg(int proc, S*sob, int (S::*meth)(const A1 a1, const A2 a2,
-             const A3 a3, const A4 a4,
-             const A5 a5, R & r))
-{
- class h1 : public handler {
-  private:
-    S * sob;
-    int (S::*meth)(const A1 a1, const A2 a2, const A3 a3, const A4 a4,
-       const A5 a5, R & r);
-  public:
-  h1(S *xsob, int (S::*xmeth)(const A1 a1, const A2 a2, const A3 a3,
-            const A4 a4, const A5 a5, R & r))
-    : sob(xsob), meth(xmeth) { }
-    int fn(unmarshall &args, marshall &ret) {
-      A1 a1;
-      A2 a2;
-      A3 a3;
-      A4 a4;
-      A5 a5;
-      R r;
-      args >> a1;
-      args >> a2;
-      args >> a3;
-      args >> a4;
-      VERIFY(args.okdone());
-      int b = (sob->*meth)(a1,a2,a3,a4,a5,r);
-      ret << r;
-      return b;
-    }
-  };
-  reg1(proc, new h1(sob, meth));
+template<class F, class C> void rsm::reg(int proc, F f, C *c) {
+    reg1(proc, marshalled_func<F>::wrap(f, c));

 }
 
 #endif /* rsm_h */
 }
 
 #endif /* rsm_h */