llfio_v2_xxx::unique_file_lock Class Reference

RAII locker matching std::unique_lock for lockable_byte_io_handle, but untemplated. More...

#include "lockable_byte_io_handle.hpp"

Public Member Functions
	unique_file_lock (lockable_byte_io_handle &h, lock_kind kind)
	unique_file_lock (unique_file_lock &&o) noexcept
	unique_file_lock (const unique_file_lock &)=delete
unique_file_lock &	operator= (unique_file_lock &&o) noexcept
unique_file_lock &	operator= (const unique_file_lock &)=delete
lockable_byte_io_handle *	mutex () const noexcept
	Returns the associated mutex.
bool	owns_lock () const noexcept
	True if the associated mutex is owned by this lock.
	operator bool () const noexcept
	True if the associated mutex is owned by this lock.
lockable_byte_io_handle *	release () noexcept
	Releases the mutex from management.
result< void >	lock () noexcept
	Lock the mutex for exclusive access.
bool	try_lock () noexcept
	Try to lock the mutex for exclusive access.
void	unlock () noexcept
	Unlock the mutex from exclusive access.
result< void >	lock_shared () noexcept
	Lock the mutex for shared access.
bool	try_lock_shared () noexcept
	Try to lock the mutex for shared access.
void	unlock_shared () noexcept
	Unlock the mutex from shared access.

Detailed Description

RAII locker matching std::unique_lock for lockable_byte_io_handle, but untemplated.

Constructor & Destructor Documentation

unique_file_lock() [1/2]

llfio_v2_xxx::unique_file_lock::unique_file_lock ( lockable_byte_io_handle &  h, lock_kind  kind  )

inlineexplicit

      : _h(&h)
  {
    if(kind == lock_kind::exclusive)
    {
      lock().value();
    }
    else if(kind == lock_kind::shared)
    {
      lock_shared().value();
    }
  }

unique_file_lock() [2/2]

llfio_v2_xxx::unique_file_lock::unique_file_lock ( unique_file_lock &&  o )

inlinenoexcept

      : _h(o._h)
      , _lock_state(o._lock_state)
  {
    o._h = nullptr;
    o._lock_state = lock_kind::unlocked;
  }

~unique_file_lock()

llfio_v2_xxx::unique_file_lock::~unique_file_lock ( )

inline

  {
    if(_h != nullptr)
    {
      if(_lock_state == lock_kind::exclusive)
      {
        _h->unlock_file();
      }
      else if(_lock_state == lock_kind::shared)
      {
        _h->unlock_file_shared();
      }
      _h = nullptr;
    }
  }

Member Function Documentation

lock()

result< void > llfio_v2_xxx::unique_file_lock::lock ( )

inlinenoexcept

Lock the mutex for exclusive access.

  {
    if(_h == nullptr)
    {
      return errc::operation_not_permitted;
    }
    if(_lock_state != lock_kind::unlocked)
    {
      return errc::resource_deadlock_would_occur;
    }
    OUTCOME_TRY(_h->lock_file());
    _lock_state = lock_kind::exclusive;
    return success();
  }

lock_shared()

result< void > llfio_v2_xxx::unique_file_lock::lock_shared ( )

inlinenoexcept

Lock the mutex for shared access.

  {
    if(_h == nullptr)
    {
      return errc::operation_not_permitted;
    }
    if(_lock_state != lock_kind::unlocked)
    {
      return errc::resource_deadlock_would_occur;
    }
    OUTCOME_TRY(_h->lock_file_shared());
    _lock_state = lock_kind::shared;
    return success();
  }

mutex()

lockable_byte_io_handle * llfio_v2_xxx::unique_file_lock::mutex ( ) const

inlinenoexcept

Returns the associated mutex.

{ return _h; }

operator bool()

llfio_v2_xxx::unique_file_lock::operator bool ( ) const

inlineexplicitnoexcept

True if the associated mutex is owned by this lock.

{ return owns_lock(); }

operator=()

unique_file_lock & llfio_v2_xxx::unique_file_lock::operator= ( unique_file_lock &&  o )

inlinenoexcept

  {
    if(this == &o)
    {
      return *this;
    }
    this->~unique_file_lock();
    new(this) unique_file_lock(std::move(o));
    return *this;
  }

owns_lock()

bool llfio_v2_xxx::unique_file_lock::owns_lock ( ) const

inlinenoexcept

True if the associated mutex is owned by this lock.

{ return (_h != nullptr) && _lock_state != lock_kind::unlocked; }

release()

lockable_byte_io_handle * llfio_v2_xxx::unique_file_lock::release ( )

inlinenoexcept

Releases the mutex from management.

  {
    lockable_byte_io_handle *ret = _h;
    _h = nullptr;
    return ret;
  }

try_lock()

bool llfio_v2_xxx::unique_file_lock::try_lock ( )

inlinenoexcept

Try to lock the mutex for exclusive access.

  {
    if(_h == nullptr)
    {
      return false;
    }
    if(_lock_state != lock_kind::unlocked)
    {
      return false;
    }
    if(_h->try_lock_file())
    {
      _lock_state = lock_kind::exclusive;
      return true;
    }
    return false;
  }

try_lock_shared()

bool llfio_v2_xxx::unique_file_lock::try_lock_shared ( )

inlinenoexcept

Try to lock the mutex for shared access.

  {
    if(_h == nullptr)
    {
      return false;
    }
    if(_lock_state != lock_kind::unlocked)
    {
      return false;
    }
    if(_h->try_lock_file_shared())
    {
      _lock_state = lock_kind::shared;
      return true;
    }
    return false;
  }

unlock()

void llfio_v2_xxx::unique_file_lock::unlock ( )

inlinenoexcept

Unlock the mutex from exclusive access.

  {
    assert(_h != nullptr);
    assert(_lock_state == lock_kind::exclusive);
    if(_h == nullptr || _lock_state != lock_kind::exclusive)
    {
      return;
    }
    _h->unlock_file();
    _lock_state = lock_kind::unlocked;
  }

unlock_shared()

void llfio_v2_xxx::unique_file_lock::unlock_shared ( )

inlinenoexcept

Unlock the mutex from shared access.

  {
    assert(_h != nullptr);
    assert(_lock_state == lock_kind::shared);
    if(_h == nullptr || _lock_state != lock_kind::shared)
    {
      return;
    }
    _h->unlock_file_shared();
    _lock_state = lock_kind::unlocked;
  }

---

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

• include/llfio/v2.0/lockable_byte_io_handle.hpp