# ifdef CPPA_DEBUG

auto st = m_state.load();

switch (st) {

case abstract_scheduled_actor::ready:

case abstract_scheduled_actor::pending:

// state ok

break;

default: {

std::cerr << "UNEXPECTED STATE: " << st << std::endl;

// failed requirement calls abort() and prints stack trace

CPPA_REQUIRE( st == abstract_scheduled_actor::ready

|| st == abstract_scheduled_actor::pending);

}

}

# endif // CPPA_DEBUG

scoped_self_setter sss{this};

auto done_cb = [&]() {

m_state.store(abstract_scheduled_actor::done);

m_bhvr_stack.clear();

m_bhvr_stack.cleanup();

on_exit();

CPPA_REQUIRE(next_job == nullptr);

next_job.swap(m_chained_actor);

};

CPPA_REQUIRE(next_job == nullptr);

try {

detail::recursive_queue_node* e = nullptr;

for (;;) {

e = m_mailbox.try_pop();

if (e == nullptr) {

CPPA_REQUIRE(next_job == nullptr);

next_job.swap(m_chained_actor);

m_state.store(abstract_scheduled_actor::about_to_block);

std::atomic_thread_fence(std::memory_order_seq_cst);

if (m_mailbox.can_fetch_more() == false) {

switch (compare_exchange_state(

abstract_scheduled_actor::about_to_block,

abstract_scheduled_actor::blocked)) {

case abstract_scheduled_actor::ready:

// interrupted by arriving message

// restore members

CPPA_REQUIRE(m_chained_actor == nullptr);

next_job.swap(m_chained_actor);

break;

case abstract_scheduled_actor::blocked:

// done setting actor to blocked

return resume_result::actor_blocked;

case abstract_scheduled_actor::pending:

CPPA_CRITICAL("illegal state: pending");

case abstract_scheduled_actor::done:

CPPA_CRITICAL("illegal state: done");

case abstract_scheduled_actor::about_to_block:

CPPA_CRITICAL("illegal state: about_to_block");

default:

CPPA_CRITICAL("invalid state");

};

}

else {

m_state.store(abstract_scheduled_actor::ready);

CPPA_REQUIRE(m_chained_actor == nullptr);

next_job.swap(m_chained_actor);

}

}

else if (m_bhvr_stack.invoke(m_policy, this, e)) {

if (m_bhvr_stack.empty()) {

done_cb();

return resume_result::actor_done;

}

m_bhvr_stack.cleanup();

}

}

}

catch (actor_exited& what) { cleanup(what.reason()); }

catch (...) { cleanup(exit_reason::unhandled_exception); }

done_cb();

return resume_result::actor_done;

reset_timeout();

request_timeout(bhvr.timeout());

if (discard_old) m_bhvr_stack.pop_async_back();

m_bhvr_stack.push_back(std::move(bhvr));

if (bhvr.timeout().valid()) {

reset_timeout();

request_timeout(bhvr.timeout());

}

m_bhvr_stack.push_back(std::move(bhvr), mf);

if (reason == exit_reason::normal) {

cleanup(exit_reason::normal);

m_bhvr_stack.clear();

}

else {

abstract_scheduled_actor::quit(reason);

}