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.
bool	m_keepRunning {true}
	The thread's inner while-loop condition variable.
bool	m_started {false}
	Flag whether the main loop of the thread has started and will listen to further notifications.
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 15 of file EventLoopUtils.h.

Constructor & Destructor Documentation

LoopThread() [1/3]

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

inlineexplicit

Definition at line 62 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 67 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 105 of file EventLoopUtils.h.

{return m_cond;}

mutex()

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

inline

Definition at line 106 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 44 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 79 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 87 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 93 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 35 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 28 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 30 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 18 of file EventLoopUtils.h.

m_finished

bool HLT::LoopThread::m_finished {false}

private

Flag whether the main loop of the thread has finished.

Definition at line 26 of file EventLoopUtils.h.

{false};

m_keepRunning

bool HLT::LoopThread::m_keepRunning {true}

private

The thread's inner while-loop condition variable.

Definition at line 22 of file EventLoopUtils.h.

{true};

m_mutex

std::mutex HLT::LoopThread::m_mutex

private

Mutex used to notify the condition.

Definition at line 20 of file EventLoopUtils.h.

m_started

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 24 of file EventLoopUtils.h.

{false};

m_thread

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

private

The thread object.

Definition at line 32 of file EventLoopUtils.h.

---

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

• EventLoopUtils.h