Application

template<typename component_t>
class single : public pars::app::with_default_setup

Public Types

using component_type = component_t

using self_type = single<component_type>

Public Functions

inline single()

inline int exec(int argc, char **argv)

Protected Functions

inline component_type &comp()

inline ev::enqueuer &router()

inline ev::hf_registry &hfs()

virtual void startup(int argc, char **argv) = 0

inline void graceful_terminate()

inline void terminate_now()

inline void stop_job_thread(const int j_id)

inline int run()

struct with_default_setup

Subclassed by pars::app::single< component_type >, pars::app::single< comp::client >, pars::app::single< comp::backend >, pars::app::single< component_t >

Public Functions

inline void enable_source_loc_logging()

inline void setup()

Protected Functions

with_default_setup() = default

template<typename state_t>
struct state_machine

Public Types

using state_type = state_t

Public Functions

inline state_machine(state_type s)

inline void ensure(std::initializer_list<state_type> expected)

inline void ensure(state_type s)

inline void next(state_type s)

inline void rollback()

inline void commit()

inline state_tx<state_type> tx(state_type to_state)

inline state_tx<state_type> tx(state_type from_state, state_type to_state)

inline state_tx<state_type> tx(std::initializer_list<state_type> from_states, state_type to_state)

inline state_type current() const

inline void reset()

template<typename state_t>
struct state_tx

Public Types

using state_type = state_t

Public Functions

inline state_tx(state_machine<state_type> &sm, state_type to_state)

inline ~state_tx()

inline void commit()

inline void rollback()

template<typename key_t, typename resource_t, typename mutex_t = std::mutex>
class resources

Public Types

using key_type = key_t

using resource_type = resource_t

using mutex_type = mutex_t

Public Functions

inline resources()

inline std::size_t count()

inline bool contains(const key_type key)

template<class ...args_t>
inline auto find_or_emplace(const key_type key, args_t&&... args)

template<class ...args_t>
inline auto emplace(const key_type key, args_t&&... args)

inline locked<resource_type, mutex_type, key_type> locked_resource(const key_type k)

inline void delete_resource(key_type k)

template<typename resource_t, typename mtx_t>
struct lockable

Public Types

using resource_type = resource_t

using mutex_type = mtx_t

Public Members

resource_type &resource

mutex_type &mutex

template<typename resource_t, typename mutex_t, typename key_t, typename lock_t = std::unique_lock<mutex_t>>
struct locked

Public Types

using resource_type = resource_t

using mutex_type = mutex_t

using key_type = key_t

using lock_type = lock_t

Public Functions

inline locked(lockable<resource_type, mutex_type> l, key_type k)

inline auto &resource()

inline auto &guard()

inline auto &key()