{

public:

using event_wait_t = enum class EEvent : std::uint8_t { timeout = 0, signaled };

using waiting_threads_t = std::vector<std::thread::id>;

/**

* C-tor

*

* @param autoReset In case that is set to true, will reset the event after being signaled

* at consumer point, so that it can wait - block on the same event on the next recall

*/

explicit Event(bool autoReset) noexcept;

~Event();

// Copy functions forbidden

Event(const Event&) = delete;

Event& operator=(const Event&) = delete;

// Move operations forbidden

Event(Event&&) = delete;

Event& operator=(Event&&) = delete;

/**

* Wait on the event being signaled, or timeout expired

*

* @param timeout Timeout in milliseconds to wait

* @return Indication of the operation outcome {@link Event#event_wait_t}

*/

event_wait_t wait_for(std::chrono::milliseconds timeout);

/**

* Wait infinitely on event being signaled

*/

void wait();

/**

* Notify - wake up the single thread

*/

void notify();

/**

* Notify - wake up the all waiting threads

*

* @note If the event is auto reset - this will notify only the first

* woken thread

*/

void broadcast();

/**

* Manually reset event - in case of the auto reset is false.

*/

[[maybe_unused]] void reset();

private:

using notify_f = void (std::condition_variable::*)(void);

void setEvent(notify_f notifier)

{

std::lock_guard lock{m_lock};

m_predicate = true;

// There is at least one consumer-thread - waiting on the event to be signaled

if (not m_waitingThreads.empty())

{

std::invoke(notifier, m_event);

}

}

private:

std::condition_variable m_event; // not copyable nor movable

std::mutex m_lock; // not copyable nor movable

const bool m_autoReset;

bool m_predicate = false;

waiting_threads_t m_waitingThreads;