pars::ev Namespace Reference

Classes
struct	base_async_metadata
struct	base_internal_metadata
struct	base_kind
struct	base_kind< kind_of, event_t >
struct	base_klass
struct	base_network_metadata
struct	base_sync_metadata
struct	common_kind
struct	common_metadata
struct	creating_pipe
class	dispatcher
class	enqueuer
struct	exception
struct	fired
struct	fired< event_t >
struct	hf_registry
struct	hf_traits
struct	hf_traits< return_t(class_t::*)(hf_arg< kind_of, event_t >)>
struct	init
class	job
struct	klass
struct	klass< creating_pipe >
struct	klass< exception >
struct	klass< init >
struct	klass< network_error >
struct	klass< nngxx::msg >
struct	klass< pipe_created >
struct	klass< pipe_removed >
struct	klass< shutdown >
struct	klass< std::shared_ptr< event_t > >
struct	klass<::pars_example::event::fib_computed >
struct	klass<::pars_example::event::fib_requested >
struct	klass<::pars_example::event::stop_compute >
struct	metadata
struct	metadata< kind_of, event_t >
struct	network_error
struct	pipe_created
struct	pipe_removed
struct	received
struct	received< event_t >
struct	received< nngxx::msg >
struct	runner
struct	sent
struct	sent< event_t >
struct	serialize
struct	shutdown
class	spec
struct	uuid

Concepts
concept	event_c
concept	internal_event_c
concept	network_event_c
concept	sync_event_c
concept	sync_internal_event_c
concept	sync_network_event_c
concept	async_event_c
concept	async_internal_event_c
concept	async_network_event_c
concept	kind_c
concept	sync_kind_c
concept	async_kind_c

Typedefs
using	job_handler_f = std::function<void(job)>
template<template< typename > typename kind_of, event_c event_t>
using	hf_arg = kind_of<event_t>
template<template< typename > typename kind_of, event_c event_t>
using	handler_f = std::move_only_function<void(hf_arg<kind_of, event_t>)>

Enumerations
enum class	executes { sync , async }

Functions
template<typename event_t>
	sent (event_t, metadata< sent, event_t >) -> sent< event_t >
template<typename event_t>
	received (event_t, metadata< received, event_t >) -> received< event_t >
template<typename event_t>
	fired (event_t, metadata< fired, event_t >) -> fired< event_t >
template<typename mem_fn_t, template< typename > typename kind_of = hf_traits<mem_fn_t>::template kind_type, typename event_t = hf_traits<mem_fn_t>::event_type, typename class_t = hf_traits<mem_fn_t>::class_type> requires kind_c<kind_of> && event_c<event_t>
handler_f< kind_of, event_t >	make_hf (mem_fn_t &mem_fn, class_t *self)

Variables
template<template< typename > typename kind_of, template< typename > typename event_t>
constexpr auto	is_same_kind_v = std::is_same_v<kind_of<void>, event_t<void>>

Typedef Documentation

handler_f

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

using pars::ev::handler_f = std::move_only_function<void(hf_arg<kind_of, event_t>)>

Definition at line 50 of file make_hf.h.

hf_arg

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

using pars::ev::hf_arg = kind_of<event_t>

Definition at line 46 of file make_hf.h.

job_handler_f

using pars::ev::job_handler_f = std::function<void(job)>

Definition at line 61 of file hf_registry.h.

Enumeration Type Documentation

executes

enum class pars::ev::executes

strong

Enumerator
sync
async

Definition at line 40 of file event.h.

{
  sync,
  async
};

Function Documentation

fired()

template<typename event_t>

pars::ev::fired	(	event_t	,
		metadata< fired, event_t >	) -> fired< event_t >

make_hf()

template<typename mem_fn_t, template< typename > typename kind_of = hf_traits<mem_fn_t>::template kind_type, typename event_t = hf_traits<mem_fn_t>::event_type, typename class_t = hf_traits<mem_fn_t>::class_type>
requires kind_c<kind_of> && event_c<event_t>

handler_f< kind_of, event_t > pars::ev::make_hf	(	mem_fn_t &	mem_fn,
		class_t *	self )

Definition at line 58 of file make_hf.h.

{
  using namespace std::placeholders;
 
  static constexpr std::size_t arity = hf_traits<mem_fn_t>::arity;
 
  if constexpr (std::is_same_v<class_t, void>)
  {
    return handler_f<kind_of, event_t>(std::bind(mem_fn, _1));
  }
  else if constexpr (std::is_same_v<std::integral_constant<std::size_t, arity>,
                                    std::integral_constant<std::size_t, 0>>)
  {
    return handler_f<kind_of, event_t>(
      std::bind(mem_fn, static_cast<class_t*>(self)));
  }
  else if constexpr (std::is_same_v<std::integral_constant<std::size_t, arity>,
                                    std::integral_constant<std::size_t, 1>>)
  {
    return handler_f<kind_of, event_t>(
      std::bind(mem_fn, static_cast<class_t*>(self), _1));
  }
  else if constexpr (std::is_same_v<std::integral_constant<std::size_t, arity>,
                                    std::integral_constant<std::size_t, 2>>)
  {
    return handler_f<kind_of, event_t>(
      std::bind(mem_fn, static_cast<class_t*>(self), _1, _2));
  }
 
  static_assert(std::ratio_less_equal_v<std::ratio<arity>, std::ratio<2>>,
                "Only fn with arity <= 2 are supported");
}

Referenced by pars::ev::hf_registry::on(), pars::net::pull::on(), pars::net::push::on(), pars::net::rep::on(), and pars::net::req::on().

Here is the caller graph for this function:

received()

template<typename event_t>

pars::ev::received	(	event_t	,
		metadata< received, event_t >	) -> received< event_t >

sent()

template<typename event_t>

pars::ev::sent	(	event_t	,
		metadata< sent, event_t >	) -> sent< event_t >

Variable Documentation

is_same_kind_v

template<template< typename > typename kind_of, template< typename > typename event_t>

auto pars::ev::is_same_kind_v = std::is_same_v<kind_of<void>, event_t<void>>

constexpr

Definition at line 56 of file kind.h.

Referenced by pars::ev::klass<::pars_example::event::fib_requested >::exec_policy(), and pars::ev::job::operator=().