guards.h

Go to the documentation of this file.

#ifndef FPMAS_SYNCHRO_GUARDS_H
#define FPMAS_SYNCHRO_GUARDS_H
 
#include "fpmas/api/graph/distributed_node.h"
 
namespace fpmas { namespace synchro {
    template<typename T>
        class Guard {
            protected:
                api::synchro::Mutex<T>& mutex;
 
                Guard(api::graph::DistributedNode<T>* node)
                    : mutex(*node->mutex()) {
                    }
 
            public:
                Guard(const Guard&) = delete;
                Guard(Guard&&) = delete;
                Guard& operator=(const Guard&) = delete;
                Guard& operator=(Guard&&) = delete;
 
                virtual ~Guard() {}
        };
 
    template<typename T>
        class ReadGuard : Guard<T> {
            public:
                ReadGuard(const api::graph::DistributedNode<T>* node)
                    : Guard<T>(const_cast<api::graph::DistributedNode<T>*>(node)) {
                        // updates node.data() according to the SyncMode
                        this->mutex.read();
                    }
 
                virtual ~ReadGuard() {
                    this->mutex.releaseRead();
                }
        };
 
    template<typename T>
        class AcquireGuard : Guard<T> {
            public:
                AcquireGuard(api::graph::DistributedNode<T>* node)
                    : Guard<T>(node) {
                        // updates node.data() according to the SyncMode
                        this->mutex.acquire();
                    }
                virtual ~AcquireGuard() {
                    this->mutex.releaseAcquire();
                }
        };
 
    template<typename T>
        class LockGuard : Guard<T> {
            public:
                LockGuard(api::graph::DistributedNode<T>* node)
                    : Guard<T>(node) {
                        this->mutex.lock();
                    }
                virtual ~LockGuard() {
                    this->mutex.unlock();
                }
        };
 
    template<typename T>
        class SharedLockGuard : Guard<T> {
            public:
                SharedLockGuard(const api::graph::DistributedNode<T>* node)
                    : Guard<T>(const_cast<api::graph::DistributedNode<T>*>(node)) {
                        this->mutex.lockShared();
                    }
                virtual ~SharedLockGuard() {
                    this->mutex.unlockShared();
                }
        };
 
 
}}
#endif