unique_lock.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
 
#ifndef TETL_MUTEX_UNIQUE_LOCK_HPP
#define TETL_MUTEX_UNIQUE_LOCK_HPP
 
#include <etl/_chrono/duration.hpp>
#include <etl/_chrono/time_point.hpp>
#include <etl/_mutex/tags.hpp>
#include <etl/_utility/exchange.hpp>
#include <etl/_utility/swap.hpp>
 
namespace etl {

template <typename Mutex>
struct unique_lock {
private:
    Mutex* _mutex{nullptr};
    bool _owns{false};
 
public:
    using mutex_type = Mutex;

    constexpr unique_lock() noexcept = default;

    explicit constexpr unique_lock(mutex_type& m)
        : _mutex{&m}
    {
        lock();
    }

    constexpr unique_lock(mutex_type& m, defer_lock_t /*tag*/) noexcept
        : _mutex{&m}
    {
    }

    constexpr unique_lock(mutex_type& m, try_to_lock_t /*tag*/) noexcept
        : _mutex{&m}
    {
        try_lock();
    }

    constexpr unique_lock(mutex_type& m, adopt_lock_t /*tag*/)
        : _mutex{&m}
        , _owns{true}
    {
    }

    template <typename Clock, typename Duration>
    constexpr unique_lock(mutex_type& m, chrono::time_point<Clock, Duration> const& absTime) noexcept
        : _mutex{&m}
    {
        try_lock_until(absTime);
    }

    template <typename Rep, typename Period>
    constexpr unique_lock(mutex_type& m, chrono::duration<Rep, Period> const& relTime) noexcept
        : _mutex{&m}
    {
        try_lock_for(relTime);
    }

    constexpr unique_lock(unique_lock const&) = delete;

    constexpr auto operator=(unique_lock const&) -> unique_lock& = delete;

    constexpr unique_lock(unique_lock&& u) noexcept
        : _mutex{exchange(u._mutex, nullptr)}
        , _owns{exchange(u._owns, false)}
    {
    }

    constexpr auto operator=(unique_lock&& u) noexcept -> unique_lock&
    {
        if (_mutex != nullptr && _owns) {
            unlock();
        }
        _mutex = exchange(u._mutex, nullptr);
        _owns  = exchange(u._owns, false);
        return *this;
    }
 
    constexpr ~unique_lock() noexcept { unlock(); }

    constexpr auto lock() noexcept(noexcept(_mutex->lock())) -> void
    {
        if ((_mutex != nullptr) and !_owns) {
            _mutex->lock();
            _owns = true;
        }
    }

    constexpr auto try_lock() noexcept(noexcept(_mutex->try_lock())) -> bool
    {
        if ((_mutex != nullptr) && !_owns) {
            if (auto success = _mutex->try_lock(); success) {
                _owns = true;
                return true;
            }
        }
 
        return false;
    }

    template <typename Rep, typename Period>
    constexpr auto try_lock_for(chrono::duration<Rep, Period> const& dur) noexcept(noexcept(_mutex->try_lock_for(dur)))
        -> bool
    {
        if ((_mutex != nullptr) && !_owns) {
            if (auto success = _mutex->try_lock_for(dur); success) {
                _owns = true;
                return true;
            }
        }
        return false;
    }

    template <typename Clock, typename Duration>
    constexpr auto try_lock_until(chrono::time_point<Clock, Duration> const& tp)
        noexcept(noexcept(_mutex->try_lock_until(tp))) -> bool
    {
        if ((_mutex != nullptr) && !_owns) {
            if (auto success = _mutex->try_lock_until(tp); success) {
                _owns = true;
                return true;
            }
        }
        return false;
    }

    constexpr auto unlock() -> void
    {
        if ((_mutex != nullptr) and _owns) {
            _mutex->unlock();
            _owns = false;
        }
    }

    constexpr auto swap(unique_lock& other) noexcept -> void
    {
        using etl::swap;
        swap(_mutex, other._mutex);
        swap(_owns, other._owns);
    }

    [[nodiscard]] constexpr auto release() noexcept -> mutex_type*
    {
        _owns = false;
        return _mutex;
    }

    [[nodiscard]] constexpr auto owns_lock() const noexcept -> bool { return _owns; }

    [[nodiscard]] explicit constexpr operator bool() const noexcept { return owns_lock(); }

    [[nodiscard]] constexpr auto mutex() const noexcept -> mutex_type* { return _mutex; }

    friend constexpr auto swap(unique_lock& lhs, unique_lock& rhs) noexcept(noexcept(lhs.swap(rhs))) -> void
    {
        lhs.swap(rhs);
    }
};
 
} // namespace etl
 
#endif // TETL_MUTEX_UNIQUE_LOCK_HPP