X-Git-Url: http://xvm.mit.edu/gitweb/invirt/third/libt4.git/blobdiff_plain/5a5c578e2e358a121cdb9234a6cb11c4ecfbf323..02967a43024ce81912cd1ec96a800397457f8066:/lock_client.h

diff --git a/lock_client.h b/lock_client.h
index 36ee3a2..9e449f4 100644
--- a/lock_client.h
+++ b/lock_client.h
@@ -9,6 +9,7 @@
 #include "lock_protocol.h"
 #include "rpc/fifo.h"
 #include "rsm_client.h"
+#include "maybe.h"
 
 class lock_release_user {
     public:
@@ -26,42 +27,40 @@ public:
         acquiring,
         releasing
     } state = none;
-    thread::id held_by;
-    list<thread::id> wanted_by;
-    mutex m;
-    map<thread::id, cond> c;
+    std::thread::id held_by;
+    std::list<thread::id> wanted_by;
+    std::mutex m;
+    std::map<thread::id, cond> c;
     lock_protocol::xid_t xid;
     void wait(lock & mutex_lock);
     void signal();
     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:
-        rpcc *cl;
+        unique_ptr<rpcs> rlsrpc;
         thread releaser_thread;
-        rsm_client *rsmc;
-        class lock_release_user *lu;
-        unsigned int rlock_port;
+        unique_ptr<rsm_client> rsmc;
+        lock_release_user *lu;
+        in_port_t rlock_port;
         string hostname;
         string id;
-        mutex xid_mutex;
+        std::mutex xid_mutex;
         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_state &get_lock_state(lock_protocol::lockid_t lid);
+        lock_state & get_lock_state(lock_protocol::lockid_t lid);
     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);
         void releaser();
         rlock_protocol::status revoke_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
         rlock_protocol::status retry_handler(int &, lock_protocol::lockid_t, lock_protocol::xid_t);
@@ -69,7 +68,9 @@ class lock_client {
 
 #endif // C++
 
+#ifdef __cplusplus
 extern "C" {
+#endif
 
 struct _t4_lock_client;
 typedef struct _t4_lock_client t4_lock_client;
@@ -90,8 +91,9 @@ t4_lock_client *t4_lock_client_new(const char *dst);
 void t4_lock_client_delete(t4_lock_client *);
 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);
 
+#ifdef __cplusplus
 }
+#endif
 
 #endif