scoped_actor::scoped_actor(actor_system& sys, bool hide) : context_(&sys) {
actor_config cfg{&context_};
self_ = make_actor<impl, strong_actor_ptr>(sys.next_actor_id(), sys.node(),
&sys, cfg);
if (!hide)
prev_ = CAF_SET_AID(self_->id());
CAF_LOG_TRACE(CAF_ARG(hide));
if (!hide)
ptr()->register_at_system();
}
void caf_main(actor_system& system) {
// create one cell for each implementation
auto cell1 = system.spawn(type_checked_cell);
auto cell2 = system.spawn(unchecked_cell);
auto f = make_function_view(cell1);
cout << "cell value: " << f(get_atom::value) << endl;
f(put_atom::value, 20);
cout << "cell value (after setting to 20): " << f(get_atom::value) << endl;
// get an unchecked cell and send it some garbage
anon_send(cell2, "hello there!");
}
void actor_ostream::redirect_all(actor_system& sys, std::string fn, int flags) {
auto pr = sys.scheduler().printer();
pr->enqueue(make_mailbox_element(nullptr, message_id::make(), {},
redirect_atom::value,
std::move(fn), flags),
nullptr);
}
expected<ActorHandle> remote_actor(actor_system& sys, std::string host,
uint16_t port) {
detail::type_list<ActorHandle> tk;
auto res = remote_actor(sys, sys.message_types(tk), std::move(host), port);
if (res)
return actor_cast<ActorHandle>(std::move(*res));
return std::move(res.error());
}
/// Establish a new connection to the actor at `host` on given `port`.
/// @param host Valid hostname or IP address.
/// @param port TCP port.
/// @returns An `actor` to the proxy instance representing
/// a remote actor or an `error`.
expected<strong_actor_ptr> remote_actor(actor_system& sys,
const std::set<std::string>& mpi,
std::string host, uint16_t port) {
CAF_LOG_TRACE(CAF_ARG(mpi) << CAF_ARG(host) << CAF_ARG(port));
expected<strong_actor_ptr> res{strong_actor_ptr{nullptr}};
auto f = make_function_view(sys.openssl_manager().actor_handle());
auto x = f(connect_atom::value, std::move(host), port);
if (!x)
return std::move(x.error());
auto& tup = *x;
auto& ptr = get<1>(tup);
if (!ptr)
return sec::no_actor_published_at_port;
auto& found_mpi = get<2>(tup);
if (sys.assignable(found_mpi, mpi))
return std::move(ptr);
return sec::unexpected_actor_messaging_interface;
}
void caf_main(actor_system& sys, const config& cfg) {
auto& mm = sys.middleman();
auto self =sys.spawn(math);
if (cfg.server) {
auto p = mm.publish(self, cfg.port);
if (!p)
cerr << "unable to publish actor: " << sys.render(p.error()) << "\n";
else
cout << "math actor published at port " << *p << "\n";
} else {
auto x = mm.remote_actor(cfg.host, cfg.port);
if (!x)
cerr << "unable to connect to server: " << sys.render(x.error()) << "\n";
else {
//self->send(*x,1);
auto f = make_function_view(*x);
cout << "f('add', 4, 2) = " << f(add_atom::value, 4, 2) << "\n"
<< "f('sub', 4, 2) = " << f(sub_atom::value, 4, 2) << "\n"
<< "f('mul', 4, 2) = " << f(mul_atom::value, 4, 2) << "\n"
<< "f('div', 4, 2) = " << f(div_atom::value, 4, 2) << "\n"
<< "f('div', 1, 0) = " << f(div_atom::value, 1, 0) << "\n";
}
}
}
middleman_actor make_middleman_actor(actor_system& sys, actor db) {
return sys.config().middleman_detach_utility_actors
? sys.spawn<middleman_actor_impl, detached + hidden>(std::move(db))
: sys.spawn<middleman_actor_impl, hidden>(std::move(db));
}
deserializer::deserializer(actor_system& x) : super(x.dummy_execution_unit()) {
// nop
}
/// Tries to connect to given node.
/// @experimental
inline expected<node_id> connect(actor_system& sys, std::string host,
uint16_t port) {
return sys.middleman().connect(std::move(host), port);
}
