HLT::LoopThread Class Reference

Helper class to manage a long-running thread (duration of event loop) More...

#include <EventLoopUtils.h>

Collaboration diagram for HLT::LoopThread:

Public Member Functions
	LoopThread (std::function< void()> &&callback, int callbackInterval=-1)
	~LoopThread ()
	LoopThread (const LoopThread &)=delete
	LoopThread (LoopThread &&)=delete
LoopThread &	operator= (const LoopThread &)=delete
LoopThread &	operator= (LoopThread &&)=delete
void	start ()
	Keep notifying the thread until the callback is called for the first time (returns just before calling the callback)
void	stop ()
	Flag the main loop to finish.
void	wait ()
	Wait until main loop finishes.
std::condition_variable &	cond ()
std::mutex &	mutex ()

Private Member Functions
void	waitForCond (std::unique_lock< std::mutex > &lock)
	Helper to wait for the condition.
void	run ()
	Main function executed by the thread.

Private Attributes
std::condition_variable	m_cond
	Condition for which the thread waits most of its lifetime.
std::mutex	m_mutex
	Mutex used to notify the condition.
std::atomic< bool >	m_keepRunning {true}
	The thread's inner while-loop condition variable.
std::atomic< bool >	m_started {false}
	Flag whether the main loop of the thread has started and will listen to further notifications.
std::atomic< bool >	m_finished {false}
	Flag whether the main loop of the thread has finished.
std::function< void()>	m_callback
	The callback executed in each step of the thread's inner while-loop.
int	m_callbackIntervalMilliseconds {-1}
	If positive, call the callback periodically with this interval regardless of the m_cond.
std::unique_ptr< std::thread >	m_thread
	The thread object.

Detailed Description

Helper class to manage a long-running thread (duration of event loop)

Definition at line 16 of file EventLoopUtils.h.

Constructor & Destructor Documentation

LoopThread() [1/3]

HLT::LoopThread::LoopThread ( std::function< void()> && callback, int callbackInterval = -1 )

inlineexplicit

Definition at line 63 of file EventLoopUtils.h.

    : m_callback(std::move(callback)),
      m_callbackIntervalMilliseconds(callbackInterval),
      m_thread(std::make_unique<std::thread>([this]{run();})) {}

~LoopThread()

HLT::LoopThread::~LoopThread ( )

inline

Definition at line 68 of file EventLoopUtils.h.

                  {
      wait();
    }

LoopThread() [2/3]

HLT::LoopThread::LoopThread ( const LoopThread & )

delete

LoopThread() [3/3]

HLT::LoopThread::LoopThread ( LoopThread && )

delete

Member Function Documentation

cond()

std::condition_variable & HLT::LoopThread::cond ( )

inline

Definition at line 106 of file EventLoopUtils.h.

{return m_cond;}

mutex()

std::mutex & HLT::LoopThread::mutex ( )

inline

Definition at line 107 of file EventLoopUtils.h.

{return m_mutex;}

operator=() [1/2]

LoopThread & HLT::LoopThread::operator= ( const LoopThread & )

delete

operator=() [2/2]

LoopThread & HLT::LoopThread::operator= ( LoopThread && )

delete

run()

void HLT::LoopThread::run ( )

inlineprivate

Main function executed by the thread.

Definition at line 45 of file EventLoopUtils.h.

               {
      if (!m_keepRunning) {return;}
      std::unique_lock<std::mutex> lock{m_mutex};
 
      // first call outside the loop to set the m_started flag
      waitForCond(lock);
      m_started = true;
      m_callback();
 
      // subsequent calls in a loop
      while(m_keepRunning) {
        waitForCond(lock);
        m_callback();
      }
      m_finished = true;
    }

start()

void HLT::LoopThread::start ( )

inline

Keep notifying the thread until the callback is called for the first time (returns just before calling the callback)

Definition at line 80 of file EventLoopUtils.h.

                 {
      while (!m_started) {
        std::this_thread::sleep_for(std::chrono::milliseconds(3));
        m_cond.notify_one();
      }
    }

stop()

void HLT::LoopThread::stop ( )

inline

Flag the main loop to finish.

Definition at line 88 of file EventLoopUtils.h.

                {
      m_keepRunning=false;
      m_cond.notify_all();
    }

wait()

void HLT::LoopThread::wait ( )

inline

Wait until main loop finishes.

Definition at line 94 of file EventLoopUtils.h.

                {
      // Nothing to do if thread already finished
      if (m_thread==nullptr || !m_thread->joinable()) {return;}
      // Keep notifying the condition until the loop finishes
      while (!m_finished) {
        std::this_thread::sleep_for(std::chrono::milliseconds(3));
        m_cond.notify_all();
      }
      // Wait for the thread to return
      m_thread->join();
    }

waitForCond()

void HLT::LoopThread::waitForCond ( std::unique_lock< std::mutex > & lock )

inlineprivate

Helper to wait for the condition.

Definition at line 36 of file EventLoopUtils.h.

                                                            {
      if (m_callbackIntervalMilliseconds < 0) {
        m_cond.wait(lock);
      } else {
        m_cond.wait_for(lock, std::chrono::milliseconds(m_callbackIntervalMilliseconds));
      }
    }

Member Data Documentation

m_callback

std::function<void()> HLT::LoopThread::m_callback

private

The callback executed in each step of the thread's inner while-loop.

Definition at line 29 of file EventLoopUtils.h.

m_callbackIntervalMilliseconds

int HLT::LoopThread::m_callbackIntervalMilliseconds {-1}

private

If positive, call the callback periodically with this interval regardless of the m_cond.

Definition at line 31 of file EventLoopUtils.h.

{-1};

m_cond

std::condition_variable HLT::LoopThread::m_cond

private

Condition for which the thread waits most of its lifetime.

Definition at line 19 of file EventLoopUtils.h.

m_finished

std::atomic<bool> HLT::LoopThread::m_finished {false}

private

Flag whether the main loop of the thread has finished.

Definition at line 27 of file EventLoopUtils.h.

{false};

m_keepRunning

std::atomic<bool> HLT::LoopThread::m_keepRunning {true}

private

The thread's inner while-loop condition variable.

Definition at line 23 of file EventLoopUtils.h.

{true};

m_mutex

std::mutex HLT::LoopThread::m_mutex

private

Mutex used to notify the condition.

Definition at line 21 of file EventLoopUtils.h.

m_started

std::atomic<bool> HLT::LoopThread::m_started {false}

private

Flag whether the main loop of the thread has started and will listen to further notifications.

Definition at line 25 of file EventLoopUtils.h.

{false};

m_thread

std::unique_ptr<std::thread> HLT::LoopThread::m_thread

private

The thread object.

Definition at line 33 of file EventLoopUtils.h.

---

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

• EventLoopUtils.h