service Member List

This is the complete list of members for service, including all inherited members.

__do_cmd_request(const request_ptr_t a_request)	endpoint	private
__do_get_request(const request_ptr_t a_request)	endpoint	private
__do_handle_set_condition_request(const request_ptr_t a_request)	endpoint	inlineprivatevirtual
__do_run_request(const request_ptr_t a_request)	endpoint	private
__do_set_request(const request_ptr_t a_request)	endpoint	private
add_async_child(endpoint_ptr_t a_endpoint_ptr)	service
add_child(endpoint_ptr_t a_endpoint_ptr)	service
async_map_t typedef	service
authenticate(const uuid_t &a_key) const	endpoint	protected
bind_key(amqp_channel_ptr a_channel, const std::string &a_exchange, const std::string &a_queue_name, const std::string &a_routing_key)	core	protectedstatic
bind_keys()	service	protectedvirtual
check_key(const uuid_t &a_key) const	endpoint	inline
clock_t typedef	scheduler< executor, clock >
concurrent_receiver()	concurrent_receiver
concurrent_receiver(const concurrent_receiver &)=delete	concurrent_receiver
concurrent_receiver(concurrent_receiver &&a_orig)	concurrent_receiver
core(const scarab::param_node &a_config=dripline_config(), const scarab::authentication &a_auth=scarab::authentication(), const bool a_make_connection=true)	core
core(const core &a_orig)=default	core
core(core &&a_orig)=default	core
disable_lockout(const uuid_t &a_key, bool a_force=false)	endpoint
do_cancellation(int a_code)	service	privatevirtual
do_cmd_request(const request_ptr_t a_request)	endpoint	inlinevirtual
do_get_request(const request_ptr_t a_request)	endpoint	inlinevirtual
do_run_request(const request_ptr_t a_request)	endpoint	inlinevirtual
do_send(message_ptr_t a_message, const std::string &a_exchange, bool a_expect_reply, amqp_channel_ptr a_channel=amqp_channel_ptr()) const	core	protected
do_set_request(const request_ptr_t a_request)	endpoint	inlinevirtual
duration_t typedef	scheduler< executor, clock >
enable_lockout(const scarab::param_node &a_tag)	endpoint	inline
enable_lockout(const scarab::param_node &a_tag, uuid_t a_key)	endpoint
endpoint(const std::string &a_name)	endpoint
endpoint(const endpoint &a_orig)=default	endpoint
endpoint(endpoint &&a_orig)=default	endpoint
events_map_t typedef	scheduler< executor, clock >
executable_t typedef	scheduler< executor, clock >
dripline::execute()	concurrent_receiver
dripline::heartbeater::execute(const std::string &a_name, uuid_t a_id, const std::string &a_routing_key)	heartbeater
dripline::scheduler::execute()	scheduler< executor, clock >
f_cv	scheduler< executor, clock >
f_executor_mutex	scheduler< executor, clock >
f_heartbeat_thread	heartbeater	protected
f_scheduler_mutex	scheduler< executor, clock >
f_scheduler_thread	scheduler< executor, clock >
handle_is_locked_request(const request_ptr_t a_request)	endpoint	private
handle_lock_request(const request_ptr_t a_request)	endpoint	private
handle_message_chunk(amqp_envelope_ptr a_envelope)	receiver
handle_ping_request(const request_ptr_t a_request)	endpoint	private
handle_set_condition_request(const request_ptr_t a_request)	endpoint	private
handle_unlock_request(const request_ptr_t a_request)	endpoint	private
heartbeater(service *a_service)	heartbeater
heartbeater(const heartbeater &)=delete	heartbeater
heartbeater(heartbeater &&a_orig)=default	heartbeater
is_locked() const	endpoint	inline
listen()	service
listen_for_message(amqp_envelope_ptr &a_envelope, post_listen_status &a_status, amqp_channel_ptr a_channel, const std::string &a_consumer_tag, int a_timeout_ms=0, bool a_do_ack=true)	core	static
listen_on_queue()	service	virtual
listener()	listener
listener(const listener &)=delete	listener
listener(listener &&a_orig)=default	listener
listener_receiver()	listener_receiver	inline
listener_receiver(const listener_receiver &)=delete	listener_receiver
listener_receiver(listener_receiver &&a_orig)	listener_receiver	inline
on_alert_message(const alert_ptr_t a_alert)	endpoint	virtual
on_reply_message(const reply_ptr_t a_reply)	endpoint	virtual
on_request_message(const request_ptr_t a_request)	service	protectedvirtual
open_channel() const	core	protected
open_channels()	service	protectedvirtual
operator=(const service &)=delete	service
operator=(service &&a_orig)	service
dripline::core::operator=(const core &a_orig)=default	core
dripline::core::operator=(core &&a_orig)=default	core
dripline::endpoint::operator=(const endpoint &a_orig)=default	endpoint
dripline::endpoint::operator=(endpoint &&a_orig)=default	endpoint
dripline::listener_receiver::operator=(const listener_receiver &)=delete	listener_receiver
dripline::listener_receiver::operator=(listener_receiver &&a_orig)	listener_receiver	inline
dripline::listener::operator=(const listener &)=delete	listener
dripline::listener::operator=(listener &&a_orig)	listener
dripline::concurrent_receiver::operator=(const concurrent_receiver &)=delete	concurrent_receiver
dripline::concurrent_receiver::operator=(concurrent_receiver &&a_orig)	concurrent_receiver
dripline::receiver::operator=(const receiver &a_orig)=delete	receiver
dripline::receiver::operator=(receiver &&a_orig)	receiver
dripline::heartbeater::operator=(const heartbeater &)=delete	heartbeater
dripline::heartbeater::operator=(heartbeater &&a_orig)	heartbeater
dripline::scheduler::operator=(const scheduler &)=delete	scheduler< executor, clock >
dripline::scheduler::operator=(scheduler &&a_orig)	scheduler< executor, clock >
parent()	endpoint
parent() const	endpoint
post_listen_status enum name	core
process_message(message_ptr_t a_message)	concurrent_receiver	virtual
process_message_pack(incoming_message_pack &a_pack, const std::string &a_message_id)	receiver
process_received_reply(incoming_message_pack &a_pack, const std::string &a_message_id)	receiver	protected
receiver()	receiver
dripline::listener_receiver::receiver(const receiver &a_orig)=delete	receiver
dripline::listener_receiver::receiver(receiver &&a_orig)=default	receiver
remove_queue()	service	protectedvirtual
dripline::core::remove_queue(amqp_channel_ptr a_channel, const std::string &a_queue_name)	core	protectedstatic
run()	service	virtual
s_offline	core	static
schedule(executable_t an_executable, time_point_t an_exe_time)	scheduler< executor, clock >
schedule(executable_t an_executable, duration_t an_interval, time_point_t an_exe_time=clock::now())	scheduler< executor, clock >
scheduler()	scheduler< executor, clock >
scheduler(const scheduler &)=delete	scheduler< executor, clock >
scheduler(scheduler &&)	scheduler< executor, clock >
send(request_ptr_t a_request, amqp_channel_ptr a_channel=amqp_channel_ptr()) const	service	inlinevirtual
send(reply_ptr_t a_reply, amqp_channel_ptr a_channel=amqp_channel_ptr()) const	service	inlinevirtual
send(alert_ptr_t a_alert, amqp_channel_ptr a_channel=amqp_channel_ptr()) const	service	inlinevirtual
send_noreply(message_ptr_t a_message, const std::string &a_exchange) const	core	protected
send_reply(reply_ptr_t a_reply) const	service	virtual
send_withreply(message_ptr_t a_message, std::string &a_reply_consumer_tag, const std::string &a_exchange) const	core	protected
service(const scarab::param_node &a_config=service_config(), const scarab::authentication &a_auth=create_auth_with_dripline(true), const bool a_make_connection=true)	service
service(const service &)=delete	service
service(service &&a_orig)=default	service
setup_exchange(amqp_channel_ptr a_channel, const std::string &a_exchange)	core	protectedstatic
setup_queue(amqp_channel_ptr a_channel, const std::string &a_queue_name)	core	protectedstatic
setup_queues()	service	protectedvirtual
snake_case_mv_accessible(status, status)	service
snake_case_mv_accessible(bool, restart_on_error)	service
snake_case_mv_accessible(bool, enable_scheduling)	service
snake_case_mv_accessible(uuid_t, id)	service
dripline::core::snake_case_mv_accessible(unsigned, port)	core
dripline::core::snake_case_mv_accessible(unsigned, max_payload_size)	core
dripline::core::snake_case_mv_accessible(bool, make_connection)	core
dripline::core::snake_case_mv_accessible(unsigned, max_connection_attempts)	core
dripline::endpoint::snake_case_mv_accessible(service *, service)	endpoint
dripline::endpoint::snake_case_mv_accessible(uuid_t, lockout_key)	endpoint	protected
dripline::listener_receiver::snake_case_mv_accessible(unsigned, listen_timeout_ms)	listener
dripline::listener_receiver::snake_case_mv_accessible(unsigned, single_message_wait_ms)	receiver
dripline::concurrent_receiver::snake_case_mv_accessible(unsigned, reply_listen_timeout_ms)	receiver
dripline::heartbeater::snake_case_mv_accessible(unsigned, heartbeat_interval_s)	heartbeater
dripline::heartbeater::snake_case_mv_accessible(unsigned, check_timeout_ms)	heartbeater
dripline::heartbeater::snake_case_mv_accessible(service *, service)	heartbeater
dripline::scheduler::snake_case_mv_accessible(duration_t, exe_buffer)	scheduler< executor, clock >
dripline::scheduler::snake_case_mv_accessible(duration_t, cycle_time)	scheduler< executor, clock >
snake_case_mv_referrable(scarab::authentication, auth)	service
snake_case_mv_referrable(sync_map_t, sync_children)	service
snake_case_mv_referrable(async_map_t, async_children)	service
snake_case_mv_referrable(std::string, broadcast_key)	service
dripline::core::snake_case_mv_referrable(std::string, address)	core
dripline::core::snake_case_mv_referrable(std::string, username)	core
dripline::core::snake_case_mv_referrable(std::string, password)	core
dripline::core::snake_case_mv_referrable(std::string, requests_exchange)	core
dripline::core::snake_case_mv_referrable(std::string, alerts_exchange)	core
dripline::core::snake_case_mv_referrable(std::string, heartbeat_routing_key)	core
dripline::endpoint::snake_case_mv_referrable(std::string, name)	endpoint
dripline::endpoint::snake_case_mv_referrable(scarab::param_node, lockout_tag)	endpoint	protected
dripline::listener_receiver::snake_case_mv_referrable(amqp_channel_ptr, channel)	listener
dripline::listener_receiver::snake_case_mv_referrable(std::string, consumer_tag)	listener
dripline::listener_receiver::snake_case_mv_referrable(std::thread, listener_thread)	listener
dripline::listener_receiver::snake_case_mv_referrable(scarab::concurrent_queue< message_ptr_t >, message_queue)	concurrent_receiver	protected
dripline::concurrent_receiver::snake_case_mv_referrable(std::thread, receiver_thread)	concurrent_receiver	protected
dripline::receiver::snake_case_mv_referrable(incoming_message_map, incoming_messages)	receiver
snake_case_mv_referrable_const(executor, the_executor)	scheduler< executor, clock >
snake_case_mv_referrable_const(events_map_t, events)	scheduler< executor, clock >
sort_message(const message_ptr_t a_request)	endpoint
start()	service
start_consuming()	service	protectedvirtual
dripline::core::start_consuming(amqp_channel_ptr a_channel, const std::string &a_queue_name)	core	protectedstatic
status enum name	service	protected
stop()	service
stop_consuming()	service	protectedvirtual
dripline::core::stop_consuming(amqp_channel_ptr a_channel, std::string &a_consumer_tag)	core	protectedstatic
submit_alert_message(const alert_ptr_t a_alert)	endpoint
submit_message(message_ptr_t a_message)	service	protectedvirtual
submit_reply_message(const reply_ptr_t a_reply)	endpoint
submit_request_message(const request_ptr_t a_request)	endpoint
sync_map_t typedef	service
time_point_t typedef	scheduler< executor, clock >
unschedule(int an_id)	scheduler< executor, clock >
wait_for_message(incoming_message_pack &a_pack, const std::string &a_message_id)	receiver
wait_for_reply(const sent_msg_pkg_ptr a_receive_reply, int a_timeout_ms=0)	receiver
wait_for_reply(const sent_msg_pkg_ptr a_receive_reply, core::post_listen_status &a_status, int a_timeout_ms=0)	receiver
~concurrent_receiver()	concurrent_receiver	virtual
~core()=default	core	virtual
~endpoint()=default	endpoint	virtual
~heartbeater()=default	heartbeater	virtual
~listener()=default	listener	virtual
~receiver()=default	receiver	virtual
~scheduler()=default	scheduler< executor, clock >	virtual
~service()	service	virtual