pars::ev::dispatcher Class Reference

#include <dispatcher.h>

Public Member Functions
	dispatcher (runner &r)

Running Jobs
void	run ()
void	stop_running ()
void	terminate_now ()
bool	terminating ()

Managing Queue
template<template< typename > typename kind_of, event_c event_t> requires kind_c<kind_of>
void	queue_back (kind_of< event_t > ke)
template<template< typename > typename kind_of, event_c event_t> requires kind_c<kind_of>
void	queue_front (kind_of< event_t > ke)

Detailed Description

Definition at line 46 of file dispatcher.h.

Constructor & Destructor Documentation

dispatcher()

pars::ev::dispatcher::dispatcher ( runner & r )

inline

Definition at line 49 of file dispatcher.h.

    : runner_m{r}
  {
  }

Member Function Documentation

queue_back()

template<template< typename > typename kind_of, event_c event_t>
requires kind_c<kind_of>

void pars::ev::dispatcher::queue_back ( kind_of< event_t > ke )

inline

Definition at line 117 of file dispatcher.h.

  {
    auto guard = std::lock_guard{mtx_m};
 
    queue(std::move(ke),
          std::bind(std::mem_fn<void(decltype(queue_m)::value_type&&)>(
                      &decltype(queue_m)::push_back),
                    &queue_m, std::placeholders::_1));
  }

Referenced by run().

Here is the caller graph for this function:

queue_front()

template<template< typename > typename kind_of, event_c event_t>
requires kind_c<kind_of>

void pars::ev::dispatcher::queue_front ( kind_of< event_t > ke )

inline

Definition at line 129 of file dispatcher.h.

  {
    auto guard = std::lock_guard{mtx_m};
 
    queue(std::move(ke),
          std::bind(std::mem_fn<void(decltype(queue_m)::value_type&&)>(
                      &decltype(queue_m)::push_front),
                    &queue_m, std::placeholders::_1));
  }

run()

void pars::ev::dispatcher::run ( )

inline

Definition at line 56 of file dispatcher.h.

  {
    running_m = true;
 
    queue_back(fired{init{}, {}});
 
    for (;;)
    {
      auto lock = std::unique_lock{mtx_m};
 
      cond_m.wait(lock, [&]() { return !queue_m.empty() || !running_m; });
 
      if (!running_m)
      {
        cond_m.wait(lock, [&]() { return terminate_m; });
 
        return;
      }
 
      // NOTE: exec is executed after mtx_m unlock
 
      runner_m.exec(next_job(lock));
    }
  }

References queue_back().

Here is the call graph for this function:

stop_running()

void pars::ev::dispatcher::stop_running ( )

inline

Definition at line 81 of file dispatcher.h.

  {
    auto guard = std::lock_guard{mtx_m};
 
    queue_m.clear();
 
    runner_m.stop_all_threads();
 
    running_m = false;
 
    cond_m.notify_one();
  }

terminate_now()

void pars::ev::dispatcher::terminate_now ( )

inline

Definition at line 94 of file dispatcher.h.

  {
    auto guard = std::lock_guard{mtx_m};
 
    if (running_m)
      throw std::runtime_error("Call stop_running first!");
 
    terminate_m = true;
 
    cond_m.notify_one();
  }

terminating()

bool pars::ev::dispatcher::terminating ( )

inline

Definition at line 106 of file dispatcher.h.

  {
    auto guard = std::lock_guard{mtx_m};
 
    return running_m == false;
  }

---

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

• /home/runner/work/pars-cxx/pars-cxx/lib/include/pars/ev/dispatcher.h