client_server.h

Go to the documentation of this file.

#ifndef FPMAS_CLIENT_SERVER_API_H
#define FPMAS_CLIENT_SERVER_API_H
 
#include "enums.h"
#include "fpmas/api/graph/distributed_edge.h"
 
namespace fpmas { namespace synchro { namespace hard { namespace api {
    struct MutexRequest {
        static const int LOCAL;
        DistributedId id;
        int source;
        MutexRequestType type;
 
        MutexRequest(DistributedId id, int source, MutexRequestType type)
            : id(id), source(source), type(type) {}
 
        bool operator==(const MutexRequest& other) const {
            return
                (this->type == other.type) &&
                (this->id == other.id) &&
                (this->source == other.source);
        }
    };
 
    template<typename T>
        class MutexClient {
            public:
                virtual T read(DistributedId id, int location) = 0;
 
                virtual void releaseRead(DistributedId id, int location) = 0;
 
                virtual T acquire(DistributedId id, int location) = 0;
 
                virtual void releaseAcquire(DistributedId id, const T& updated_data, int location) = 0;
 
                virtual void lock(DistributedId id, int location) = 0;
 
                virtual void unlock(DistributedId id, int location) = 0;
 
                virtual void lockShared(DistributedId id, int location) = 0;
 
                virtual void unlockShared(DistributedId id, int location) = 0;
 
                virtual ~MutexClient() {}
        };
 
    class Server {
        public:
            virtual void setEpoch(Epoch epoch) = 0;
            virtual Epoch getEpoch() const = 0;
 
            virtual void handleIncomingRequests() = 0;
 
            virtual ~Server() {}
    };
 
    template<typename T> class HardSyncMutex;
 
    template<typename T>
        class MutexServer : public Server {
            friend HardSyncMutex<T>;
            protected:
            void lock(HardSyncMutex<T>* mutex) {mutex->_lock();}
            void lockShared(HardSyncMutex<T>* mutex) {mutex->_lockShared();}
            void unlock(HardSyncMutex<T>* mutex) {mutex->_unlock();}
            void unlockShared(HardSyncMutex<T>* mutex) {mutex->_unlockShared();}
            public:
            virtual void manage(DistributedId id, HardSyncMutex<T>* mutex) = 0;
            virtual void remove(DistributedId id) = 0;
 
            virtual void wait(const MutexRequest& request) = 0;
 
            virtual void notify(DistributedId id) = 0;
 
 
            virtual ~MutexServer() {}
        };
 
    template<typename T>
        class LinkClient {
            public:
                virtual void link(const fpmas::api::graph::DistributedEdge<T>* edge) = 0;
 
                virtual void unlink(const fpmas::api::graph::DistributedEdge<T>* edge) = 0;
 
                virtual void removeNode(const fpmas::api::graph::DistributedNode<T>* node) = 0;
 
                virtual ~LinkClient() {};
        };
 
    class LinkServer : public Server {
        public:
            virtual void lockUnlink(DistributedId edge_id) = 0;
 
            virtual bool isLockedUnlink(DistributedId edge_id) = 0;
 
            virtual void unlockUnlink(DistributedId edge_id) = 0;
 
            virtual void lockRemoveNode(DistributedId node_id) = 0;
            virtual bool isLockedRemoveNode(DistributedId node_id) = 0;
            virtual void unlockRemoveNode(DistributedId node_id) = 0;
    };
 
    class TerminationAlgorithm {
        public:
            virtual void terminate(Server& server) = 0;
 
            virtual ~TerminationAlgorithm() {};
    };
}}}}
#endif