/* Process a command packet that entered on a TLS pool socket
*/
static void process_command (struct command *cmd) {
tlog (TLOG_UNIXSOCK, LOG_DEBUG, "Processing command 0x%08x", cmd->cmd.pio_cmd);
union pio_data *d = &cmd->cmd.pio_data;
if (is_callback (cmd)) {
post_callback (cmd);
return;
}
switch (cmd->cmd.pio_cmd) {
case PIOC_PING_V1:
strcpy (d->pioc_ping.YYYYMMDD_producer, TLSPOOL_IDENTITY_V1);
send_command (cmd, -1);
return;
case PIOC_STARTTLS_CLIENT_V1:
starttls_client (cmd);
return;
case PIOC_STARTTLS_SERVER_V1:
starttls_server (cmd);
return;
case PIOC_PINENTRY_V1:
register_pinentry_command (cmd);
return;
default:
send_error (cmd, ENOSYS, "Command not implemented");
return;
}
}
void Transform::post_body_part(Body_part* in, Body_part_list* out)
{
switch(in->classid())
{
case C_CODE::ID:
{
Body_part_list* local_out = new Body_part_list;
Body_part_list::const_iterator i;
post_c_code(dynamic_cast<C_CODE*>(in), local_out);
for(i = local_out->begin(); i != local_out->end(); i++)
out->push_back(*i);
}
return;
case Lookup::ID:
out->push_back(post_lookup(dynamic_cast<Lookup*>(in)));
return;
case PARAM_NAME::ID:
out->push_back(post_param_name(dynamic_cast<PARAM_NAME*>(in)));
return;
case Macro_call::ID:
out->push_back(post_macro_call(dynamic_cast<Macro_call*>(in)));
return;
case Callback::ID:
out->push_back(post_callback(dynamic_cast<Callback*>(in)));
return;
}
assert(0);
}
Expr* Transform::post_expr(Expr* in)
{
switch(in->classid())
{
case Param::ID: return post_param(dynamic_cast<Param*>(in));
case STRING::ID: return post_string(dynamic_cast<STRING*>(in));
case Lookup::ID: return post_lookup(dynamic_cast<Lookup*>(in));
case Macro_call::ID: return post_macro_call(dynamic_cast<Macro_call*>(in));
case Callback::ID: return post_callback(dynamic_cast<Callback*>(in));
}
assert(0);
}
std::future<void> foo()
{
std::future<void> fu = m_promise->get_future();
auto fn = [](long long const& i)
{
long long& j = const_cast<long long&>(i);
long long k = j;
for (int m = 0; m < EXPONENT; ++m) {
j = (j * k) % MOD;
}
};
auto reduction = [](long long const& a, long long const& b) {
return (a + b) % MOD;
};
post_callback(
[this, fn, reduction]() mutable {
// Capturing 'this' is evil, but we'll do it anyways, because this is just a test.
// Also, if everything works, the servant is guaranteed to stay alive until the callback finishes.
// With C++14, we would instead capture [data=std::move(this->m_data), fn=std::move(fn), reduction=std::move(reduction)]
auto continuation = boost::asynchronous::parallel_for<decltype(this->m_data),
decltype(fn),
job>(
std::move(this->m_data),
std::move(fn),
8192,
"parallel_for",
0);
return boost::asynchronous::parallel_reduce<decltype(continuation),
decltype(reduction),
job>(
std::move(continuation),
std::move(reduction),
8192,
"parallel_reduce",
0);
},
[this](boost::asynchronous::expected<long long> res){
this->on_callback(res.get());
},
"foo",
0,
0
);
return fu;
}
