Semaphore.hpp

Go to the documentation of this file.

#ifndef INCLUDE_DISTORTOS_SEMAPHORE_HPP_
#define INCLUDE_DISTORTOS_SEMAPHORE_HPP_

#include "distortos/internal/scheduler/ThreadList.hpp"

#include "distortos/TickClock.hpp"

namespace distortos
{

class Semaphore
{
public:

    using Value = unsigned int;

    constexpr explicit Semaphore(const Value value, const Value maxValue = std::numeric_limits<Value>::max()) :
            blockedList_{},
            value_{value < maxValue ? value : maxValue},
            maxValue_{maxValue}
    {

    }

    ~Semaphore() = default;

    Value getMaxValue() const
    {
        return maxValue_;
    }

    Value getValue() const
    {
        return value_;
    }

    int post();

    int tryWait();

    int tryWaitFor(TickClock::duration duration);

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

    int tryWaitUntil(TickClock::time_point timePoint);

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

    int wait();

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

private:

    int tryWaitInternal();

    internal::ThreadList blockedList_;

    Value value_;

    Value maxValue_;
};

}   // namespace distortos

#endif  // INCLUDE_DISTORTOS_SEMAPHORE_HPP_