// lock client interface.
#ifndef lock_client_h
-
#define lock_client_h
#ifdef __cplusplus
-#include <string>
+#include "types.h"
#include "lock_protocol.h"
-#include "rpc/rpc.h"
-#include "lang/verify.h"
#include "rpc/fifo.h"
#include "rsm_client.h"
+#include "maybe.h"
class lock_release_user {
public:
virtual ~lock_release_user() {}
};
-using std::string;
-using std::thread;
-using std::list;
-using std::map;
-
-typedef string callback;
-
class lock_state {
public:
- lock_state();
enum {
none = 0,
retrying,
locked,
acquiring,
releasing
- } state;
+ } state = none;
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;
- void wait();
+ void wait(lock & mutex_lock);
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:
- 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;
- 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() {}
+ static in_port_t last_port;
+ 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);
#endif // C++
+#ifdef __cplusplus
extern "C" {
+#endif
struct _t4_lock_client;
typedef struct _t4_lock_client t4_lock_client;
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