mn_autolock.hpp

Go to the documentation of this file.

 
#ifndef _MINLIB_AUTOLOCK_H_
#define _MINLIB_AUTOLOCK_H_
 
#include "mn_config.hpp"
#include "mn_lock.hpp"
 
#include "mn_mutex.hpp"
#include "mn_semaphore.hpp"
#include "mn_null_lock.hpp"
 
#if (MN_THREAD_CONFIG_RECURSIVE_MUTEX == MN_THREAD_CONFIG_YES)
  #include "mn_recursive_mutex.hpp"
#endif
 
#ifndef portMAX_DELAY
#define portMAX_DELAY 0xffffffffUL
#endif
 
namespace mn {
  using autocsemp_t = basic_autolock<counting_semaphore_t>;
 
  using autobinsemp_t = basic_autolock<binary_semaphore_t>;
 
  using automutx_t = basic_autolock<mutex_t>;
 
  #if (MN_THREAD_CONFIG_RECURSIVE_MUTEX == MN_THREAD_CONFIG_YES)
  //using autoremutx_t = basic_autolock<remutex_t>;
  #endif
 
  #if MN_THREAD_CONFIG_LOCK_TYPE == MN_THREAD_CONFIG_MUTEX
    using LockType_t = mn::mutex_t;
  #elif MN_THREAD_CONFIG_LOCK_TYPE == MN_THREAD_CONFIG_BINARY_SEMAPHORE
    using LockType_t = mn::binary_semaphore_t;
  #elif MN_THREAD_CONFIG_LOCK_TYPE == MN_THREAD_CONFIG_COUNTING_SEMAPHORE
    using LockType_t = mn::counting_semaphore_t;
  //#elif MN_THREAD_CONFIG_LOCK_TYPE == MN_THREAD_CONFIG_RECURSIVE_MUTEX
  //  using LockType_t = remutex_t;
  #endif
 
  using autolock_t = basic_autolock<LockType_t>;
 
  template <class TLOCK = LockType_t>
  int lock(TLOCK& m1, unsigned int timeout) { return m1.lock(timeout); }
 
  template <class TLOCK = LockType_t>
  int unlock(TLOCK& m1) { return m1.unlock(); }
 
  template <class TLOCK = LockType_t>
  bool try_lock(TLOCK& m1) { return m1.try_lock(); }
}
 
#endif