mn_lock.hpp

Go to the documentation of this file.

 
#ifndef _MINLIB_ILOCK_INTERFACE_H_
#define _MINLIB_ILOCK_INTERFACE_H_
 
#include "mn_config.hpp"
 
#include <assert.h>
#include <freertos/FreeRTOS.h>
#include <time.h>
 
#include "mn_functional.hpp"
#include "mn_copyable.hpp"
#include "mn_error.hpp"
#include "mn_micros.hpp"
 
#define LOCKED_SECTION(LOCK, OBJECT) if( (mn::basic_autolock<LOCK> lock(OBJECT)) )
 
 
#define UNLOCKED_SECTION(LOCK, OBJECT) if( (mn::basic_autounlock<LOCK> lock(OBJECT)) )
namespace mn {
    class ILockObject  : MN_ONSIGLETN_CLASS {
    public:
        using this_type = ILockObject;
 
        ILockObject() { }
 
        virtual int lock(unsigned int timeout = 0) = 0;
 
        virtual int time_lock(const struct timespec *timeout) = 0;
        virtual int unlock() = 0;
 
        virtual bool try_lock() {
            return (lock(0) == 0);
        }
 
        virtual bool is_initialized() const = 0;
 
        virtual bool is_locked() const = 0;
    };
 
 
 
 
  template <class LOCK>
  class  basic_autolock  : MN_ONSIGLETN_CLASS  {
  public:
    basic_autolock(LOCK &m)
      : m_ref_lock(m) {
      assert( (m_ref_lock.lock(portMAX_DELAY) != NO_ERROR) );
    }
    basic_autolock(LOCK &m, unsigned long xTicksToWait)
      : m_ref_lock(m) {
      assert( (m_ref_lock.lock(xTicksToWait) != NO_ERROR) );
    }
    ~basic_autolock() {
        m_ref_lock.unlock();
    }
 
    operator bool () {
        return m_ref_lock.is_locked();
    }
  private:
    LOCK &m_ref_lock;
  };
 
 
  template <class LOCK>
  class  basic_autounlock  : MN_ONSIGLETN_CLASS  {
  public:
    basic_autounlock(LOCK &m)
      : m_ref_lock(m) {
        m_ref_lock.unlock();
        m_xTicksToWait = portMAX_DELAY;
    }
 
    basic_autounlock(LOCK &m, unsigned long xTicksToWait)
      : m_ref_lock(m) {
        m_ref_lock.unlock();
        m_xTicksToWait = xTicksToWait;
    }
    ~basic_autounlock() {
        assert( (m_ref_lock.lock(m_xTicksToWait) != NO_ERROR) );
    }
 
    void set_timeout(unsigned long xTicksToWait = portMAX_DELAY) {
        m_xTicksToWait = xTicksToWait;
    }
 
    operator bool () {
        return !(m_ref_lock.is_locked());
    }
  private:
    LOCK &m_ref_lock;
 
     unsigned long m_xTicksToWait;
  };
 
}
 
#endif