lock_client_cache.h

// lock client interface.

#ifndef lock_client_cache_h

#define lock_client_cache_h

#include <string>
#include "lock_protocol.h"
#include "rpc.h"
#include "lock_client.h"
#include "lang/verify.h"

// Classes that inherit lock_release_user can override dorelease so that 
// that they will be called when lock_client releases a lock.
// You will not need to do anything with this class until Lab 5.
class lock_release_user {
    public:
        virtual void dorelease(lock_protocol::lockid_t) = 0;
        virtual ~lock_release_user() {};
};



class lock_client_cache : public lock_client {
    private:
        class lock_release_user *lu;
        int rlock_port;
        std::string hostname;
        std::string id;
        struct client_lock {
            enum lockstatus {
                NONE,
                FREE,
                LOCKED,
                ACQUIRING,
                RELEASING,
            };
            lock_protocol::lockid_t lock_id;
            int status = NONE;
            std::mutex mtx;
            std::condition_variable available_cv;
            std::condition_variable release_cv;
            std::condition_variable retry_cv;
            int num_revoke = 0; 
            int num_retry = 0;  

            client_lock(lock_protocol::lockid_t lid) : lock_id(lid) {}
        };
        std::unordered_map<lock_protocol::lockid_t, std::shared_ptr<client_lock>> lock_cache;
        std::mutex mtx_map;
    public:
        lock_client_cache(std::string xdst, class lock_release_user *l = 0);
        virtual ~lock_client_cache() {};
        lock_protocol::status acquire(lock_protocol::lockid_t);
        lock_protocol::status release(lock_protocol::lockid_t);
        rlock_protocol::status revoke_handler(lock_protocol::lockid_t, 
                int &);
        rlock_protocol::status retry_handler(lock_protocol::lockid_t, 
                int &);
};


#endif