mn_basic_semaphore.hpp

Go to the documentation of this file.

 
#ifndef MINLIB_ESP32_BASE_SEMAPHORE_
#define MINLIB_ESP32_BASE_SEMAPHORE_
 
#include "mn_config.hpp"
 
#include <time.h>
 
#include "mn_error.hpp"
#include "mn_lock.hpp"
#include "excp/mn_lock_exptions.hpp"
 
 
 
namespace mn {
 
  class basic_semaphore : public ILockObject {
  public:
    basic_semaphore();
 
#if( configSUPPORT_STATIC_ALLOCATION == 0 )
    basic_semaphore(const basic_semaphore& other);
    basic_semaphore(basic_semaphore&& other);
#endif
    virtual int lock(unsigned int timeout = MN_THREAD_CONFIG_TIMEOUT_SEMAPHORE_DEFAULT);
 
    virtual int time_lock(const struct timespec *timeout);
 
    virtual int unlock();
 
    void* get_handle()                      { return m_pSpinlock; }
 
    int   get_error()                       { return m_iCreateErrorCode; }
 
    virtual bool is_initialized() const     { return m_pSpinlock != NULL; }
 
    #if configQUEUE_REGISTRY_SIZE > 0
      void set_name(const char* name)       { vQueueAddToRegistry(m_pSpinlock, name); }
    #endif // configQUEUE_REGISTRY_SIZE
 
 
    virtual bool is_locked() const { return m_isLocked; }
  public:
 
    bool operator == (const basic_semaphore &r) const {
      return m_pSpinlock == r.m_pSpinlock;
    }
 
    bool operator != (const basic_semaphore &r) const {
      return !operator==(r);
    }
 
    bool operator < (const basic_semaphore &r) const {
      return m_pSpinlock < r.m_pSpinlock;
    }
 
    bool operator > (const basic_semaphore &r) const {
      return m_pSpinlock > r.m_pSpinlock;
    }
  protected:
    void  set_error(int error)              { m_iCreateErrorCode = error; }
  protected:
    void* m_pSpinlock;
 
    #if( configSUPPORT_STATIC_ALLOCATION == 1 )
      StaticSemaphore_t m_SemaphoreBasicBuffer;
    #endif
 
    int m_iCreateErrorCode;
    bool m_isLocked;
  };
}
 
#endif // MINLIB_ESP32_BASE_SEMAPHORE_