inline void spawn(
spawn_type spw,
actor<stackless>& sire, match_t func, SpawnHandler h,
match_t ctxid = ctxid_nil,
link_type type = no_link,
std::size_t stack_size = default_stacksize(),
seconds_t tmo = seconds_t(GCE_DEFAULT_REQUEST_TIMEOUT_SEC)
)
{
aid_t aid;
sid_t sid = sire.spawn(spw, func, ctxid, stack_size);
boost::uint16_t err = 0;
sid_t ret_sid = sid_nil;
duration_t curr_tmo = tmo;
typedef boost::chrono::system_clock clock_t;
clock_t::time_point begin_tp = clock_t::now();
match mach(curr_tmo);
mach.match_list_.push_back(detail::msg_spawn_ret);
sire.recv(
boost::bind(
&handle_remote_spawn, _1, _2, _3,
type, begin_tp, sid, tmo, curr_tmo, spawn_handler_t(h)
),
mach
);
}
actor_id spawn(actor sire, F&& f, fiber_meta meta)
{
// Create actor handler.
actor_handler_t hdr(f);
// Generate actor_id.
auto aid = generate_actor_id();
// Spawn an coctx.
asev::strand_t snd(*evs_);
auto sire_aid = sire == nullactor ? nullaid : sire.get_actor_id();
if (sire_aid != nullaid && meta.ssire_)
{
snd = sire.get_strand();
}
snd.spawn(
[this, sire_aid, hdr, aid](asev::corctx_t& ctx)
{
// Alloc fiber_actor.
auto a = fiber_actor_pool_->get();
// Run actor.
a->init(aid, ctx.get_strand());
a->run(ctx, sire_aid, std::move(hdr));
},
coctx::make_stacksize(meta.ssize_)
);
return aid;
}
inline void handle_remote_spawn(
actor<stackless>& self, aid_t aid,
message msg, link_type type,
boost::chrono::system_clock::time_point begin_tp,
sid_t sid, seconds_t tmo, duration_t curr_tmo,
spawn_handler_t const& hdr
)
{
boost::uint16_t err = 0;
sid_t ret_sid = sid_nil;
msg >> err >> ret_sid;
do
{
if (err != 0 || (aid && sid == ret_sid))
{
break;
}
if (tmo != infin)
{
duration_t pass_time = boost::chrono::system_clock::now() - begin_tp;
curr_tmo -= pass_time;
}
begin_tp = boost::chrono::system_clock::now();
match mach(curr_tmo);
mach.match_list_.push_back(detail::msg_spawn_ret);
self.recv(
boost::bind(
&handle_remote_spawn, _1, _2, _3,
type, begin_tp, sid, tmo, curr_tmo, hdr
),
mach
);
return;
}
while (false);
detail::spawn_error error = (detail::spawn_error)err;
if (error != detail::spawn_ok)
{
aid = aid_t();
}
if (aid)
{
if (type == linked)
{
self.link(aid);
}
else if (type == monitored)
{
self.monitor(aid);
}
}
hdr(self, aid);
}
bool manager::actualize_doors_state ( actor& actor, float const average_speed )
{
float const radius = average_speed*g_door_open_time + g_door_length;
Fvector const& position = actor.get_position();
//check_bug_door ( );
m_doors.nearest ( position, radius, m_nearest_doors );
//check_bug_door ( );
if ( m_nearest_doors.empty() && !actor.need_update() )
return true;
return actor.update_doors( m_nearest_doors, average_speed );
}
actor operator*(actor f, actor g) {
auto& sys = f->home_system();
return make_actor<decorator::sequencer, actor>(
sys.next_actor_id(), sys.node(), &sys,
actor_cast<strong_actor_ptr>(std::move(f)),
actor_cast<strong_actor_ptr>(std::move(g)), std::set<std::string>{});
}
void send_message(actor& source, actor& target, const std::string& message)
{
ac_message_t msg;
msg.src = &source;
msg.message = message;
target.enqueue(msg);
}
void renderer::animateActor(actor &character, bool isMoving)
{
double temp[2];
(character.animationStep > 6) ? character.animationStep = 0 : 0;
switch(character.face)
{
case Up:
case UpRight:
case UpLeft:
temp[1] = .25;
break;
case Left: temp[1] = 0;
break;
case Down:
case DownRight:
case DownLeft: temp[1] = .75;
break;
case Right: temp[1] = .5;
break;
default:
break;
}
temp[0] = double(character.animationStep)*.125;
character.animationStep++;
characterData[character.getID()].moveActorCoords(temp);
}
void actor_registry::put_named(atom_value key, actor value) {
if (value)
value->attach_functor([=](uint32_t) {
detail::singletons::get_actor_registry()->put_named(key, invalid_actor);
});
exclusive_guard guard{named_entries_mtx_};
named_entries_.emplace(key, std::move(value));
}
message_id local_actor::sync_send_tuple_impl(message_priority mp,
const actor& dest,
any_tuple&& what) {
auto nri = new_request_id();
if (mp == message_priority::high) nri = nri.with_high_priority();
dest->enqueue({address(), dest, nri}, std::move(what));
return nri.response_id();
}
void send_as(const actor& from, message_priority prio,
const channel& to, Ts&&... xs) {
if (! to) {
return;
}
message_id mid;
to->enqueue(from.address(),
prio == message_priority::high ? mid.with_high_priority() : mid,
make_message(std::forward<Ts>(xs)...), nullptr);
}
inline void handle_spawn(
actor<stackless>& self, aid_t aid,
message msg, link_type type, spawn_handler_t const& hdr
)
{
if (aid)
{
if (type == linked)
{
self.link(aid);
}
else if (type == monitored)
{
self.monitor(aid);
}
}
hdr(self, aid);
}
void delegate(message_priority mp, const actor& dest, Ts&&... xs) {
static_assert(sizeof...(Ts) > 0, "no message to send");
if (! dest)
return;
auto mid = current_element_->mid;
current_element_->mid = mp == message_priority::high
? mid.with_high_priority()
: mid.with_normal_priority();
current_element_->msg = make_message(std::forward<Ts>(xs)...);
dest->enqueue(std::move(current_element_), host());
}
void local_actor::forward_message(const actor& dest, message_priority prio) {
if (!dest) {
return;
}
auto id = (prio == message_priority::high)
? m_current_node->mid.with_high_priority()
: m_current_node->mid.with_normal_priority();
dest->enqueue(m_current_node->sender, id, m_current_node->msg, host());
// treat this message as asynchronous message from now on
m_current_node->mid = invalid_message_id;
}
message_id local_actor::sync_send_tuple_impl(message_priority mp,
const actor& dest,
any_tuple&& what) {
if (!dest) {
throw std::invalid_argument("cannot send synchronous message "
"to invalid_actor");
}
auto nri = new_request_id();
if (mp == message_priority::high) nri = nri.with_high_priority();
dest->enqueue({address(), dest, nri}, std::move(what), m_host);
return nri.response_id();
}
message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
const actor& dest,
const util::duration& rtime,
any_tuple&& what) {
auto nri = new_request_id();
if (mp == message_priority::high) nri = nri.with_high_priority();
dest->enqueue({address(), dest, nri}, std::move(what));
auto rri = nri.response_id();
get_scheduler()->delayed_send({address(), this, rri}, rtime,
make_any_tuple(sync_timeout_msg{}));
return rri;
}
static void echo(actor<stackful>& self)
{
try
{
while (true)
{
message msg;
aid_t sender = self.recv(msg);
match_t type = msg.get_type();
if (type == atom("echo"))
{
self.send(sender, msg);
}
else
{
break;
}
}
}
catch (std::exception& ex)
{
std::cerr << "echo except: " << ex.what() << std::endl;
}
}
inline void spawn(
stackless,
actor<stackless>& sire, F f, SpawnHandler h,
cache_pool* user, link_type type, std::size_t stack_size
)
{
user->get_strand().post(
boost::bind(
&detail::make_stackless_actor,
sire.get_aid(), user,
make_actor_func<stackless>(f), stack_size
)
);
match mach;
mach.match_list_.push_back(detail::msg_new_actor);
sire.recv(
boost::bind(
&handle_spawn, _1, _2, _3,
type, spawn_handler_t(h)
),
mach
);
}
message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
const actor& dest,
const util::duration& rtime,
any_tuple&& what) {
if (!dest) {
throw std::invalid_argument("cannot send synchronous message "
"to invalid_actor");
}
auto nri = new_request_id();
if (mp == message_priority::high) nri = nri.with_high_priority();
dest->enqueue({address(), dest, nri}, std::move(what), m_host);
auto rri = nri.response_id();
get_scheduling_coordinator()->delayed_send({address(), this, rri}, rtime,
make_any_tuple(sync_timeout_msg{}));
return rri;
}
message_id local_actor::timed_sync_send_tuple_impl(message_priority mp,
const actor& dest,
const duration& rtime,
message&& what) {
if (!dest) {
throw std::invalid_argument(
"cannot send synchronous message "
"to invalid_actor");
}
auto nri = new_request_id();
if (mp == message_priority::high) {
nri = nri.with_high_priority();
}
dest->enqueue(address(), nri, std::move(what), host());
auto rri = nri.response_id();
auto sched_cd = detail::singletons::get_scheduling_coordinator();
sched_cd->delayed_send(rtime, address(), this, rri,
make_message(sync_timeout_msg{}));
return rri;
}
/// Removes a monitor from `whom`.
inline void demonitor(const actor& whom) {
demonitor(whom.address());
}
/**
* Sends an exit message to `whom`.
*/
inline void send_exit(const actor& whom, uint32_t reason) {
send_exit(whom.address(), reason);
}
// utility function to print an exit message with custom name
void print_on_exit(const actor& ptr, const std::string& name) {
ptr->attach_functor([=](uint32_t reason) {
aout(ptr) << name << " exited with reason " << reason << endl;
});
}
// utility function to print an exit message with custom name
void print_on_exit(const actor& hdl, const std::string& name) {
hdl->attach_functor([=](abstract_actor* ptr, uint32_t reason) {
aout(ptr) << name << " exited with reason " << reason << endl;
});
}
static bool operator==(actor const& lhs, actor const& rhs)
{
return lhs.get_actor() == rhs.get_actor();
}
void actor_ostream::redirect(const actor& src, std::string f, int flags) {
send_as(src, detail::singletons::get_scheduling_coordinator()->printer(),
redirect_atom::value, src.address(), std::move(f), flags);
}
