actor_ptr m_observer;

actor_ptr m_observed;

public:

down_observer(actor_ptr observer, actor_ptr observed)

: m_observer(std::move(observer)), m_observed(std::move(observed)) {

CPPA_REQUIRE(m_observer != nullptr);

CPPA_REQUIRE(m_observed != nullptr);

}

void actor_exited(std::uint32_t reason) {

if (m_observer) {

m_observer->enqueue(m_observed.get(),

make_any_tuple(atom("DOWN"), reason));

}

}

bool matches(const attachable::token& match_token) {

if (match_token.subtype == typeid(down_observer)) {

auto ptr = reinterpret_cast<const local_actor*>(match_token.ptr);

return m_observer == ptr;

}

return false;

}

if (what && m_subscriptions.count(what) == 0) {

m_subscriptions.insert(std::make_pair(what, what->subscribe(this)));

}

std::vector<group_ptr> result;

for (auto& kvp : m_subscriptions) {

result.emplace_back(kvp.first);

}

return result;

auto& whom = last_sender();

if (whom == nullptr) {

return;

}

auto& id = m_current_node->mid;

if (id.valid() == false || id.is_response()) {

send_message(whom.get(), std::move(what));

}

else if (!id.is_answered()) {

if (chaining_enabled()) {

if (whom->chained_sync_enqueue(this, id.response_id(), std::move(what))) {

m_chained_actor = whom;

}

}

else {

whom->sync_enqueue(this, id.response_id(), std::move(what));

}

id.mark_as_answered();

}

if (new_receiver == nullptr) {

return;

}

auto& from = last_sender();

auto id = m_current_node->mid;

if (id.valid() == false || id.is_response()) {

new_receiver->enqueue(from.get(), m_current_node->msg);

}

else {

new_receiver->sync_enqueue(from.get(), id, m_current_node->msg);

// treat this message as asynchronous message from now on

m_current_node->mid = message_id_t();

}

auto n = m_current_node;

response_handle result(this, n->sender, n->mid.response_id());

n->mid.mark_as_answered();

return std::move(result);

const util::duration& rel_time,

any_tuple&& what) {

auto mid = this->send_sync_message(whom, std::move(what));

auto tmp = make_any_tuple(atom("TIMEOUT"));

get_scheduler()->delayed_reply(this, rel_time, mid, std::move(tmp));

return mid;