zpp::unique_lock< T_Mutex > Class Template Reference

zpp::unique_lock using zpp::mutex as a lock. More...

#include <unique_lock.hpp>

Public Types
using	native_pointer = T_Mutex::native_pointer
using	native_const_pointer = T_Mutex::native_const_pointer

Public Member Functions
	unique_lock () noexcept=default
	Try locking the mutex without waiting. More...
	unique_lock (T_Mutex &lock) noexcept
	Try locking the mutex without waiting. More...
	unique_lock (unique_lock &&src) noexcept
	Try locking the mutex without waiting. More...
unique_lock &	operator= (unique_lock &&src) noexcept
	Try locking the mutex without waiting. More...
	~unique_lock () noexcept
	Try locking the mutex without waiting. More...
auto	lock () noexcept
	Lock the mutex. Wait for ever until it is locked. More...
auto	try_lock () noexcept
	Try locking the mutex without waiting. More...
template<class T_Rep , class T_Period >
auto	try_lock_for (const std::chrono::duration< T_Rep, T_Period > &timeout) noexcept
	Try locking the mutex with a timeout. More...
auto	unlock () noexcept
	Unlock the mutex. More...
constexpr T_Mutex *	release () noexcept
	Try locking the mutex without waiting. More...
constexpr bool	owns_lock () const noexcept
	Try locking the mutex without waiting. More...
constexpr	operator bool () const noexcept
	Try locking the mutex without waiting. More...
constexpr T_Mutex *	mutex () const noexcept
	Try locking the mutex without waiting. More...
constexpr auto	native_handle () noexcept -> native_pointer
	get the native zephyr mutex handle. More...
constexpr auto	native_handle () const noexcept -> native_const_pointer
	get the native zephyr mutex handle. More...
	unique_lock (const unique_lock &)=delete
unique_lock &	operator= (const unique_lock &)=delete

Detailed Description

template<typename T_Mutex>
class zpp::unique_lock< T_Mutex >

zpp::unique_lock using zpp::mutex as a lock.

Definition at line 24 of file unique_lock.hpp.

Member Typedef Documentation

native_const_pointer

template<typename T_Mutex >

using zpp::unique_lock< T_Mutex >::native_const_pointer = T_Mutex::native_const_pointer

Definition at line 27 of file unique_lock.hpp.

native_pointer

template<typename T_Mutex >

using zpp::unique_lock< T_Mutex >::native_pointer = T_Mutex::native_pointer

Definition at line 26 of file unique_lock.hpp.

Constructor & Destructor Documentation

unique_lock() [1/4]

template<typename T_Mutex >

zpp::unique_lock< T_Mutex >::unique_lock ( )

defaultnoexcept

Try locking the mutex without waiting.

unique_lock() [2/4]

template<typename T_Mutex >

zpp::unique_lock< T_Mutex >::unique_lock ( T_Mutex &  lock )

inlineexplicitnoexcept

Try locking the mutex without waiting.

Definition at line 37 of file unique_lock.hpp.

    : m_lock(&lock)
  {
    __ASSERT_NO_MSG(m_lock != nullptr);
    auto res = m_lock->lock();
    __ASSERT_NO_MSG(res != false);
    m_is_owner = true;
  }

unique_lock() [3/4]

template<typename T_Mutex >

zpp::unique_lock< T_Mutex >::unique_lock ( unique_lock< T_Mutex > &&  src )

inlinenoexcept

Try locking the mutex without waiting.

Definition at line 49 of file unique_lock.hpp.

    : m_lock(src.m_lock)
    , m_is_owner(src.m_is_owner)
  {
    src.m_lock = nullptr;
    src.m_is_owner = false;
  }

~unique_lock()

template<typename T_Mutex >

zpp::unique_lock< T_Mutex >::~unique_lock ( )

inlinenoexcept

Try locking the mutex without waiting.

Definition at line 79 of file unique_lock.hpp.

  {
    if (m_lock != nullptr && m_is_owner) {
      auto res = m_lock->unlock();
      __ASSERT_NO_MSG(res != false);
    }
  }

unique_lock() [4/4]

template<typename T_Mutex >

zpp::unique_lock< T_Mutex >::unique_lock ( const unique_lock< T_Mutex > &  )

delete

Member Function Documentation

lock()

template<typename T_Mutex >

auto zpp::unique_lock< T_Mutex >::lock ( )

inlinenoexcept

Lock the mutex. Wait for ever until it is locked.

Returns

true if successfully locked.

Definition at line 92 of file unique_lock.hpp.

  {
    result<void, error_code> res;
 
    if (m_lock == nullptr) {
      res.assign_error(error_code::k_inval);
    } else if (m_is_owner == true) {
      res.assign_error(error_code::k_deadlk);
    } else {
      res = m_lock->lock();
      m_is_owner = (bool)res;
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::k_deadlk, and zpp::k_inval.

mutex()

template<typename T_Mutex >

constexpr T_Mutex* zpp::unique_lock< T_Mutex >::mutex ( ) const

inlineconstexprnoexcept

Try locking the mutex without waiting.

Definition at line 203 of file unique_lock.hpp.

  {
    return m_lock;
  }

native_handle() [1/2]

template<typename T_Mutex >

constexpr auto zpp::unique_lock< T_Mutex >::native_handle ( ) const -> native_const_pointer

inlineconstexprnoexcept

get the native zephyr mutex handle.

Returns

A pointer to the zephyr k_mutex.

Definition at line 226 of file unique_lock.hpp.

  {
    if (m_lock != nullptr)
      return m_lock->native_handle();
    else
      return nullptr;
  }

native_handle() [2/2]

template<typename T_Mutex >

constexpr auto zpp::unique_lock< T_Mutex >::native_handle ( ) -> native_pointer

inlineconstexprnoexcept

get the native zephyr mutex handle.

Returns

A pointer to the zephyr k_mutex.

Definition at line 213 of file unique_lock.hpp.

  {
    if (m_lock != nullptr)
      return m_lock->native_handle();
    else
      return nullptr;
  }

operator bool()

template<typename T_Mutex >

constexpr zpp::unique_lock< T_Mutex >::operator bool ( ) const

inlineexplicitconstexprnoexcept

Try locking the mutex without waiting.

Definition at line 195 of file unique_lock.hpp.

  {
    return owns_lock();
  }

References zpp::unique_lock< T_Mutex >::owns_lock().

operator=() [1/2]

template<typename T_Mutex >

unique_lock& zpp::unique_lock< T_Mutex >::operator= ( const unique_lock< T_Mutex > &  )

delete

operator=() [2/2]

template<typename T_Mutex >

unique_lock& zpp::unique_lock< T_Mutex >::operator= ( unique_lock< T_Mutex > &&  src )

inlinenoexcept

Try locking the mutex without waiting.

Definition at line 60 of file unique_lock.hpp.

  {
    if (m_lock != nullptr && m_is_owner) {
      auto res = m_lock->unlock();
      __ASSERT_NO_MSG(res != false);
    }
 
    m_lock = src.m_lock;
    m_is_owner = src.m_is_owner;
 
    src.m_lock = nullptr;
    src.m_is_owner = false;
 
    return *this;
  }

owns_lock()

template<typename T_Mutex >

constexpr bool zpp::unique_lock< T_Mutex >::owns_lock ( ) const

inlineconstexprnoexcept

Try locking the mutex without waiting.

Definition at line 187 of file unique_lock.hpp.

  {
    return m_is_owner;
  }

Referenced by zpp::unique_lock< T_Mutex >::operator bool().

release()

template<typename T_Mutex >

constexpr T_Mutex* zpp::unique_lock< T_Mutex >::release ( )

inlineconstexprnoexcept

Try locking the mutex without waiting.

Definition at line 176 of file unique_lock.hpp.

  {
    auto ret = m_lock;
    m_lock = nullptr;
    m_is_owner = false;
    return ret;
  }

try_lock()

template<typename T_Mutex >

auto zpp::unique_lock< T_Mutex >::try_lock ( )

inlinenoexcept

Try locking the mutex without waiting.

Returns

true if successfully locked.

Definition at line 113 of file unique_lock.hpp.

  {
    result<void, error_code> res;
 
    if (m_lock == nullptr) {
      res.assign_error(error_code::k_inval);
    } else if (m_is_owner == true) {
      res.assign_error(error_code::k_deadlk);
    } else {
      res = m_lock->try_lock();
      m_is_owner = (bool)res;
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::k_deadlk, and zpp::k_inval.

try_lock_for()

template<typename T_Mutex >

template<class T_Rep , class T_Period >

auto zpp::unique_lock< T_Mutex >::try_lock_for ( const std::chrono::duration< T_Rep, T_Period > &  timeout )

inlinenoexcept

Try locking the mutex with a timeout.

Parameters

timeout

The time to wait before returning

Returns

true if successfully locked.

Definition at line 138 of file unique_lock.hpp.

  {
    result<void, error_code> res;
 
    if (m_lock == nullptr) {
      res.assign_error(error_code::k_inval);
    } else if (m_is_owner == true) {
      res.assign_error(error_code::k_deadlk);
    } else {
      res = m_lock->try_lock_for(timeout);
      m_is_owner = (bool)res;
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::k_deadlk, and zpp::k_inval.

unlock()

template<typename T_Mutex >

auto zpp::unique_lock< T_Mutex >::unlock ( )

inlinenoexcept

Unlock the mutex.

Definition at line 157 of file unique_lock.hpp.

  {
    result<void, error_code> res;
 
    if (m_is_owner == false) {
      res.assign_error(error_code::k_perm);
    } else if (m_lock == nullptr) {
      res.assign_error(error_code::k_inval);
    } else {
      res = m_lock->unlock();
      m_is_owner = false;
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::k_inval, and zpp::k_perm.

---

The documentation for this class was generated from the following file:

• include/zpp/unique_lock.hpp