inline void delayed_reply_tuple(const std::chrono::duration<Rep, Period>& rtime,
any_tuple what) {
get_scheduler()->delayed_reply(self->last_sender(),
rtime,
self->get_response_id(),
std::move(what));
}
void delayed_send_tuple(channel_destination dest,
const util::duration& rtime,
any_tuple data) {
if (dest.receiver) {
message_header hdr{self, std::move(dest.receiver), dest.priority};
get_scheduler()->delayed_send(std::move(hdr), rtime, std::move(data));
}
}
inline void delayed_send(const channel_ptr& whom,
const std::chrono::duration<Rep, Period>& rel_time,
Args&&... what) {
if (whom) {
get_scheduler()->delayed_send(whom, rel_time,
std::forward<Args>(what)...);
}
}
actor_ptr spawn_in_group(const group_ptr& grp, Fun&& fun, Args&&... args) {
return get_scheduler()->spawn_cb_impl(Hint,
[grp](local_actor* ptr) {
ptr->join(grp);
},
std::forward<Fun>(fun),
std::forward<Args>(args)...);
}
message_future timed_sync_send_tuple(actor_ptr whom,
const std::chrono::duration<Rep,Period>& rel_time,
any_tuple what) {
auto mf = sync_send_tuple(std::move(whom), std::move(what));
auto tmp = make_any_tuple(atom("TIMEOUT"));
get_scheduler()->delayed_reply(self, rel_time, mf.id(), std::move(tmp));
return mf;
}
message_future timed_sync_send_tuple(actor_destination dest,
const util::duration& rtime,
any_tuple what) {
auto mf = sync_send_tuple(std::move(dest), std::move(what));
message_header hdr{self, self, mf.id()};
auto tmp = make_any_tuple(atom("TIMEOUT"));
get_scheduler()->delayed_send(std::move(hdr), rtime, std::move(tmp));
return mf;
}
void local_actor::delayed_send_tuple(message_priority prio,
const channel& dest,
const util::duration& rel_time,
cppa::any_tuple msg) {
message_id mid;
if (prio == message_priority::high) mid = mid.with_high_priority();
get_scheduler()->delayed_send({address(), dest, mid},
rel_time, std::move(msg));
}
/*
* Send stopRequest() to scheduler.
*/
void
scx_simcontroller::scheduler_stop_request()
{
sg::SchedulerInterfaceForComponents * scheduler =
get_scheduler()->ObtainPointer<sg::SchedulerInterfaceForComponents>();
if (scheduler) {
scheduler->stopRequest();
}
}
boost::future<void> foo()
{
int i=5;
m_sink.foo2(boost::ref(i)).get();
boost::shared_ptr<Servant3> s3 (boost::make_shared<Servant3>(get_scheduler()));
boost::promise<boost::shared_ptr<Servant3>> p;
boost::future<boost::shared_ptr<Servant3>> fu = p.get_future();
p.set_value(s3);
return m_sink.foo(std::move(fu));
}
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;
}
void request_timeout(const util::duration& d) {
if (d.valid()) {
if (d.is_zero()) {
// immediately enqueue timeout
enqueue(nullptr, make_any_tuple(atom("TIMEOUT"),
++m_active_timeout_id));
}
else {
get_scheduler()->delayed_send(this, d, atom("TIMEOUT"),
++m_active_timeout_id);
}
m_has_pending_timeout_request = true;
}
else m_has_pending_timeout_request = false;
}
actor_ptr spawn_hidden(Args&&... args) {
auto ptr = detail::memory::create<ActorImpl>(std::forward<Args>(args)...);
return get_scheduler()->spawn(ptr, scheduled_and_hidden);
}
actor_ptr spawn_in_group(const group_ptr& grp, Args&&... args) {
return get_scheduler()->spawn(new ActorImpl(std::forward<Args>(args)...),
[&grp](local_actor* ptr) { ptr->join(grp); });
}
actor_ptr spawn(Args&&... args) {
return get_scheduler()->spawn(new ActorImpl(std::forward<Args>(args)...));
}
actor_ptr spawn(Args&&... args) {
return get_scheduler()->spawn(memory::create<impl>(m_init, m_on_exit,
std::forward<Args>(args)...));
}
actor_ptr spawn(Fun&& fun, Args&&... args) {
return get_scheduler()->spawn_impl(Hint,
std::forward<Fun>(fun),
std::forward<Args>(args)...);
}
void go(const char* name, Callable&& fn, Args&&... args)
{
assert(get_scheduler());
get_scheduler_check().go(std::string(name), std::forward<Callable>(fn), std::forward<Args>(args)...);
}
void delayed_reply_tuple(const util::duration& rtime,
message_id mid,
any_tuple data) {
message_header hdr{self, self->last_sender(), mid};
get_scheduler()->delayed_send(std::move(hdr), rtime, std::move(data));
}
inline void delayed_send_tuple(const channel_ptr& whom,
const std::chrono::duration<Rep,Period>& rtime,
any_tuple what) {
if (whom) get_scheduler()->delayed_send(whom, rtime, what);
}
TaskOptionsTestScheduler() : m_scheduler(get_scheduler()), m_numTasks(0)
{
}
actor_ptr spawn_hidden_in_group(const group_ptr& grp, Args&&... args) {
auto ptr = detail::memory::create<ActorImpl>(std::forward<Args>(args)...);
return get_scheduler()->spawn(ptr, [&](local_actor* p) { p->join(grp); },
scheduled_and_hidden);
}
virtual void schedule(pplx::TaskProc_t proc, void* param)
{
pplx::details::atomic_increment(m_numTasks);
get_scheduler()->schedule(proc, param);
}
