Mutex.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_MUTEX_HPP_
#define INCLUDE_DISTORTOS_MUTEX_HPP_

#include "distortos/internal/synchronization/MutexControlBlock.hpp"

namespace distortos
{

class Mutex : private internal::MutexControlBlock
{
public:

    using Protocol = MutexProtocol;

    using RecursiveLocksCount = MutexControlBlock::RecursiveLocksCount;

    using Type = MutexType;

    constexpr static RecursiveLocksCount getMaxRecursiveLocks()
    {
        return std::numeric_limits<RecursiveLocksCount>::max();
    }

    constexpr explicit Mutex(const Type type = Type::normal, const Protocol protocol = Protocol::none,
            const uint8_t priorityCeiling = {}) :
                    MutexControlBlock{type, protocol, priorityCeiling}
    {

    }

    constexpr explicit Mutex(const Protocol protocol, const uint8_t priorityCeiling = {}) :
            Mutex{Type::normal, protocol, priorityCeiling}
    {

    }

    ~Mutex() = default;

    int lock();

    int tryLock();

    int tryLockFor(TickClock::duration duration);

    template<typename Rep, typename Period>
    int tryLockFor(const std::chrono::duration<Rep, Period> duration)
    {
        return tryLockFor(std::chrono::duration_cast<TickClock::duration>(duration));
    }

    int tryLockUntil(TickClock::time_point timePoint);

    template<typename Duration>
    int tryLockUntil(const std::chrono::time_point<TickClock, Duration> timePoint)
    {
        return tryLockUntil(std::chrono::time_point_cast<TickClock::duration>(timePoint));
    }

    bool try_lock()
    {
        return tryLock() == 0;
    }

    template<typename Rep, typename Period>
    bool try_lock_for(const std::chrono::duration<Rep, Period> duration)
    {
        return tryLockFor(duration) == 0;
    }

    template<typename Duration>
    bool try_lock_until(const std::chrono::time_point<TickClock, Duration> timePoint)
    {
        return tryLockUntil(timePoint) == 0;
    }

    int unlock();

    Mutex(const Mutex&) = delete;
    Mutex(Mutex&&) = default;
    const Mutex& operator=(const Mutex&) = delete;
    Mutex& operator=(Mutex&&) = delete;

private:

    int tryLockInternal();
};

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_MUTEX_HPP_