Clean-ups

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

diff --git a/lock_client.h b/lock_client.h
index 541cc23..7a4d43f 100644 (file)
--- a/lock_client.h
+++ b/lock_client.h
@@ -1,17 +1,15 @@
 // lock client interface.
 
 #ifndef lock_client_h
 // lock client interface.
 
 #ifndef lock_client_h

-

 #define lock_client_h
 
 #ifdef __cplusplus
 
 #define lock_client_h
 
 #ifdef __cplusplus
 

-#include <string>
+#include "types.h"

 #include "lock_protocol.h"
 #include "lock_protocol.h"

-#include "rpc/rpc.h"
-#include "lang/verify.h"

 #include "rpc/fifo.h"
 #include "rsm_client.h"
 #include "rpc/fifo.h"
 #include "rsm_client.h"

+#include "maybe.h"

 
 class lock_release_user {
     public:
 
 class lock_release_user {
     public:

@@ -19,16 +17,8 @@ class lock_release_user {
         virtual ~lock_release_user() {}
 };
 
         virtual ~lock_release_user() {}
 };
 

-using std::string;
-using std::thread;
-using std::list;
-using std::map;
-
-typedef string callback;
-

 class lock_state {
 public:
 class lock_state {
 public:

-    lock_state();

     enum {
         none = 0,
         retrying,
     enum {
         none = 0,
         retrying,

@@ -36,40 +26,40 @@ public:
         locked,
         acquiring,
         releasing
         locked,
         acquiring,
         releasing

-    } state;
+    } state = none;

     std::thread::id held_by;
     std::thread::id held_by;

-    list<std::thread::id> wanted_by;
-    mutex m;
-    map<std::thread::id, std::condition_variable> c;
+    std::list<thread::id> wanted_by;
+    std::mutex m;
+    std::map<thread::id, cond> c;

     lock_protocol::xid_t xid;
     lock_protocol::xid_t xid;

-    void wait();
+    void wait(lock & mutex_lock);

     void signal();
     void signal();

-    void signal(std::thread::id who);
+    void signal(thread::id who);

 };
 
 };
 

-typedef map<lock_protocol::lockid_t, lock_state> lock_map;
+typedef std::map<lock_protocol::lockid_t, lock_state> lock_map;

 
 // Clients that caches locks.  The server can revoke locks using
 // lock_revoke_server.
 class lock_client {
     private:
 
 // Clients that caches locks.  The server can revoke locks using
 // lock_revoke_server.
 class lock_client {
     private:

-        rpcc *cl;
-        std::thread releaser_thread;
-        rsm_client *rsmc;
-        class lock_release_user *lu;
-        unsigned int rlock_port;
+        unique_ptr<rpcc> cl;
+        unique_ptr<rpcs> rlsrpc;
+        thread releaser_thread;
+        unique_ptr<rsm_client> rsmc;
+        lock_release_user *lu;
+        in_port_t rlock_port;

         string hostname;
         string id;
         string hostname;
         string id;

-        mutex xid_mutex;
+        std::mutex xid_mutex;

         lock_protocol::xid_t next_xid;
         lock_protocol::xid_t next_xid;

-        fifo<lock_protocol::lockid_t> release_fifo;
-        mutex lock_table_lock;
+        fifo<maybe<lock_protocol::lockid_t>> release_fifo;
+        std::mutex lock_table_lock;

         lock_map lock_table;
         lock_map lock_table;

-        lock_state &get_lock_state(lock_protocol::lockid_t lid);
+        lock_state & get_lock_state(lock_protocol::lockid_t lid);

     public:
     public:

-        static unsigned int last_port;
-        lock_client(string xdst, class lock_release_user *l = 0);
-        ~lock_client() {}
+        lock_client(string xdst, lock_release_user *l = 0);
+        ~lock_client();

         lock_protocol::status acquire(lock_protocol::lockid_t);
         lock_protocol::status release(lock_protocol::lockid_t);
         int stat(lock_protocol::lockid_t);
         lock_protocol::status acquire(lock_protocol::lockid_t);
         lock_protocol::status release(lock_protocol::lockid_t);
         int stat(lock_protocol::lockid_t);

@@ -80,7 +70,9 @@ class lock_client {
 
 #endif // C++
 
 
 #endif // C++
 

+#ifdef __cplusplus

 extern "C" {
 extern "C" {

+#endif

 
 struct _t4_lock_client;
 typedef struct _t4_lock_client t4_lock_client;
 
 struct _t4_lock_client;
 typedef struct _t4_lock_client t4_lock_client;

@@ -103,6 +95,8 @@ t4_status t4_lock_client_acquire(t4_lock_client *, t4_lockid_t);
 t4_status t4_lock_client_release(t4_lock_client *, t4_lockid_t);
 t4_status t4_lock_client_stat(t4_lock_client *, t4_lockid_t);
 
 t4_status t4_lock_client_release(t4_lock_client *, t4_lockid_t);
 t4_status t4_lock_client_stat(t4_lock_client *, t4_lockid_t);
 

+#ifdef __cplusplus

 }
 }

+#endif

 
 #endif
 
 #endif