mn_atomic_spinlock.hpp

Go to the documentation of this file.

 
#ifndef _MINLIB_d82b672b_8681_4cea_bb66_a4aa2d9927e2_H_
#define _MINLIB_d82b672b_8681_4cea_bb66_a4aa2d9927e2_H_
 
#include "mn_config.hpp"
 
#include "mn_atomic.hpp"
#include "mn_lock.hpp"
 
namespace mn {
 
    template<typename T>
    class atomic_spinlock : public ILockObject {
    public:
        using self_type = atomic_spinlock<T>;
        using value_type = T;
        using pointer = value_type*;
        using reference = value_type&;
        using lock_guard = basic_autolock<self_type> ;
 
        atomic_spinlock()
            : m_locked(false), m_value() { }
 
        explicit atomic_spinlock(const reference value)
            : m_locked(false), m_value(value) { }
 
        virtual int lock(unsigned int not_use = 0) {
            while(! m_locked.compare_exchange_t(false, true,
                atomic_bool::memory_order::Acquire) ) { }
            return 0;
        }
 
        virtual int time_lock(const struct timespec *timeout) {
            return lock();
        }
        virtual int unlock() {
            m_locked.store(false, basic_atomic_gcc_memory_order::Release);
            return 0;
        }
        virtual bool try_lock() {
            if( m_locked.compare_exchange_t(false, true, atomic_bool::memory_order::Acquire) )
                return false;
            else
                lock();
            return true;
        }
        virtual bool is_initialized() const {
            return true;
        }
 
        operator value_type() { return m_value; }
 
        self_type& operator = (const value_type& oValue) {
            lock_guard lock(*this);
            m_value = oValue;
            return *this;
        }
 
        bool operator == (const value_type& oValue) {
            lock_guard lock(*this);
            return m_value == oValue;
        }
        bool operator != (const value_type& oValue) {
            lock_guard lock(*this);
            return m_value != oValue;
        }
 
        atomic_spinlock(const self_type&) = delete;
        self_type& operator=(const self_type&) = delete;
    protected:
        atomic_bool m_locked;
        value_type m_value;
    };
}
 
#endif