neurocyte/thespian
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor: run clang linter and formatter

Browse source
This commit is contained in:
CJ van den Berg 2025-01-20 18:21:54 +01:00
parent 7668befc06
commit 2dd2b9e087
Signed by: neurocyte
GPG key ID: 8EB1E1BB660E3FB9
27 changed files with 189 additions and 157 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/backtrace.cpp
View file

@ -8,6 +8,7 @@
#include <sys/wait.h>
#include <unistd.h>
namespace {
static void msg(const char *msg, const char *arg) {
if (write(STDERR_FILENO, msg, strlen(msg)) != 0) {
}
@ -46,7 +47,7 @@ static auto get_debugger() -> const char * {
}
const char *const debugger = get_debugger();
void start_debugger(const char * dbg, const char **argv) {
void start_debugger(const char *dbg, const char **argv) {
#if defined(PR_SET_PTRACER)
prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0); // NOLINT
#endif
@ -61,6 +62,7 @@ void start_debugger(const char * dbg, const char **argv) {
waitpid(child_pid, &stat, 0);
}
}
} // namespace
extern "C" void sighdl_debugger(int no, siginfo_t * /*sigi*/, void * /*uco*/) {
get_pid_binpath();
@ -73,14 +75,15 @@ extern "C" void sighdl_debugger(int no, siginfo_t * /*sigi*/, void * /*uco*/) {
extern "C" void sighdl_backtrace(int no, siginfo_t * /*sigi*/, void * /*uco*/) {
get_pid_binpath();
const char *argv[] = {// NOLINT
lldb, "--batch", "-p", pid_s,
lldb, "--batch", "-p", pid_s,
"--one-line", "bt", binpath, nullptr};
start_debugger(lldb, argv);
(void)raise(no);
}
namespace {
static void install_crash_handler(void (*hdlr)(int, siginfo_t *, void *)) {
struct sigaction action {};
struct sigaction action{};
sigemptyset(&action.sa_mask);
action.sa_flags = SA_SIGINFO | SA_RESETHAND;
#ifdef SA_FULLDUMP
@ -93,6 +96,7 @@ static void install_crash_handler(void (*hdlr)(int, siginfo_t *, void *)) {
sigaction(SIGTRAP, &action, nullptr);
sigaction(SIGFPE, &action, nullptr);
}
} // namespace
extern "C" void install_debugger() { install_crash_handler(sighdl_debugger); }
extern "C" void install_backtrace() { install_crash_handler(sighdl_backtrace); }

1
src/c/handle.cpp
View file

@ -66,5 +66,4 @@ auto thespian_handle_is_expired(thespian_handle h) -> bool {
h)};
return h_->expired();
}
}

6
src/c/metronome.cpp
View file

@ -14,8 +14,7 @@ using thespian::stop_metronome;
extern "C" {
auto thespian_metronome_create_ms(uint64_t ms)
-> thespian_metronome_handle * {
auto thespian_metronome_create_ms(uint64_t ms) -> thespian_metronome_handle * {
try {
auto *handle = thespian::create_metronome(milliseconds(ms)).ref.release();
return reinterpret_cast<thespian_metronome_handle *>(handle); // NOLINT
@ -27,8 +26,7 @@ auto thespian_metronome_create_ms(uint64_t ms)
return nullptr;
}
}
auto thespian_metronome_create_us(uint64_t us)
-> thespian_metronome_handle * {
auto thespian_metronome_create_us(uint64_t us) -> thespian_metronome_handle * {
try {
auto *handle = thespian::create_metronome(microseconds(us)).ref.release();
return reinterpret_cast<thespian_metronome_handle *>(handle); // NOLINT

1
src/c/trace.cpp
View file

@ -18,5 +18,4 @@ void thespian_trace_to_cbor_file(const char *file_name) {
void thespian_trace_to_mermaid_file(const char *file_name) {
thespian::trace_to_mermaid_file(file_name);
}
}

25
src/cbor.cpp
View file

@ -71,6 +71,7 @@ auto buffer::push_string(const string_view &s) -> buffer & {
using json_iter = string::const_iterator;
namespace {
static auto match_wsp_char(json_iter &b, const json_iter &e) -> bool {
if (b == e)
return false;
@ -347,6 +348,7 @@ static auto push_json_value(buffer &buf, json_iter &b, const json_iter &e)
return false;
}
} // namespace
auto buffer::push_json(const string &s) -> void {
json_iter b = s.cbegin();
@ -360,6 +362,7 @@ auto buffer::push_json(const string &s) -> void {
using iter = buffer::const_iterator;
namespace {
static auto decode_int_length_recurse(size_t length, iter &b, const iter &e,
int64_t i) -> int64_t {
if (b == e)
@ -426,6 +429,7 @@ static auto decode_type(iter &b, const iter &e)
++b;
return make_tuple(uint8_t(type >> 5), uint8_t(type & 31), type);
}
} // namespace
auto buffer::decode_range_header(iter &b, const iter &e) -> size_t {
const auto [major, minor, type] = decode_type(b, e);
@ -460,6 +464,7 @@ auto buffer::decode_map_header(iter &b, const iter &e) -> size_t {
return decode_pint(minor, b, e);
}
namespace {
static auto skip_string(uint8_t type, iter &b, const iter &e) -> void {
auto len = decode_pint(type, b, e);
while (len) {
@ -559,6 +564,7 @@ static auto match_type(iter &b, const iter &e, type &v) -> bool {
}
return true;
}
} // namespace
auto buffer::match_value(iter &b, const iter &e, type t) -> bool {
type v{type::any};
@ -570,6 +576,7 @@ auto buffer::match_value(iter &b, const iter &e, type t) -> bool {
return false;
}
namespace {
static auto match_uint(iter &b, const iter &e, unsigned long long int &val)
-> bool {
const auto [major, minor, type] = decode_type(b, e);
@ -596,6 +603,7 @@ static auto match_int(iter &b, const iter &e, signed long long int &val)
}
return true;
}
} // namespace
auto buffer::match_value(iter &b, const iter &e, unsigned long long int lit)
-> bool {
@ -613,6 +621,7 @@ auto buffer::match_value(iter &b, const iter &e, signed long long int lit)
return false;
}
namespace {
static auto match_bool(iter &b, const iter &e, bool &v) -> bool {
const auto [major, minor, type] = decode_type(b, e);
if (major == 7) { // special
@ -627,6 +636,7 @@ static auto match_bool(iter &b, const iter &e, bool &v) -> bool {
}
return false;
}
} // namespace
auto buffer::match_value(iter &b, const iter &e, bool lit) -> bool {
bool val{};
@ -635,6 +645,7 @@ auto buffer::match_value(iter &b, const iter &e, bool lit) -> bool {
return false;
}
namespace {
static auto match_string(iter &b, const iter &e, string_view &val) -> bool {
const auto [major, minor, type] = decode_type(b, e);
switch (major) {
@ -649,6 +660,7 @@ static auto match_string(iter &b, const iter &e, string_view &val) -> bool {
}
return true;
}
} // namespace
auto buffer::match_value(iter &b, const iter &e, const string_view lit)
-> bool {
@ -669,6 +681,7 @@ auto extract(type &t) -> buffer::extractor {
return [&t](iter &b, const iter &e) { return match_type(b, e, t); };
}
namespace {
template <typename T> static auto extract_int(T &i) -> buffer::extractor {
return [&i](iter &b, const iter &e) {
signed long long int i_{};
@ -681,6 +694,8 @@ template <typename T> static auto extract_int(T &i) -> buffer::extractor {
return false;
};
}
} // namespace
// clang-format off
auto extract(signed long long int &i) -> buffer::extractor { return extract_int(i); }
auto extract(signed long int &i) -> buffer::extractor { return extract_int(i); }
@ -692,6 +707,7 @@ auto extract(signed char &i) -> buffer::extractor { return extract_int(i); }
auto extract(unsigned long long int &i) -> buffer::extractor {
return [&i](iter &b, const iter &e) { return match_uint(b, e, i); };
}
namespace {
template <typename T> static auto extract_uint(T &i) -> buffer::extractor {
return [&i](iter &b, const iter &e) {
unsigned long long int i_{};
@ -704,6 +720,7 @@ template <typename T> static auto extract_uint(T &i) -> buffer::extractor {
return false;
};
}
} // namespace
// clang-format off
auto extract(unsigned long int &i) -> buffer::extractor { return extract_uint(i); }
auto extract(unsigned int &i) -> buffer::extractor { return extract_uint(i); }
@ -748,6 +765,7 @@ auto buffer::match_value(iter &b, const iter &e, const extractor &ex) -> bool {
return ex(b, e);
}
namespace {
static auto tohex(ostream &os, uint8_t v) -> ostream & {
return os << hex << setfill('0') << setw(2) << static_cast<unsigned>(v);
}
@ -866,6 +884,7 @@ static auto to_json_(const iter &b_, const iter &e) -> string {
}
return ss.str();
}
} // namespace
auto buffer::to_json() const -> string {
return to_json_(raw_cbegin(), raw_cend());
@ -885,8 +904,8 @@ auto buffer::range::to_json(ostream &os) const -> void {
extern "C" void cbor_to_json(cbor_buffer buf, cbor_to_json_callback cb) {
auto cbor = cbor::buffer();
const uint8_t *data = buf.base;
std::copy(data, data + buf.len,
back_inserter(cbor)); // NOLINT(*-pointer-arithmetic)
std::copy(data, data + buf.len, // NOLINT(*-pointer-arithmetic)
back_inserter(cbor));
auto json = cbor.to_json();
cb({json.data(), json.size()});
}
@ -909,11 +928,13 @@ auto buffer::value_accessor::type_() const -> type {
return t;
}
namespace {
template <typename T> static auto get(iter b, const iter &e) -> T {
T val;
extract(val)(b, e);
return val;
}
} // namespace
// clang-format off
buffer::value_accessor::operator type() const { return get<type>(b, e); }

16
src/executor_asio.cpp
View file

@ -481,11 +481,11 @@ namespace unx {
struct socket_impl {
explicit socket_impl(strand &strand)
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_}, socket_{
*ctx->asio} {}
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_},
socket_{*ctx->asio} {}
explicit socket_impl(strand &strand, int fd)
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_}, socket_{*ctx->asio,
fd} {}
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_},
socket_{*ctx->asio, fd} {}
auto bind(string_view path) -> error_code {
error_code ec;
ec = socket_.bind(path, ec);
@ -615,8 +615,8 @@ namespace file_descriptor {
struct watcher_impl {
explicit watcher_impl(strand &strand, int fd)
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_}, fd_{*ctx->asio,
fd} {}
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_},
fd_{*ctx->asio, fd} {}
void wait_read(watcher::handler h) {
if (!read_in_progress_) {
@ -680,8 +680,8 @@ struct file_stream_impl {
explicit file_stream_impl(
strand &strand,
const asio::windows::stream_handle::native_handle_type &handle)
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_}, handle_{*ctx->asio,
handle} {}
: ctx{strand.ref->ctx}, strand_{strand.ref->strand_},
handle_{*ctx->asio, handle} {}
void start_read(file_stream::read_handler h) {
if (!read_in_progress_) {

2
src/hub.cpp
View file

@ -91,7 +91,7 @@ struct hub_impl {
set<string> msgs;
for (const auto val : r)
msgs.insert(string(val));
subscribers_.emplace_back(move(from), [msgs](auto m) {
subscribers_.emplace_back(move(from), [msgs](const auto &m) {
string tag;
return m(extract(tag), more) && (msgs.find(tag) != msgs.end());
});

161
src/instance.cpp
View file

@ -108,9 +108,11 @@ struct context_impl : context {
};
thread_local instance *current_instance{}; // NOLINT
namespace {
auto impl(context &ctx) -> context_impl & {
return *reinterpret_cast<context_impl *>(&ctx); // NOLINT
}
} // namespace
auto context::create() -> ref {
return {new context_impl{executor::context::create()}, context_impl::destroy};
@ -129,10 +131,12 @@ void context::on_last_exit(last_exit_handler h) {
namespace debug {
namespace {
void register_instance(context_impl &ctx, const handle &h);
void unregister_instance(context_impl &ctx, const string &name);
auto get_name(context_impl &ctx, const string &name) -> handle;
auto get_names(context_impl &ctx) -> buffer;
} // namespace
} // namespace debug
@ -147,6 +151,7 @@ constexpr auto context_error = "call out of context";
auto handle_ref(handle &h) -> ref & { return h.ref_; }
auto handle_ref(const handle &h) -> const ref & { return h.ref_; }
namespace {
auto make_handle(ref &&r) -> handle {
handle h{};
handle_ref(h) = move(r);
@ -159,12 +164,13 @@ template <typename... Ts> auto exit_message(string_view e, Ts &&...parms) {
return buffer(array("exit", e, forward<Ts>(parms)...));
}
[[nodiscard]] auto exit() -> result { return to_error(exit_message("normal")); }
template <typename... Ts>
[[nodiscard]] auto exit(std::string_view e, Ts &&...parms) -> result {
return to_error(exit_message(e, std::forward<Ts>(parms)...));
}
} // namespace
[[nodiscard]] auto exit() -> result { return to_error(exit_message("normal")); }
[[nodiscard]] auto exit(std::string_view e) -> result {
return to_error(exit_message(e));
@ -186,7 +192,9 @@ template <typename... Ts>
return exit("UNEXPECTED_MESSAGE:" + b.to_json());
}
namespace {
auto deadsend(const buffer &m, const ref &from) -> result;
} // namespace
const auto exit_normal_msg = array("exit", "normal");
const auto exit_noreceive_msg = array("exit", "noreceive");
const auto exit_nosyncreceive_msg = array("exit", "nosyncreceive");
@ -221,7 +229,7 @@ struct instance : std::enable_shared_from_this<instance> {
env_(move(env)) {
if (eh)
exit_handlers_.emplace_front(eh);
receiver_ = [this, b{move(b)}](auto, auto) {
receiver_ = [this, b{move(b)}](const auto &, const auto &) {
this->do_trace(channel::lifetime, "init");
receiver b_;
b_.swap(receiver_);
@ -245,8 +253,8 @@ struct instance : std::enable_shared_from_this<instance> {
}
static auto spawn(context_impl &ctx, behaviour b, exit_handler eh,
string_view name, const ref &link,
env_t env) -> expected<handle, error> {
string_view name, const ref &link, env_t env)
-> expected<handle, error> {
auto pimpl = make_shared<instance>(ctx, move(b), move(eh), name, move(env));
pimpl->lifetime_ = pimpl;
handle_ref(pimpl->self_ref_) = pimpl->lifetime_;
@ -316,7 +324,7 @@ struct instance : std::enable_shared_from_this<instance> {
auto trace_enabled(channel c) { return env_.enabled(c); }
template <class F> void submit_msg_task(F f) {
strand_.post(msg_task_T<F>(f));
strand_.post(msg_task_T<F>(move(f)));
}
[[nodiscard]] auto dispatch_sync_raw(buffer m) -> result {
@ -447,8 +455,8 @@ struct instance : std::enable_shared_from_this<instance> {
return send_raw(array(std::forward<Ts>(parms)...));
}
auto spawn_link(behaviour b, string_view name,
env_t env) -> expected<handle, error> {
auto spawn_link(behaviour b, string_view name, env_t env)
-> expected<handle, error> {
auto ret = instance::spawn(ctx, move(b), exit_handler{}, name, lifetime_,
move(env));
if (not ret)
@ -497,6 +505,7 @@ struct instance : std::enable_shared_from_this<instance> {
env_t env_;
};
namespace {
auto deadsend(const buffer &m, const ref &from) -> result {
if (current_instance and !current_instance->is_in_shutdown() and
!m("exit", type::more)) {
@ -505,6 +514,7 @@ auto deadsend(const buffer &m, const ref &from) -> result {
}
return ok();
}
} // namespace
[[nodiscard]] auto handle::send_raw(buffer m) const -> result {
if (auto p = ref_.lock()) {
@ -517,6 +527,7 @@ auto operator==(const handle &a, const handle &b) -> bool {
return a.ref_.lock() == b.ref_.lock();
}
namespace {
auto ref_m(const void *p, string name) -> buffer {
stringstream ss;
ss << p;
@ -530,7 +541,9 @@ auto ref_m(const ref &r) -> buffer {
return ref_m(p.get(), p->name());
return ref_m(nullptr, "none");
}
} // namespace
namespace {
auto private_call() -> instance & {
if (!current_instance)
throw domain_error{context_error};
@ -544,6 +557,7 @@ auto private_call_noexcept() noexcept -> instance * {
}
auto trace_enabled(channel c) { return private_call().env_.enabled(c); }
} // namespace
auto spawn(behaviour b, string_view name) -> expected<handle, error> {
auto &p = private_call();
@ -551,15 +565,15 @@ auto spawn(behaviour b, string_view name) -> expected<handle, error> {
p.env_);
}
auto spawn(behaviour b, string_view name,
env_t env) -> expected<handle, error> {
auto spawn(behaviour b, string_view name, env_t env)
-> expected<handle, error> {
auto &p = private_call();
return instance::spawn(p.ctx, move(b), exit_handler{}, name, thespian::ref{},
move(env));
}
auto context::spawn(behaviour b, string_view name,
env_t env) -> expected<handle, error> {
auto context::spawn(behaviour b, string_view name, env_t env)
-> expected<handle, error> {
return instance::spawn(impl(*this), move(b), exit_handler{}, name,
thespian::ref{}, move(env));
}
@ -577,8 +591,8 @@ auto context::spawn_link(behaviour b, exit_handler eh, string_view name,
move(env));
}
auto context::spawn_link(behaviour b, exit_handler eh,
string_view name) -> expected<handle, error> {
auto context::spawn_link(behaviour b, exit_handler eh, string_view name)
-> expected<handle, error> {
return spawn_link(move(b), move(eh), name, env_t{});
}
@ -588,8 +602,8 @@ auto self_ref() -> handle & { return private_call().self_ref_; }
auto spawn_link(behaviour b, string_view name) -> expected<handle, error> {
return private_call().spawn_link(move(b), name);
}
auto spawn_link(behaviour b, string_view name,
env_t env) -> expected<handle, error> {
auto spawn_link(behaviour b, string_view name, env_t env)
-> expected<handle, error> {
return private_call().spawn_link(move(b), name, move(env));
}
auto send_raw(buffer m) -> result { return private_call().send_raw(move(m)); }
@ -603,12 +617,6 @@ auto on_trace(trace_handler h) -> trace_handler {
return private_call().env_.on_trace(move(h));
}
auto get_strand(const handle &h) -> executor::strand * {
if (auto p = handle_ref(h).lock())
return &p->strand_;
return nullptr;
}
struct signal_impl {
signal_impl(const signal_impl &) = delete;
signal_impl(signal_impl &&) = delete;
@ -827,8 +835,8 @@ struct udp_impl {
}
}
[[nodiscard]] auto sendto(string_view data, in6_addr ip,
port_t port) -> size_t {
[[nodiscard]] auto sendto(string_view data, in6_addr ip, port_t port)
-> size_t {
if (is_trace_enabled_)
owner_.env_.trace(
array("udp", tag_, "sendto", data, executor::to_string(ip), port));
@ -868,8 +876,8 @@ auto udp::create(string tag) -> udp {
struct file_descriptor_impl {
file_descriptor_impl(const file_descriptor_impl &) = delete;
file_descriptor_impl(file_descriptor_impl &&) = delete;
auto
operator=(const file_descriptor_impl &) -> file_descriptor_impl & = delete;
auto operator=(const file_descriptor_impl &)
-> file_descriptor_impl & = delete;
auto operator=(file_descriptor_impl &&) -> file_descriptor_impl & = delete;
file_descriptor_impl(string_view tag, int fd)
@ -1263,16 +1271,7 @@ void connector::cancel() { ref->cancel(); }
namespace unx {
auto unx_mode_string(mode m) -> const char * {
switch (m) {
case mode::file:
return "file";
case mode::abstract:
return "abstract";
}
return "unknown";
}
namespace {
auto unx_mode_path(mode m, string_view path) -> string {
switch (m) {
case mode::file:
@ -1285,6 +1284,7 @@ auto unx_mode_path(mode m, string_view path) -> string {
}
return "unknown";
}
} // namespace
struct acceptor_impl {
explicit acceptor_impl(string_view tag)
@ -1498,16 +1498,16 @@ struct connection {
return ok();
}
static auto start(int fd, const handle &owner,
const char *tag) -> expected<handle, error> {
static auto start(int fd, const handle &owner, const char *tag)
-> expected<handle, error> {
return spawn(
[fd, owner, tag]() {
link(owner);
trap(true);
::thespian::receive(
[p{make_shared<connection>(fd, owner, tag)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<connection>(fd, owner, tag)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -1516,9 +1516,8 @@ struct connection {
static void attach(int fd, handle owner, const char *tag) {
private_call().name_ = tag;
::thespian::receive(
[p{make_shared<connection>(fd, owner, tag)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
[p{make_shared<connection>(fd, owner, tag)}](
const auto &from, const auto &m) { return p->receive(from, m); });
}
};
@ -1579,11 +1578,11 @@ struct connector {
return spawn_link(
[=]() {
trap(true);
::thespian::receive(
[p{make_shared<connector>(ip, port, owner, retry_time,
retry_count)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<connector>(
ip, port, owner, retry_time, retry_count)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -1633,10 +1632,10 @@ struct acceptor {
return spawn_link(
[=]() {
trap(true);
::thespian::receive(
[p{make_shared<acceptor>(ip, port, owner)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<acceptor>(ip, port, owner)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -1714,11 +1713,11 @@ struct connector {
return spawn_link(
[path{string(path)}, m_, owner, retry_time, retry_count]() {
trap(true);
::thespian::receive(
[p{make_shared<connector>(path, m_, owner, retry_time,
retry_count)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<connector>(
path, m_, owner, retry_time, retry_count)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -1770,10 +1769,10 @@ struct acceptor {
return spawn_link(
[path{string(path)}, m_, owner]() {
trap(true);
::thespian::receive(
[p{make_shared<acceptor>(path, m_, owner)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<acceptor>(path, m_, owner)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -1794,14 +1793,19 @@ auto connect(string_view path, mode m, milliseconds retry_time,
namespace debug {
namespace {
void enable(context_impl &ctx) {
ctx.debug_enabled.fetch_add(1, memory_order_relaxed);
}
} // namespace
void enable(context &ctx) { enable(impl(ctx)); }
namespace {
auto isenabled(context_impl &ctx) -> bool {
return ctx.debug_enabled.load(memory_order_relaxed) > 0;
}
} // namespace
auto isenabled(context &ctx) -> bool { return isenabled(impl(ctx)); }
namespace {
void disable(context_impl &ctx) {
auto prev = ctx.debug_enabled.fetch_sub(1, memory_order_relaxed);
if (prev == 1) {
@ -1809,8 +1813,10 @@ void disable(context_impl &ctx) {
ctx.registry.clear();
}
}
} // namespace
void disable(context &ctx) { disable(impl(ctx)); }
namespace {
void register_instance(context_impl &ctx, const handle &h) {
if (not isenabled(ctx))
return;
@ -1856,6 +1862,7 @@ auto get_names(context_impl &ctx) -> buffer {
}
return b;
}
} // namespace
namespace tcp {
@ -1994,14 +2001,14 @@ struct connection {
return ok();
}
static auto start(context_impl &ctx, int fd,
const string &prompt) -> expected<handle, error> {
static auto start(context_impl &ctx, int fd, const string &prompt)
-> expected<handle, error> {
return spawn(
[&ctx, fd, prompt]() {
::thespian::receive(
[p{make_shared<connection>(ctx, fd, prompt)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<connection>(ctx, fd, prompt)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
@ -2051,22 +2058,22 @@ struct acceptor {
return ok();
}
static auto start(context_impl &ctx, port_t port,
const string &prompt) -> expected<handle, error> {
static auto start(context_impl &ctx, port_t port, const string &prompt)
-> expected<handle, error> {
return spawn(
[&ctx, port, prompt]() {
::thespian::receive(
[p{make_shared<acceptor>(ctx, port, prompt)}](auto from, auto m) {
return p->receive(move(from), move(m));
});
::thespian::receive([p{make_shared<acceptor>(ctx, port, prompt)}](
const auto &from, const auto &m) {
return p->receive(from, m);
});
return ok();
},
tag);
}
};
auto create(context &ctx, port_t port,
const string &prompt) -> expected<handle, error> {
auto create(context &ctx, port_t port, const string &prompt)
-> expected<handle, error> {
return acceptor::start(impl(ctx), port, prompt);
}

2
src/trace.cpp
View file

@ -91,6 +91,7 @@ template <typename T, typename Q> struct trace_file {
}
};
namespace {
auto to_mermaid(ostream &s, const buffer &m) -> void {
string_view from;
string_view typ;
@ -124,6 +125,7 @@ auto to_mermaid(ostream &s, const buffer &m) -> void {
s << " Note right of " << from << ": EXIT " << msg << '\n';
}
}
} // namespace
static const auto cbor_cr = array("\n");