forstio
/
forstio
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

executed clang-tidy once

fb-mini-snake
Claudius Holeksa 2022-12-18 16:38:41 +01:00
parent 03d8924cf4
commit 32aa36a43d
14 changed files with 430 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
.clang-tidy
View File

@ -1,26 +1,4 @@
Checks: '-*,clang-analyzer-*,clang-analyzer-cplusplus*,readability-identifier-naming'
Checks: '-*,readability-identifier-naming'
CheckOptions:
- { key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true }
- { key: readability-identifier-naming.NamespaceCase, value: lower_case }
- { key: readability-identifier-naming.EnumCase, value: lower_case }
- { key: readability-identifier-naming.ConstexprFunctionCase, value: lower_case }
- { key: readability-identifier-naming.ConstexprMethodCase, value: lower_case }
- { key: readability-identifier-naming.ConstexprVariableCase, value: lower_case }
- { key: readability-identifier-naming.EnumConstantCase, value: lower_case }
- { key: readability-identifier-naming.ScopedEnumConstantCase, value: lower_case }
- { key: readability-identifier-naming.AbstractClassCase, value: lower_case }
- { key: readability-identifier-naming.ClassCase, value: lower_case }
- { key: readability-identifier-naming.ClassMethod, value: lower_case }
- { key: readability-identifier-naming.VirtualMethodCase, value: lower_case }
- { key: readability-identifier-naming.MemberCase, value: lower_case }
- { key: readability-identifier-naming.TemplateParameterCase, value: CamelCase }
- { key: readability-identifier-naming.ValueTemplateParameterCase, value: lower_case }
- { key: readability-identifier-naming.TypeTemplateParameterCase, value: CamelCase }
- { key: readability-identifier-naming.StructCase, value: CamelCase }
- { key: readability-identifier-naming.FunctionCase, value: lower_case }
- { key: readability-identifier-naming.ParameterCase, value: lower_case }
- { key: readability-identifier-naming.TypeAliasCase, value: lower_case }
- { key: readability-identifier-naming.VariableCase, value: lower_case }
- { key: readability-identifier-naming.PrivateMemberCase, value: lower_case }
- { key: readability-identifier-naming.PrivateMemberSuffix, value: '_' }
- { key: readability-identifier-naming.ProtectedMemberSuffix, value: '_' }
- { key: readability-identifier-naming.PrivateMemberSuffix, value: "_" }
- { key: readability-identifier-naming.ProtectedMemberSuffix, value: "_" }

2
SConstruct
View File

@ -82,7 +82,7 @@ env.tidy_actions = []
def tidy_iter(env,files):
string_of_files = "";
for f in files:
if(f != "/home/keldu/workspace/forstio/source/forstio/async.tmpl.h" or f != "/home/keldu/workspace/forstio/forstio/source/forstio/io_peer.tmpl.h" ):
if(f != "/home/keldu/workspace/forstio/source/forstio/async.tmpl.h" and f != "/home/keldu/workspace/forstio/forstio/source/forstio/io_peer.tmpl.h" ):
string_of_files = string_of_files + " " + f;
# env.tidy_actions.append(env.AlwaysBuild(env.ClangTidyFix(target=f+"-clang-tidy-fix",source=f)));
print(string_of_files);

132
driver/io-unix.h
View File

@ -35,12 +35,12 @@ constexpr int MAX_EPOLL_EVENTS = 256;
class UnixEventPort;
class IFdOwner {
protected:
UnixEventPort &event_port;
UnixEventPort &event_port_;
private:
int file_descriptor;
int fd_flags;
uint32_t event_mask;
int file_descriptor_;
int fd_flags_;
uint32_t event_mask_;
public:
IFdOwner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
@ -50,19 +50,19 @@ public:
virtual void notify(uint32_t mask) = 0;
int fd() const { return file_descriptor; }
int fd() const { return file_descriptor_; }
};
class UnixEventPort final : public EventPort {
private:
int epoll_fd;
int signal_fd;
int epoll_fd_;
int signal_fd_;
sigset_t signal_fd_set;
sigset_t signal_fd_set_;
std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>> signal_conveyors;
std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>> signal_conveyors_;
int pipefds[2];
int pipefds_[2];
std::vector<int> toUnixSignal(Signal signal) const {
switch (signal) {
@ -89,7 +89,7 @@ private:
void notifySignalListener(int sig) {
Signal signal = fromUnixSignal(sig);
auto equal_range = signal_conveyors.equal_range(signal);
auto equal_range = signal_conveyors_.equal_range(signal);
for (auto iter = equal_range.first; iter != equal_range.second;
++iter) {
@ -105,7 +105,7 @@ private:
epoll_event events[MAX_EPOLL_EVENTS];
int nfds = 0;
do {
nfds = epoll_wait(epoll_fd, events, MAX_EPOLL_EVENTS, time);
nfds = epoll_wait(epoll_fd_, events, MAX_EPOLL_EVENTS, time);
if (nfds < 0) {
/// @todo error_handling
@ -117,7 +117,7 @@ private:
while (1) {
struct ::signalfd_siginfo siginfo;
ssize_t n =
::read(signal_fd, &siginfo, sizeof(siginfo));
::read(signal_fd_, &siginfo, sizeof(siginfo));
if (n < 0) {
break;
}
@ -127,11 +127,11 @@ private:
}
} else if (events[i].data.u64 == 1) {
uint8_t i;
if (pipefds[0] < 0) {
if (pipefds_[0] < 0) {
continue;
}
while (1) {
ssize_t n = ::recv(pipefds[0], &i, sizeof(i), 0);
ssize_t n = ::recv(pipefds_[0], &i, sizeof(i), 0);
if (n < 0) {
break;
}
@ -150,17 +150,17 @@ private:
}
public:
UnixEventPort() : epoll_fd{-1}, signal_fd{-1} {
UnixEventPort() : epoll_fd_{-1}, signal_fd_{-1} {
::signal(SIGPIPE, SIG_IGN);
epoll_fd = ::epoll_create1(EPOLL_CLOEXEC);
if (epoll_fd < 0) {
epoll_fd_ = ::epoll_create1(EPOLL_CLOEXEC);
if (epoll_fd_ < 0) {
return;
}
::sigemptyset(&signal_fd_set);
signal_fd = ::signalfd(-1, &signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
if (signal_fd < 0) {
::sigemptyset(&signal_fd_set_);
signal_fd_ = ::signalfd(-1, &signal_fd_set_, SFD_NONBLOCK | SFD_CLOEXEC);
if (signal_fd_ < 0) {
return;
}
@ -168,37 +168,37 @@ public:
memset(&event, 0, sizeof(event));
event.events = EPOLLIN;
event.data.u64 = 0;
::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, signal_fd, &event);
::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, signal_fd_, &event);
int rc = ::pipe2(pipefds, O_NONBLOCK | O_CLOEXEC);
int rc = ::pipe2(pipefds_, O_NONBLOCK | O_CLOEXEC);
if (rc < 0) {
return;
}
memset(&event, 0, sizeof(event));
event.events = EPOLLIN;
event.data.u64 = 1;
::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipefds[0], &event);
::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, pipefds_[0], &event);
}
~UnixEventPort() {
::close(epoll_fd);
::close(signal_fd);
::close(pipefds[0]);
::close(pipefds[1]);
::close(epoll_fd_);
::close(signal_fd_);
::close(pipefds_[0]);
::close(pipefds_[1]);
}
Conveyor<void> onSignal(Signal signal) override {
auto caf = newConveyorAndFeeder<void>();
signal_conveyors.insert(std::make_pair(signal, std::move(caf.feeder)));
signal_conveyors_.insert(std::make_pair(signal, std::move(caf.feeder)));
std::vector<int> sig = toUnixSignal(signal);
for (auto iter = sig.begin(); iter != sig.end(); ++iter) {
::sigaddset(&signal_fd_set, *iter);
::sigaddset(&signal_fd_set_, *iter);
}
::sigprocmask(SIG_BLOCK, &signal_fd_set, nullptr);
::signalfd(signal_fd, &signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
::sigprocmask(SIG_BLOCK, &signal_fd_set_, nullptr);
::signalfd(signal_fd_, &signal_fd_set_, SFD_NONBLOCK | SFD_CLOEXEC);
auto node = Conveyor<void>::fromConveyor(std::move(caf.conveyor));
return Conveyor<void>::toConveyor(std::move(node));
@ -227,15 +227,15 @@ public:
void wake() override {
/// @todo pipe() in the beginning and write something minor into it like
/// uint8_t or sth the value itself doesn't matter
if (pipefds[1] < 0) {
if (pipefds_[1] < 0) {
return;
}
uint8_t i = 0;
::send(pipefds[1], &i, sizeof(i), MSG_DONTWAIT);
::send(pipefds_[1], &i, sizeof(i), MSG_DONTWAIT);
}
void subscribe(IFdOwner &owner, int fd, uint32_t event_mask) {
if (epoll_fd < 0 || fd < 0) {
if (epoll_fd_ < 0 || fd < 0) {
return;
}
::epoll_event event;
@ -243,17 +243,17 @@ public:
event.events = event_mask | EPOLLET;
event.data.ptr = &owner;
if (::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event) < 0) {
if (::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &event) < 0) {
/// @todo error_handling
return;
}
}
void unsubscribe(int fd) {
if (epoll_fd < 0 || fd < 0) {
if (epoll_fd_ < 0 || fd < 0) {
return;
}
if (::epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, nullptr) < 0) {
if (::epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr) < 0) {
/// @todo error_handling
return;
}
@ -265,9 +265,9 @@ ssize_t unixWrite(int fd, const void *buffer, size_t length);
class UnixIoStream final : public IoStream, public IFdOwner {
private:
Own<ConveyorFeeder<void>> read_ready = nullptr;
Own<ConveyorFeeder<void>> on_read_disconnect = nullptr;
Own<ConveyorFeeder<void>> write_ready = nullptr;
Own<ConveyorFeeder<void>> read_ready_ = nullptr;
Own<ConveyorFeeder<void>> on_read_disconnect_ = nullptr;
Own<ConveyorFeeder<void>> write_ready_ = nullptr;
public:
UnixIoStream(UnixEventPort &event_port, int file_descriptor, int fd_flags,
@ -300,7 +300,7 @@ public:
class UnixServer final : public Server, public IFdOwner {
private:
Own<ConveyorFeeder<Own<IoStream>>> accept_feeder = nullptr;
Own<ConveyorFeeder<Own<IoStream>>> accept_feeder_ = nullptr;
public:
UnixServer(UnixEventPort &event_port, int file_descriptor, int fd_flags);
@ -312,8 +312,8 @@ public:
class UnixDatagram final : public Datagram, public IFdOwner {
private:
Own<ConveyorFeeder<void>> read_ready = nullptr;
Own<ConveyorFeeder<void>> write_ready = nullptr;
Own<ConveyorFeeder<void>> read_ready_ = nullptr;
Own<ConveyorFeeder<void>> write_ready_ = nullptr;
public:
UnixDatagram(UnixEventPort &event_port, int file_descriptor, int fd_flags);
@ -339,43 +339,43 @@ private:
struct sockaddr_in inet;
struct sockaddr_in6 inet6;
struct sockaddr_storage storage;
} address;
} address_;
socklen_t address_length;
bool wildcard;
socklen_t address_length_;
bool wildcard_;
SocketAddress() : wildcard{false} {}
SocketAddress() : wildcard_{false} {}
public:
SocketAddress(const void *sockaddr, socklen_t len, bool wildcard)
: address_length{len}, wildcard{wildcard} {
assert(len <= sizeof(address));
memcpy(&address.generic, sockaddr, len);
: address_length_{len}, wildcard_{wildcard} {
assert(len <= sizeof(address_));
memcpy(&address_.generic, sockaddr, len);
}
int socket(int type) const {
type |= SOCK_NONBLOCK | SOCK_CLOEXEC;
int result = ::socket(address.generic.sa_family, type, 0);
int result = ::socket(address_.generic.sa_family, type, 0);
return result;
}
bool bind(int fd) const {
if (wildcard) {
if (wildcard_) {
int value = 0;
::setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &value, sizeof(value));
}
int error = ::bind(fd, &address.generic, address_length);
int error = ::bind(fd, &address_.generic, address_length_);
return error < 0;
}
struct ::sockaddr *getRaw() {
return &address.generic;
return &address_.generic;
}
const struct ::sockaddr *getRaw() const { return &address.generic; }
const struct ::sockaddr *getRaw() const { return &address_.generic; }
socklen_t getRawLength() const { return address_length; }
socklen_t getRawLength() const { return address_length_; }
static std::vector<SocketAddress> resolve(std::string_view str,
uint16_t port_hint) {
@ -398,7 +398,7 @@ public:
}
for (struct ::addrinfo *it = head; it != nullptr; it = it->ai_next) {
if (it->ai_addrlen > sizeof(SocketAddress::address)) {
if (it->ai_addrlen > sizeof(SocketAddress::address_)) {
continue;
}
results.push_back({it->ai_addr, it->ai_addrlen, wildcard});
@ -410,14 +410,14 @@ public:
class UnixNetworkAddress final : public OsNetworkAddress {
private:
const std::string path;
uint16_t port_hint;
std::vector<SocketAddress> addresses;
const std::string path_;
uint16_t port_hint_;
std::vector<SocketAddress> addresses_;
public:
UnixNetworkAddress(const std::string &path, uint16_t port_hint,
std::vector<SocketAddress> &&addr)
: path{path}, port_hint{port_hint}, addresses{std::move(addr)} {}
: path_{path}, port_hint_{port_hint}, addresses_{std::move(addr)} {}
const std::string &address() const override;
@ -430,7 +430,7 @@ public:
class UnixNetwork final : public Network {
private:
UnixEventPort &event_port;
UnixEventPort &event_port_;
public:
UnixNetwork(UnixEventPort &event_port);
@ -447,10 +447,10 @@ public:
class UnixIoProvider final : public IoProvider {
private:
UnixEventPort &event_port;
EventLoop event_loop;
UnixEventPort &event_port_;
EventLoop event_loop_;
UnixNetwork unix_network;
UnixNetwork unix_network_;
public:
UnixIoProvider(UnixEventPort &port_ref, Own<EventPort> port);

132
source/forstio/async.h
View File

@ -79,9 +79,9 @@ class WaitScope;
*/
class Event {
private:
EventLoop &loop;
Event **prev = nullptr;
Event *next = nullptr;
EventLoop &loop_;
Event **prev_ = nullptr;
Event *next_ = nullptr;
friend class EventLoop;
@ -102,7 +102,7 @@ public:
class ConveyorStorage {
protected:
ConveyorStorage *parent = nullptr;
ConveyorStorage *parent_ = nullptr;
public:
ConveyorStorage();
@ -127,7 +127,7 @@ public:
class ConveyorBase {
protected:
Own<ConveyorNode> node;
Own<ConveyorNode> node_;
public:
ConveyorBase(Own<ConveyorNode> &&node_p);
@ -166,7 +166,7 @@ public:
class ConveyorSink {
private:
Own<ConveyorNode> node;
Own<ConveyorNode> node_;
public:
ConveyorSink();
@ -180,7 +180,7 @@ template <typename T> class MergeConveyorNodeData;
template <typename T> class MergeConveyor {
private:
Lent<MergeConveyorNodeData<T>> data;
Lent<MergeConveyorNodeData<T>> data_;
public:
MergeConveyor() = default;
@ -376,11 +376,11 @@ private:
void destroySinkConveyorNode(ConveyorNode &sink_node);
void fail(Error &&error);
std::list<Own<ConveyorNode>> sink_nodes;
std::list<Own<ConveyorNode>> sink_nodes_;
std::queue<ConveyorNode *> delete_nodes;
std::queue<ConveyorNode *> delete_nodes_;
std::function<void(Error &&error)> error_handler;
std::function<void(Error &&error)> error_handler_;
public:
// ConveyorSinks();
@ -400,16 +400,16 @@ public:
class EventLoop {
private:
friend class Event;
Event *head = nullptr;
Event **tail = &head;
Event **next_insert_point = &head;
Event **later_insert_point = &head;
Event *head_ = nullptr;
Event **tail_ = &head_;
Event **next_insert_point_ = &head_;
Event **later_insert_point_ = &head_;
bool is_runnable = false;
bool is_runnable_ = false;
Own<EventPort> event_port = nullptr;
Own<EventPort> event_port_ = nullptr;
Own<ConveyorSinkSet> daemon_sink = nullptr;
Own<ConveyorSinkSet> daemon_sink_ = nullptr;
// functions
void setRunnable(bool runnable);
@ -445,7 +445,7 @@ public:
*/
class WaitScope {
private:
EventLoop &loop;
EventLoop &loop_;
public:
WaitScope(EventLoop &loop);
@ -501,7 +501,7 @@ template <typename T> class AdaptConveyorNode;
template <typename T>
class AdaptConveyorFeeder final : public ConveyorFeeder<UnfixVoid<T>> {
private:
AdaptConveyorNode<T> *feedee = nullptr;
AdaptConveyorNode<T> *feedee_ = nullptr;
public:
~AdaptConveyorFeeder();
@ -521,11 +521,11 @@ template <typename T>
class AdaptConveyorNode final : public ConveyorNode,
public ConveyorEventStorage {
private:
AdaptConveyorFeeder<T> *feeder = nullptr;
AdaptConveyorFeeder<T> *feeder_ = nullptr;
std::queue<ErrorOr<UnfixVoid<T>>> storage;
std::queue<ErrorOr<UnfixVoid<T>>> storage_;
ConveyorNodeWithParentMixin parent_node;
ConveyorNodeWithParentMixin parent_node_;
public:
AdaptConveyorNode();
@ -561,7 +561,7 @@ template <typename T> class OneTimeConveyorNode;
template <typename T>
class OneTimeConveyorFeeder final : public ConveyorFeeder<UnfixVoid<T>> {
private:
OneTimeConveyorNode<T> *feedee = nullptr;
OneTimeConveyorNode<T> *feedee_ = nullptr;
public:
~OneTimeConveyorFeeder();
@ -580,10 +580,10 @@ class OneTimeConveyorNode final : public ConveyorNode,
public ConveyorStorage,
public Event {
private:
OneTimeConveyorFeeder<T> *feeder = nullptr;
OneTimeConveyorFeeder<T> *feeder_ = nullptr;
bool passed = false;
Maybe<ErrorOr<T>> storage = std::nullopt;
bool passed_ = false;
Maybe<ErrorOr<T>> storage_ = std::nullopt;
public:
~OneTimeConveyorNode();
@ -616,11 +616,11 @@ public:
class QueueBufferConveyorNodeBase : public ConveyorNode,
public ConveyorEventStorage {
protected:
ConveyorNodeWithChildMixin child_mixin;
ConveyorNodeWithChildMixin child_mixin_;
public:
QueueBufferConveyorNodeBase(Own<ConveyorNode> child_)
: ConveyorEventStorage{}, child_mixin{std::move(child_), *this} {}
: ConveyorEventStorage{}, child_mixin_{std::move(child_), *this} {}
virtual ~QueueBufferConveyorNodeBase() = default;
/**
@ -637,12 +637,12 @@ public:
template <typename T>
class QueueBufferConveyorNode final : public QueueBufferConveyorNodeBase {
private:
std::queue<ErrorOr<T>> storage;
size_t max_store;
std::queue<ErrorOr<T>> storage_;
size_t max_store_;
public:
QueueBufferConveyorNode(Own<ConveyorNode> dep, size_t max_size)
: QueueBufferConveyorNodeBase{std::move(dep)}, max_store{max_size} {}
: QueueBufferConveyorNodeBase{std::move(dep)}, max_store_{max_size} {}
// Event
void fire() override;
// ConveyorNode
@ -658,11 +658,11 @@ public:
class AttachConveyorNodeBase : public ConveyorNode {
protected:
ConveyorNodeWithChildMixin child_mixin;
ConveyorNodeWithChildMixin child_mixin_;
public:
AttachConveyorNodeBase(Own<ConveyorNode> &&child_)
: child_mixin{std::move(child_), *this} {}
: child_mixin_{std::move(child_), *this} {}
virtual ~AttachConveyorNodeBase() = default;
@ -681,11 +681,11 @@ template <typename... Args>
class AttachConveyorNode final : public AttachConveyorNodeBase {
public:
AttachConveyorNode(Own<ConveyorNode> &&dep, Args &&...args)
: AttachConveyorNodeBase(std::move(dep)), attached_data{
: AttachConveyorNodeBase(std::move(dep)), attached_data_{
std::move(args...)} {}
private:
std::tuple<Args...> attached_data;
std::tuple<Args...> attached_data_;
};
class ConvertConveyorNodeBase : public ConveyorNode {
@ -703,14 +703,14 @@ public:
ConveyorStorage *nextStorage() noexcept override;
protected:
ConveyorNodeWithChildMixin child_mixin;
ConveyorNodeWithChildMixin child_mixin_;
};
template <typename T, typename DepT, typename Func, typename ErrorFunc>
class ConvertConveyorNode final : public ConvertConveyorNodeBase {
private:
Func func;
ErrorFunc error_func;
Func func_;
ErrorFunc error_func_;
static_assert(std::is_same<DepT, RemoveErrorOr<DepT>>::value,
"Should never be of type ErrorOr");
@ -718,20 +718,20 @@ private:
public:
ConvertConveyorNode(Own<ConveyorNode> &&dep, Func &&func,
ErrorFunc &&error_func)
: ConvertConveyorNodeBase(std::move(dep)), func{std::move(func)},
error_func{std::move(error_func)} {}
: ConvertConveyorNodeBase(std::move(dep)), func_{std::move(func)},
error_func_{std::move(error_func)} {}
void getImpl(ErrorOrValue &err_or_val) noexcept override {
ErrorOr<UnfixVoid<DepT>> dep_eov;
ErrorOr<UnfixVoid<RemoveErrorOr<T>>> &eov =
err_or_val.as<UnfixVoid<RemoveErrorOr<T>>>();
if (child_mixin.child) {
child_mixin.child->getResult(dep_eov);
if (child_mixin_.child) {
child_mixin_.child->getResult(dep_eov);
if (dep_eov.isValue()) {
try {
eov = FixVoidCaller<T, DepT>::apply(
func, std::move(dep_eov.value()));
func_, std::move(dep_eov.value()));
} catch (const std::bad_alloc &) {
eov = criticalError("Out of memory");
} catch (const std::exception &) {
@ -740,7 +740,7 @@ public:
"want to handle errors which are recoverable");
}
} else if (dep_eov.isError()) {
eov = error_func(std::move(dep_eov.error()));
eov = error_func_(std::move(dep_eov.error()));
} else {
eov = criticalError("No value set in dependency");
}
@ -753,27 +753,27 @@ public:
class SinkConveyorNode final : public ConveyorNode,
public ConveyorEventStorage {
private:
ConveyorNodeWithChildMixin child_mixin;
ConveyorSinkSet *conveyor_sink;
ConveyorNodeWithChildMixin child_mixin_;
ConveyorSinkSet *conveyor_sink_;
public:
SinkConveyorNode(Own<ConveyorNode> node, ConveyorSinkSet &conv_sink)
: ConveyorEventStorage{}, child_mixin{std::move(node), *this},
conveyor_sink{&conv_sink} {}
: ConveyorEventStorage{}, child_mixin_{std::move(node), *this},
conveyor_sink_{&conv_sink} {}
SinkConveyorNode(Own<ConveyorNode> node)
: ConveyorEventStorage{}, child_mixin{std::move(node), *this},
conveyor_sink{nullptr} {}
: ConveyorEventStorage{}, child_mixin_{std::move(node), *this},
conveyor_sink_{nullptr} {}
// Event only queued if a critical error occured
void fire() override {
// Queued for destruction of children, because this acts as a sink and
// no other event should be here
child_mixin.child = nullptr;
child_mixin_.child = nullptr;
if (conveyor_sink) {
conveyor_sink->destroySinkConveyorNode(*this);
conveyor_sink = nullptr;
if (conveyor_sink_) {
conveyor_sink_->destroySinkConveyorNode(*this);
conveyor_sink_ = nullptr;
}
}
@ -789,22 +789,22 @@ public:
ErrorOr<Own<ConveyorNode>>
swapChild(Own<ConveyorNode> &&swapee) noexcept override {
return child_mixin.swapChild(std::move(swapee));
return child_mixin_.swapChild(std::move(swapee));
}
// ConveyorStorage
void childHasFired() override {
if (child_mixin.child) {
if (child_mixin_.child) {
ErrorOr<void> dep_eov;
child_mixin.child->getResult(dep_eov);
child_mixin_.child->getResult(dep_eov);
if (dep_eov.isError()) {
if (dep_eov.error().isCritical()) {
if (!isArmed()) {
armLast();
}
}
if (conveyor_sink) {
conveyor_sink->fail(std::move(dep_eov.error()));
if (conveyor_sink_) {
conveyor_sink_->fail(std::move(dep_eov.error()));
}
}
}
@ -845,8 +845,8 @@ public:
template <typename T>
class ImmediateConveyorNode final : public ImmediateConveyorNodeBase {
private:
ErrorOr<FixVoid<T>> value;
uint8_t retrieved;
ErrorOr<FixVoid<T>> value_;
uint8_t retrieved_;
public:
ImmediateConveyorNode(FixVoid<T> &&val);
@ -861,14 +861,14 @@ public:
// ConveyorNode
void getResult(ErrorOrValue &err_or_val) noexcept override {
if (retrieved > 0) {
if (retrieved_ > 0) {
err_or_val.as<FixVoid<T>>() =
makeError("Already taken value", Error::Code::Exhausted);
} else {
err_or_val.as<FixVoid<T>>() = std::move(value);
err_or_val.as<FixVoid<T>>() = std::move(value_);
}
if (queued() > 0) {
++retrieved;
++retrieved_;
}
}
@ -946,8 +946,8 @@ private:
friend class MergeConveyorNodeData<T>;
friend class Appendage;
Our<MergeConveyorNodeData<T>> data;
size_t next_appendage = 0;
Our<MergeConveyorNodeData<T>> data_;
size_t next_appendage_ = 0;
public:
MergeConveyorNode(Our<MergeConveyorNodeData<T>> data);

244
source/forstio/async.tmpl.h
View File

@ -27,7 +27,7 @@ Conveyor<T>::Conveyor(FixVoid<T> value) : ConveyorBase(nullptr) {
return;
}
node = std::move(immediate);
node_ = std::move(immediate);
}
template <typename T>
@ -39,7 +39,7 @@ Conveyor<T>::Conveyor(Error &&error) : ConveyorBase(nullptr) {
return;
}
node = std::move(immediate);
node_ = std::move(immediate);
}
template <typename T>
@ -51,7 +51,7 @@ template <typename Func, typename ErrorFunc>
ConveyorResult<Func, T> Conveyor<T>::then(Func &&func, ErrorFunc &&error_func) {
Own<ConveyorNode> conversion_node =
heap<ConvertConveyorNode<FixVoid<ReturnType<Func, T>>, FixVoid<T>, Func,
ErrorFunc>>(std::move(node), std::move(func),
ErrorFunc>>(std::move(node_), std::move(func),
std::move(error_func));
return Conveyor<RemoveErrorOr<ReturnType<Func, T>>>::toConveyor(
@ -59,12 +59,12 @@ ConveyorResult<Func, T> Conveyor<T>::then(Func &&func, ErrorFunc &&error_func) {
}
template <typename T> Conveyor<T> Conveyor<T>::buffer(size_t size) {
SAW_ASSERT(node) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
ConveyorStorage *storage = node->nextStorage();
SAW_ASSERT(node_) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
ConveyorStorage *storage = node_->nextStorage();
SAW_ASSERT(storage) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
Own<QueueBufferConveyorNode<FixVoid<T>>> storage_node =
heap<QueueBufferConveyorNode<FixVoid<T>>>(std::move(node), size);
heap<QueueBufferConveyorNode<FixVoid<T>>>(std::move(node_), size);
ConveyorStorage *storage_ptr =
static_cast<ConveyorStorage *>(storage_node.get());
@ -77,7 +77,7 @@ template <typename T>
template <typename... Args>
Conveyor<T> Conveyor<T>::attach(Args &&...args) {
Own<AttachConveyorNode<Args...>> attach_node =
heap<AttachConveyorNode<Args...>>(std::move(node), std::move(args...));
heap<AttachConveyorNode<Args...>>(std::move(node_), std::move(args...));
return Conveyor<T>{std::move(attach_node)};
}
@ -87,17 +87,17 @@ std::pair<Conveyor<T>, MergeConveyor<T>> Conveyor<T>::merge() {
Own<MergeConveyorNode<T>> merge_node = heap<MergeConveyorNode<T>>(data);
SAW_ASSERT(node) {
SAW_ASSERT(node_) {
return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
MergeConveyor<T>{});
}
ConveyorStorage *storage = node->nextStorage();
ConveyorStorage *storage = node_->nextStorage();
SAW_ASSERT(storage) {
return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
MergeConveyor<T>{});
}
data->attach(Conveyor<T>::toConveyor(std::move(node)));
data->attach(Conveyor<T>::toConveyor(std::move(node_)));
MergeConveyor<T> node_ref{data};
@ -108,10 +108,10 @@ std::pair<Conveyor<T>, MergeConveyor<T>> Conveyor<T>::merge() {
template <>
template <typename ErrorFunc>
ConveyorSink Conveyor<void>::sink(ErrorFunc &&error_func) {
ConveyorStorage *storage = node->nextStorage();
ConveyorStorage *storage = node_->nextStorage();
SAW_ASSERT(storage) { return ConveyorSink{}; }
Own<SinkConveyorNode> sink_node = heap<SinkConveyorNode>(std::move(node));
Own<SinkConveyorNode> sink_node = heap<SinkConveyorNode>(std::move(node_));
ConveyorStorage *storage_ptr =
static_cast<ConveyorStorage *>(sink_node.get());
@ -141,18 +141,18 @@ Conveyor<T> Conveyor<T>::toConveyor(Own<ConveyorNode> node) {
template <typename T>
Own<ConveyorNode> Conveyor<T>::fromConveyor(Conveyor<T> conveyor) {
return std::move(conveyor.node);
return std::move(conveyor.node_);
}
template <typename T> ErrorOr<FixVoid<T>> Conveyor<T>::take() {
SAW_ASSERT(node) {
SAW_ASSERT(node_) {
return ErrorOr<FixVoid<T>>{criticalError("Conveyor in invalid state")};
}
ConveyorStorage *storage = node->nextStorage();
ConveyorStorage *storage = node_->nextStorage();
if (storage) {
if (storage->queued() > 0) {
ErrorOr<FixVoid<T>> result;
node->getResult(result);
node_->getResult(result);
return result;
} else {
return ErrorOr<FixVoid<T>>{
@ -179,11 +179,11 @@ template <typename T> ConveyorAndFeeder<T> newConveyorAndFeeder() {
// QueueBuffer
template <typename T> void QueueBufferConveyorNode<T>::fire() {
if (child_mixin.child) {
if (!storage.empty()) {
if (storage.front().isError()) {
if (storage.front().error().isCritical()) {
child_mixin.child = nullptr;
if (child_mixin_.child) {
if (!storage_.empty()) {
if (storage_.front().isError()) {
if (storage_.front().error().isCritical()) {
child_mixin_.child = nullptr;
}
}
}
@ -191,21 +191,21 @@ template <typename T> void QueueBufferConveyorNode<T>::fire() {
bool has_space_before_fire = space() > 0;
if (parent) {
parent->childHasFired();
if (!storage.empty() && parent->space() > 0) {
if (parent_) {
parent_->childHasFired();
if (!storage_.empty() && parent_->space() > 0) {
armLater();
}
}
if (!child_mixin.child) {
while (!storage.empty()) {
storage.pop();
if (!child_mixin_.child) {
while (!storage_.empty()) {
storage_.pop();
}
return;
}
ConveyorStorage *ch_storage = child_mixin.child->nextStorage();
ConveyorStorage *ch_storage = child_mixin_.child->nextStorage();
if (ch_storage && !has_space_before_fire) {
ch_storage->parentHasFired();
}
@ -214,29 +214,29 @@ template <typename T> void QueueBufferConveyorNode<T>::fire() {
template <typename T>
void QueueBufferConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
ErrorOr<T> &err_or_val = eov.as<T>();
err_or_val = std::move(storage.front());
storage.pop();
err_or_val = std::move(storage_.front());
storage_.pop();
}
template <typename T> size_t QueueBufferConveyorNode<T>::space() const {
return max_store - storage.size();
return max_store_ - storage_.size();
}
template <typename T> size_t QueueBufferConveyorNode<T>::queued() const {
return storage.size();
return storage_.size();
}
template <typename T> void QueueBufferConveyorNode<T>::childHasFired() {
if (child_mixin.child && storage.size() < max_store) {
if (child_mixin_.child && storage_.size() < max_store_) {
ErrorOr<T> eov;
child_mixin.child->getResult(eov);
child_mixin_.child->getResult(eov);
if (eov.isError()) {
if (eov.error().isCritical()) {
}
}
storage.push(std::move(eov));
storage_.push(std::move(eov));
if (!isArmed()) {
armLater();
}
@ -244,9 +244,9 @@ template <typename T> void QueueBufferConveyorNode<T>::childHasFired() {
}
template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
SAW_ASSERT(parent) { return; }
SAW_ASSERT(parent_) { return; }
if (parent->space() == 0) {
if (parent_->space() == 0) {
return;
}
@ -257,18 +257,18 @@ template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
template <typename T>
ImmediateConveyorNode<T>::ImmediateConveyorNode(FixVoid<T> &&val)
: value{std::move(val)}, retrieved{0} {}
: value_{std::move(val)}, retrieved_{0} {}
template <typename T>
ImmediateConveyorNode<T>::ImmediateConveyorNode(Error &&error)
: value{std::move(error)}, retrieved{0} {}
: value_{std::move(error)}, retrieved_{0} {}
template <typename T> size_t ImmediateConveyorNode<T>::space() const {
return 0;
}
template <typename T> size_t ImmediateConveyorNode<T>::queued() const {
return retrieved > 1 ? 0 : 1;
return retrieved_ > 1 ? 0 : 1;
}
template <typename T> void ImmediateConveyorNode<T>::childHasFired() {
@ -277,8 +277,8 @@ template <typename T> void ImmediateConveyorNode<T>::childHasFired() {
}
template <typename T> void ImmediateConveyorNode<T>::parentHasFired() {
SAW_ASSERT(parent) { return; }
assert(parent->space() > 0);
SAW_ASSERT(parent_) { return; }
assert(parent_->space() > 0);
if (queued() > 0) {
armNext();
@ -287,9 +287,9 @@ template <typename T> void ImmediateConveyorNode<T>::parentHasFired() {
template <typename T> void ImmediateConveyorNode<T>::fire() {
if (parent) {
parent->childHasFired();
if (queued() > 0 && parent->space() > 0) {
if (parent_) {
parent_->childHasFired();
if (queued() > 0 && parent_->space() > 0) {
armLast();
}
}
@ -297,12 +297,12 @@ template <typename T> void ImmediateConveyorNode<T>::fire() {
template <typename T>
MergeConveyor<T>::MergeConveyor(Lent<MergeConveyorNodeData<T>> d)
: data{std::move(d)} {}
: data_{std::move(d)} {}
template <typename T> MergeConveyor<T>::~MergeConveyor() {}
template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
auto sp = data.lock();
auto sp = data_.lock();
SAW_ASSERT(sp) { return; }
sp->attach(std::move(conveyor));
@ -310,10 +310,10 @@ template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
template <typename T>
MergeConveyorNode<T>::MergeConveyorNode(Our<MergeConveyorNodeData<T>> d)
: data{d} {
SAW_ASSERT(data) { return; }
: data_{d} {
SAW_ASSERT(data_) { return; }
data->merger = this;
data_->merger = this;
}
template <typename T> MergeConveyorNode<T>::~MergeConveyorNode() {}
@ -330,26 +330,26 @@ template <typename T>
void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
SAW_ASSERT(data) { return; }
SAW_ASSERT(data_) { return; }
/// @todo search appendages for result
auto &appendages = data->appendages;
next_appendage = std::min(appendages.size(), next_appendage);
auto &appendages = data_->appendages;
next_appendage_ = std::min(appendages.size(), next_appendage_);
for (size_t i = next_appendage; i < appendages.size(); ++i) {
for (size_t i = next_appendage_; i < appendages.size(); ++i) {
if (appendages[i]->queued() > 0) {
err_or_val = std::move(appendages[i]->error_or_value.value());
appendages[i]->error_or_value = std::nullopt;
next_appendage = i + 1;
next_appendage_ = i + 1;
return;
}
}
for (size_t i = 0; i < next_appendage; ++i) {
for (size_t i = 0; i < next_appendage_; ++i) {
if (appendages[i]->queued() > 0) {
err_or_val = std::move(appendages[i]->error_or_value.value());
appendages[i]->error_or_value = std::nullopt;
next_appendage = i + 1;
next_appendage_ = i + 1;
return;
}
}
@ -360,10 +360,10 @@ void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
template <typename T> void MergeConveyorNode<T>::fire() {
SAW_ASSERT(queued() > 0) { return; }
if (parent) {
parent->childHasFired();
if (parent_) {
parent_->childHasFired();
if (queued() > 0 && parent->space() > 0) {
if (queued() > 0 && parent_->space() > 0) {
armLater();
}
}
@ -372,11 +372,11 @@ template <typename T> void MergeConveyorNode<T>::fire() {
template <typename T> size_t MergeConveyorNode<T>::space() const { return 0; }
template <typename T> size_t MergeConveyorNode<T>::queued() const {
SAW_ASSERT(data) { return 0; }
SAW_ASSERT(data_) { return 0; }
size_t queue_count = 0;
for (auto &iter : data->appendages) {
for (auto &iter : data_->appendages) {
queue_count += iter->queued();
}
@ -389,9 +389,9 @@ template <typename T> void MergeConveyorNode<T>::childHasFired() {
}
template <typename T> void MergeConveyorNode<T>::parentHasFired() {
SAW_ASSERT(parent) { return; }
SAW_ASSERT(parent_) { return; }
if (queued() > 0) {
if (parent->space() > 0) {
if (parent_->space() > 0) {
armLater();
}
}
@ -486,7 +486,7 @@ void MergeConveyorNode<T>::Appendage::setParent(ConveyorStorage *par) {
SAW_ASSERT(child) { return; }
parent = par;
parent_ = par;
}
template <typename T>
@ -522,50 +522,50 @@ template <typename T> void MergeConveyorNodeData<T>::governingNodeDestroyed() {
}
template <typename T> AdaptConveyorFeeder<T>::~AdaptConveyorFeeder() {
if (feedee) {
feedee->setFeeder(nullptr);
feedee = nullptr;
if (feedee_) {
feedee_->setFeeder(nullptr);
feedee_ = nullptr;
}
}
template <typename T>
void AdaptConveyorFeeder<T>::setFeedee(AdaptConveyorNode<T> *feedee_p) {
feedee = feedee_p;
feedee_ = feedee_p;
}
template <typename T> void AdaptConveyorFeeder<T>::feed(T &&value) {
if (feedee) {
feedee->feed(std::move(value));
if (feedee_) {
feedee_->feed(std::move(value));
}
}
template <typename T> void AdaptConveyorFeeder<T>::fail(Error &&error) {
if (feedee) {
feedee->fail(std::move(error));
if (feedee_) {
feedee_->fail(std::move(error));
}
}
template <typename T> size_t AdaptConveyorFeeder<T>::queued() const {
if (feedee) {
return feedee->queued();
if (feedee_) {
return feedee_->queued();
}
return 0;
}
template <typename T> size_t AdaptConveyorFeeder<T>::space() const {
if (feedee) {
return feedee->space();
if (feedee_) {
return feedee_->space();
}
return 0;
}
template <typename T>
Error AdaptConveyorFeeder<T>::swap(Conveyor<T> &&conveyor) noexcept {
SAW_ASSERT(feedee) { return criticalError("No feedee connected"); }
SAW_ASSERT(feedee_) { return criticalError("No feedee connected"); }
auto node = Conveyor<T>::fromConveyor(std::move(conveyor));
feedee->swapChild(std::move(node));
feedee_->swapChild(std::move(node));
return noError();
}
@ -574,9 +574,9 @@ template <typename T>
AdaptConveyorNode<T>::AdaptConveyorNode() : ConveyorEventStorage{} {}
template <typename T> AdaptConveyorNode<T>::~AdaptConveyorNode() {
if (feeder) {
feeder->setFeedee(nullptr);
feeder = nullptr;
if (feeder_) {
feeder_->setFeedee(nullptr);
feeder_ = nullptr;
}
}
@ -584,7 +584,7 @@ template <typename T>
ErrorOr<Own<ConveyorNode>>
AdaptConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee) noexcept {
// This should return the owning pointer of this instance
auto myself_err = parent_node.swapChildOfParent(std::move(swapee));
auto myself_err = parent_node_.swapChildOfParent(std::move(swapee));
if (myself_err.isError()) {
return myself_err;
@ -604,37 +604,37 @@ ConveyorStorage *AdaptConveyorNode<T>::nextStorage() noexcept {
template <typename T>
void AdaptConveyorNode<T>::notifyParentAttached(ConveyorNode &par) noexcept {
parent_node.changeParent(&par);
parent_node_.changeParent(&par);
}
template <typename T>
void AdaptConveyorNode<T>::setFeeder(AdaptConveyorFeeder<T> *feeder_p) {
feeder = feeder_p;
feeder_ = feeder_p;
}
template <typename T> void AdaptConveyorNode<T>::feed(T &&value) {
storage.push(std::move(value));
storage_.push(std::move(value));
armNext();
}
template <typename T> void AdaptConveyorNode<T>::fail(Error &&error) {
storage.push(std::move(error));
storage_.push(std::move(error));
armNext();
}
template <typename T> size_t AdaptConveyorNode<T>::queued() const {
return storage.size();
return storage_.size();
}
template <typename T> size_t AdaptConveyorNode<T>::space() const {
return std::numeric_limits<size_t>::max() - storage.size();
return std::numeric_limits<size_t>::max() - storage_.size();
}
template <typename T>
void AdaptConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
if (!storage.empty()) {
err_or_val.as<T>() = std::move(storage.front());
storage.pop();
if (!storage_.empty()) {
err_or_val.as<T>() = std::move(storage_.front());
storage_.pop();
} else {
err_or_val.as<T>() =
criticalError("Signal for retrieval of storage sent even though no "
@ -648,96 +648,96 @@ template <typename T> void AdaptConveyorNode<T>::childHasFired() {
}
template <typename T> void AdaptConveyorNode<T>::parentHasFired() {
SAW_ASSERT(parent) { return; }
SAW_ASSERT(parent_) { return; }
if (parent->space() == 0) {
if (parent_->space() == 0) {
return;
}
}
template <typename T> void AdaptConveyorNode<T>::fire() {
if (parent) {
parent->childHasFired();
if (parent_) {
parent_->childHasFired();
if (storage.size() > 0) {
if (storage_.size() > 0) {
armLater();
}
}
}
template <typename T> OneTimeConveyorFeeder<T>::~OneTimeConveyorFeeder() {
if (feedee) {
feedee->setFeeder(nullptr);
feedee = nullptr;
if (feedee_) {
feedee_->setFeeder(nullptr);
feedee_ = nullptr;
}
}
template <typename T>
void OneTimeConveyorFeeder<T>::setFeedee(OneTimeConveyorNode<T> *feedee_p) {
feedee = feedee_p;
feedee_ = feedee_p;
}
template <typename T> void OneTimeConveyorFeeder<T>::feed(T &&value) {
if (feedee) {
feedee->feed(std::move(value));
if (feedee_) {
feedee_->feed(std::move(value));
}
}
template <typename T> void OneTimeConveyorFeeder<T>::fail(Error &&error) {
if (feedee) {
feedee->fail(std::move(error));
if (feedee_) {
feedee_->fail(std::move(error));
}
}
template <typename T> size_t OneTimeConveyorFeeder<T>::queued() const {
if (feedee) {
return feedee->queued();
if (feedee_) {
return feedee_->queued();
}
return 0;
}
template <typename T> size_t OneTimeConveyorFeeder<T>::space() const {
if (feedee) {
return feedee->space();
if (feedee_) {
return feedee_->space();
}
return 0;
}
template <typename T> OneTimeConveyorNode<T>::~OneTimeConveyorNode() {
if (feeder) {
feeder->setFeedee(nullptr);
feeder = nullptr;
if (feeder_) {
feeder_->setFeedee(nullptr);
feeder_ = nullptr;
}
}
template <typename T>
void OneTimeConveyorNode<T>::setFeeder(OneTimeConveyorFeeder<T> *feeder_p) {
feeder = feeder_p;
feeder_ = feeder_p;
}
template <typename T> void OneTimeConveyorNode<T>::feed(T &&value) {
storage = std::move(value);
storage_ = std::move(value);
armNext();
}
template <typename T> void OneTimeConveyorNode<T>::fail(Error &&error) {
storage = std::move(error);
storage_ = std::move(error);
armNext();
}
template <typename T> size_t OneTimeConveyorNode<T>::queued() const {
return storage.has_value() ? 1 : 0;
return storage_.has_value() ? 1 : 0;
}
template <typename T> size_t OneTimeConveyorNode<T>::space() const {
return passed ? 0 : 1;
return passed_ ? 0 : 1;
}
template <typename T>
void OneTimeConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
if (storage.has_value()) {
err_or_val.as<T>() = std::move(storage.value());
storage = std::nullopt;
if (storage_.has_value()) {
err_or_val.as<T>() = std::move(storage_.value());
storage_ = std::nullopt;
} else {
err_or_val.as<T>() =
criticalError("Signal for retrieval of storage sent even though no "
@ -746,8 +746,8 @@ void OneTimeConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
}
template <typename T> void OneTimeConveyorNode<T>::fire() {
if (parent) {
parent->childHasFired();
if (parent_) {
parent_->childHasFired();
}
}

32
source/forstio/buffer.h
View File

@ -57,9 +57,9 @@ public:
*/
class BufferView : public Buffer {
private:
Buffer &buffer;
size_t read_offset;
size_t write_offset;
Buffer &buffer_;
size_t read_offset_;
size_t write_offset_;
public:
BufferView(Buffer &);
@ -96,19 +96,19 @@ constexpr size_t RING_BUFFER_MAX_SIZE = 4096;
*/
class RingBuffer final : public Buffer {
private:
std::vector<uint8_t> buffer;
size_t read_position;
size_t write_position;
bool write_reached_read = false;
std::vector<uint8_t> buffer_;
size_t read_position_;
size_t write_position_;
bool write_reached_read_ = false;
public:
RingBuffer();
RingBuffer(size_t size);
inline size_t size() const { return buffer.size(); }
inline size_t size() const { return buffer_.size(); }
inline uint8_t &operator[](size_t i) { return buffer[i]; }
inline const uint8_t &operator[](size_t i) const { return buffer[i]; }
inline uint8_t &operator[](size_t i) { return buffer_[i]; }
inline const uint8_t &operator[](size_t i) const { return buffer_[i]; }
size_t readPosition() const override;
size_t readCompositeLength() const override;
@ -134,10 +134,10 @@ public:
*/
class ArrayBuffer : public Buffer {
private:
std::vector<uint8_t> buffer;
std::vector<uint8_t> buffer_;
size_t read_position;
size_t write_position;
size_t read_position_;
size_t write_position_;
public:
ArrayBuffer(size_t size);
@ -163,10 +163,10 @@ public:
class ChainArrayBuffer : public Buffer {
private:
std::deque<ArrayBuffer> buffer;
std::deque<ArrayBuffer> buffer_;
size_t read_position;
size_t write_position;
size_t read_position_;
size_t write_position_;
public:
ChainArrayBuffer();

24
source/forstio/error.h
View File

@ -24,7 +24,7 @@ public:
};
private:
std::variant<std::string_view, std::string> error_message;
std::variant<std::string_view, std::string> error_message_;
Code error_;
public:
@ -103,35 +103,35 @@ public:
template <typename T> class ErrorOr final : public ErrorOrValue {
private:
std::variant<Error, FixVoid<T>> value_or_error;
std::variant<Error, FixVoid<T>> value_or_error_;
static_assert(!std::is_same_v<T, Void>, "Don't use internal private types");
public:
ErrorOr() = default;
ErrorOr(const FixVoid<T> &value) : value_or_error{value} {}
ErrorOr(const FixVoid<T> &value) : value_or_error_{value} {}
ErrorOr(FixVoid<T> &&value) : value_or_error{std::move(value)} {}
ErrorOr(FixVoid<T> &&value) : value_or_error_{std::move(value)} {}
ErrorOr(const Error &error) : value_or_error{error} {}
ErrorOr(Error &&error) : value_or_error{std::move(error)} {}
ErrorOr(const Error &error) : value_or_error_{error} {}
ErrorOr(Error &&error) : value_or_error_{std::move(error)} {}
bool isValue() const {
return std::holds_alternative<FixVoid<T>>(value_or_error);
return std::holds_alternative<FixVoid<T>>(value_or_error_);
}
bool isError() const {
return std::holds_alternative<Error>(value_or_error);
return std::holds_alternative<Error>(value_or_error_);
}
Error &error() { return std::get<Error>(value_or_error); }
Error &error() { return std::get<Error>(value_or_error_); }
const Error &error() const { return std::get<Error>(value_or_error); }
const Error &error() const { return std::get<Error>(value_or_error_); }
FixVoid<T> &value() { return std::get<FixVoid<T>>(value_or_error); }
FixVoid<T> &value() { return std::get<FixVoid<T>>(value_or_error_); }
const FixVoid<T> &value() const {
return std::get<FixVoid<T>>(value_or_error);
return std::get<FixVoid<T>>(value_or_error_);
}
};

16
source/forstio/io.h
View File

@ -63,14 +63,14 @@ public:
class AsyncIoStream final : public AsyncInputStream, public AsyncOutputStream {
private:
Own<IoStream> stream;
Own<IoStream> stream_;
ConveyorSink read_ready;
ConveyorSink write_ready;
ConveyorSink read_disconnected;
ConveyorSink read_ready_;
ConveyorSink write_ready_;
ConveyorSink read_disconnected_;
ReadTaskAndStepHelper read_stepper;
WriteTaskAndStepHelper write_stepper;
ReadTaskAndStepHelper read_stepper_;
WriteTaskAndStepHelper write_stepper_;
public:
AsyncIoStream(Own<IoStream> str);
@ -139,8 +139,8 @@ public:
class StringNetworkAddress final : public NetworkAddress {
private:
std::string address_value;
uint16_t port_value;
std::string address_value_;
uint16_t port_value_;
public:
StringNetworkAddress(const std::string &address, uint16_t port);

2
source/forstio/io_auth.h
View File

@ -11,7 +11,7 @@ public:
const std::string &identity() const;
private:
std::string identity_value;
std::string identity_value_;
};
class AuthenticatedIoStream {

20
source/forstio/io_peer.h
View File

@ -52,7 +52,7 @@ private:
PeerConveyorFeeder(
StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT> &peer_)
: peer{peer_} {}
: peer_{peer_} {}
void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override { (void)data; }
@ -64,24 +64,24 @@ private:
private:
StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT> &peer;
BufferT> &peer_;
};
private:
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>>
incoming_feeder = nullptr;
incoming_feeder_ = nullptr;
Own<AsyncIoStream> io_stream;
Own<AsyncIoStream> io_stream_;
Codec codec;
Codec codec_;
BufferT in_buffer;
BufferT out_buffer;
BufferT in_buffer_;
BufferT out_buffer_;
ConveyorSink sink_read;
ConveyorSink sink_write;
ConveyorSink sink_read_;
ConveyorSink sink_write_;
PeerConveyorFeeder conveyor_feeder;
PeerConveyorFeeder conveyor_feeder_;
};
/**

42
source/forstio/io_peer.tmpl.h
View File

@ -14,19 +14,19 @@ StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>::
StreamingIoPeer(
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed_,
Own<AsyncIoStream> stream_, Codec codec_, BufferT in_, BufferT out_)
: incoming_feeder{std::move(feed_)}, io_stream{std::move(stream_)},
codec{std::move(codec_)}, in_buffer{std::move(in_)}, out_buffer{std::move(
: incoming_feeder_{std::move(feed_)}, io_stream_{std::move(stream_)},
codec_{std::move(codec_)}, in_buffer_{std::move(in_)}, out_buffer_{std::move(
out_)},
sink_read{io_stream->readDone()
sink_read_{io_stream_->readDone()
.then([this](size_t bytes) -> ErrorOr<void> {
in_buffer.writeAdvance(bytes);
in_buffer_.writeAdvance(bytes);
if (in_buffer.writeSegmentLength() == 0) {
if (in_buffer_.writeSegmentLength() == 0) {
return criticalError("Message too long");
}
io_stream->read(&in_buffer.write(), 1,
in_buffer.writeSegmentLength());
io_stream_->read(&in_buffer_.write(), 1,
in_buffer_.writeSegmentLength());
while (true) {
auto root =
@ -34,14 +34,14 @@ StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>::
auto builder = root.build();
Error error =
codec.template decode<Incoming, InContainer>(
builder, in_buffer);
codec_.template decode<Incoming, InContainer>(
builder, in_buffer_);
if (error.isCritical()) {
return error;
}
if (!error.failed()) {
incoming_feeder->feed(std::move(root));
incoming_feeder_->feed(std::move(root));
} else {
break;
}
@ -50,22 +50,22 @@ StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>::
return Void{};
})
.sink([this](Error error) {
incoming_feeder->fail(error.copyError());
incoming_feeder_->fail(error.copyError());
return error;
})},
sink_write{io_stream->writeDone()
sink_write_{io_stream_->writeDone()
.then([this](size_t bytes) -> ErrorOr<void> {
out_buffer.readAdvance(bytes);
if (out_buffer.readCompositeLength() > 0) {
io_stream->write(&out_buffer.read(),
out_buffer.readSegmentLength());
out_buffer_.readAdvance(bytes);
if (out_buffer_.readCompositeLength() > 0) {
io_stream_->write(&out_buffer_.read(),
out_buffer_.readSegmentLength());
}
return Void{};
})
.sink()} {
io_stream->read(&in_buffer.write(), 1, in_buffer.writeSegmentLength());
io_stream_->read(&in_buffer_.write(), 1, in_buffer_.writeSegmentLength());
}
template <typename Codec, typename Incoming, typename Outgoing,
@ -73,16 +73,16 @@ template <typename Codec, typename Incoming, typename Outgoing,
Error StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT>::send(HeapMessageRoot<Outgoing, OutContainer>
msg) {
bool restart_write = out_buffer.readSegmentLength() == 0;
bool restart_write = out_buffer_.readSegmentLength() == 0;
Error error =
codec.template encode<Outgoing, OutContainer>(msg.read(), out_buffer);
codec_.template encode<Outgoing, OutContainer>(msg.read(), out_buffer_);
if (error.failed()) {
return error;
}
if (restart_write) {
io_stream->write(&out_buffer.read(), out_buffer.readSegmentLength());
io_stream_->write(&out_buffer_.read(), out_buffer_.readSegmentLength());
}
return noError();
@ -92,7 +92,7 @@ template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT>
Conveyor<void> StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>::onReadDisconnected() {
return io_stream->onReadDisconnected();
return io_stream_->onReadDisconnected();
}
template <typename Codec, typename Incoming, typename Outgoing,

6
source/forstio/log.h
View File

@ -10,15 +10,15 @@ public:
enum class Type : uint8_t { Info, Warning, Error, Debug };
private:
LogIo &central;
EventLoop &loop;
LogIo &central_;
EventLoop &loop_;
public:
Log(LogIo &central, EventLoop &loop);
};
class LogIo {
private:
EventLoop &loop;
EventLoop &loop_;
public:
LogIo(EventLoop &loop);

152
source/forstio/message.h
View File

@ -17,7 +17,7 @@
namespace saw {
class MessageBase {
protected:
bool set_explicitly = false;
bool set_explicitly_ = false;
public:
template <class T> T &as() {
@ -50,7 +50,7 @@ class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
private:
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
@ -62,12 +62,12 @@ public:
class Reader;
class Builder {
private:
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg) : message{msg} {}
Builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
/*
* Initialize a member by index
@ -79,7 +79,7 @@ public:
typename Container::template ElementType<i>::Builder>::type
init() {
return typename Container::template ElementType<i>::Builder{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
/*
@ -109,7 +109,7 @@ public:
init(size_t size = 0) {
auto array_builder =
typename Container::template ElementType<i>::Builder{
message.container.template get<i>(), size};
message_.container_.template get<i>(), size};
return array_builder;
}
@ -134,12 +134,12 @@ public:
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(MessageType &msg) : message{msg} {}
Reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message}; }
Builder asBuilder() { return Builder{message_}; }
/*
* Get member by index
@ -147,7 +147,7 @@ public:
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
/*
@ -181,7 +181,7 @@ private:
using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
@ -193,12 +193,12 @@ public:
class Reader;
class Builder {
private:
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg) : message{msg} {}
Builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
template <size_t i>
typename std::enable_if<
@ -208,7 +208,7 @@ public:
init() {
return typename Container::template ElementType<i>::Builder{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
template <StringLiteral Literal>
@ -236,7 +236,7 @@ public:
typename Container::template ElementType<i>::Builder>::type
init(size_t size = 0) {
return typename Container::template ElementType<i>::Builder{
message.container.template get<i>(), size};
message_.container_.template get<i>(), size};
}
template <StringLiteral Literal>
@ -257,17 +257,17 @@ public:
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(MessageType &msg) : message{msg} {}
Reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message}; }
Builder asBuilder() { return Builder{message_}; }
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
template <StringLiteral Literal>
@ -286,7 +286,7 @@ public:
return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
}
size_t index() const noexcept { return message.container.index(); }
size_t index() const noexcept { return message_.container_.index(); }
template <StringLiteral Literal> bool hasAlternative() const {
return index() == toIndex<Literal>();
@ -303,7 +303,7 @@ private:
using SchemaType = schema::Array<T>;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same Schema as Message");
@ -315,42 +315,42 @@ public:
class Reader;
class Builder {
private:
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg, size_t size) : message{msg} {
Builder(MessageType &msg, size_t size) : message_{msg} {
if (size > 0) {
message.container.resize(size);
message_.container_.resize(size);
}
}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
typename Container::ElementType::Builder init(size_t i) {
return typename Container::ElementType::Builder{
message.container.get(i)};
message_.container_.get(i)};
}
size_t size() const { return message.container.size(); }
size_t size() const { return message_.container_.size(); }
void resize(size_t size) { message.container.resize(size); }
void resize(size_t size) { message_.container_.resize(size); }
};
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(MessageType &msg) : message{msg} {}
Reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message, 0}; }
Builder asBuilder() { return Builder{message_, 0}; }
typename Container::ElementType::Reader get(size_t i) {
return typename Container::ElementType::Reader{
message.container.get(i)};
message_.container_.get(i)};
}
size_t size() const { return message.container.size(); }
size_t size() const { return message_.container_.size(); }
};
};
@ -363,7 +363,7 @@ private:
using SchemaType = schema::Tuple<T...>;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
@ -374,12 +374,12 @@ private:
public:
class Reader;
class Builder {
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg) : message{msg} {}
Builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
template <size_t i>
typename std::enable_if<
@ -388,7 +388,7 @@ public:
typename Container::template ElementType<i>::Builder>::type
init() {
return typename Container::template ElementType<i>::Builder{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
template <size_t i>
@ -398,22 +398,22 @@ public:
typename Container::template ElementType<i>::Builder>::type
init(size_t size = 0) {
return typename Container::template ElementType<i>::Builder{
message.container.template get<i>(), size};
message_.container_.template get<i>(), size};
}
};
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(MessageType &msg) : message{msg} {}
Reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message}; }
Builder asBuilder() { return Builder{message_}; }
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
message.container.template get<i>()};
message_.container_.template get<i>()};
}
};
};
@ -428,7 +428,7 @@ private:
using SchemaType = schema::Primitive<T, N>;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
@ -440,29 +440,29 @@ public:
class Reader;
class Builder {
private:
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg) : message{msg} {}
Builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
void set(const typename Container::ValueType &value) {
message.container.set(value);
message_.container_.set(value);
}
};
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(Message &msg) : message{msg} {}
Reader(Message &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message}; }
Builder asBuilder() { return Builder{message_}; }
const typename Container::ValueType &get() const {
return message.container.get();
return message_.container_.get();
}
};
};
@ -473,7 +473,7 @@ private:
using SchemaType = schema::String;
using MessageType = Message<SchemaType, Container>;
Container container;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
@ -485,47 +485,47 @@ public:
class Reader;
class Builder {
private:
MessageType &message;
MessageType &message_;
public:
Builder(MessageType &msg) : message{msg} {}
Builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message}; }
Reader asReader() { return Reader{message_}; }
void set(std::string &&str) { message.container.set(std::move(str)); }
void set(const std::string_view str) { message.container.set(str); }
void set(std::string &&str) { message_.container_.set(std::move(str)); }
void set(const std::string_view str) { message_.container_.set(str); }
void set(const char *str) { set(std::string_view{str}); }
};
class Reader {
private:
MessageType &message;
MessageType &message_;
public:
Reader(MessageType &msg) : message{msg} {}
Reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message}; }
Builder asBuilder() { return Builder{message_}; }
const std::string_view get() const { return message.container.get(); }
const std::string_view get() const { return message_.container_.get(); }
};
};
template <class Schema, class Container = MessageContainer<Schema>>
class HeapMessageRoot {
private:
Own<Message<Schema, Container>> root;
Own<Message<Schema, Container>> root_;
public:
HeapMessageRoot(Own<Message<Schema, Container>> r) : root{std::move(r)} {}
HeapMessageRoot(Own<Message<Schema, Container>> r) : root_{std::move(r)} {}
typename Message<Schema, Container>::Builder build() {
assert(root);
return typename Message<Schema, Container>::Builder{*root};
assert(root_);
return typename Message<Schema, Container>::Builder{*root_};
}
typename Message<Schema, Container>::Reader read() {
assert(root);
return typename Message<Schema, Container>::Reader{*root};
assert(root_);
return typename Message<Schema, Container>::Reader{*root_};
}
};
@ -535,19 +535,19 @@ public:
using Schema = schema::Array<T>;
private:
Own<Message<Schema, Container>> root;
Own<Message<Schema, Container>> root_;
public:
HeapMessageRoot(Own<Message<Schema, Container>> r) : root{std::move(r)} {}
HeapMessageRoot(Own<Message<Schema, Container>> r) : root_{std::move(r)} {}
typename Message<Schema, Container>::Builder build(size_t size) {
assert(root);
return typename Message<Schema, Container>::Builder{*root, size};
assert(root_);
return typename Message<Schema, Container>::Builder{*root_, size};
}
typename Message<Schema, Container>::Reader read() {
assert(root);
return typename Message<Schema, Container>::Reader{*root};
assert(root_);
return typename Message<Schema, Container>::Reader{*root_};
}
};

47
source/forstio/message_container.h
View File

@ -2,6 +2,9 @@
#include "schema.h"
#include <variant>
#include <vector>
namespace saw {
template <class T> class MessageContainer;
@ -69,7 +72,7 @@ template <class... V, StringLiteral... Keys>
class MessageContainer<schema::Struct<schema::NamedMember<V, Keys>...>> {
private:
using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
ValueType values;
ValueType values_;
public:
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
@ -78,7 +81,7 @@ public:
using ElementType = typename MessageParameterPackType<
i, Message<V, MessageContainer<V>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values); }
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
};
/*
@ -88,7 +91,7 @@ template <class... V, StringLiteral... Keys>
class MessageContainer<schema::Union<schema::NamedMember<V, Keys>...>> {
private:
using ValueType = std::variant<Message<V, MessageContainer<V>>...>;
ValueType value;
ValueType value_;
public:
using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
@ -98,14 +101,14 @@ public:
i, Message<V, MessageContainer<V>>...>::Type;
template <size_t i> ElementType<i> &get() {
if (i != value.index()) {
if (i != value_.index()) {
using MessageIV = typename MessageParameterPackType<i, V...>::Type;
value = Message<MessageIV, MessageContainer<MessageIV>>{};
value_ = Message<MessageIV, MessageContainer<MessageIV>>{};
}
return std::get<i>(value);
return std::get<i>(value_);
}
size_t index() const noexcept { return value.index(); }
size_t index() const noexcept { return value_.index(); }
};
/*
@ -115,7 +118,7 @@ public:
template <class T> class MessageContainer<schema::Array<T>> {
private:
using ValueType = std::vector<Message<T, MessageContainer<T>>>;
ValueType values;
ValueType values_;
public:
using SchemaType = schema::Array<T>;
@ -123,12 +126,12 @@ public:
using ElementType = Message<T, MessageContainer<T>>;
Message<T, MessageContainer<T>> &get(size_t index) {
return values.at(index);
return values_.at(index);
}
void resize(size_t size) { values.resize(size); }
void resize(size_t size) { values_.resize(size); }
size_t size() const { return values.size(); }
size_t size() const { return values_.size(); }
};
/*
@ -137,7 +140,7 @@ public:
template <class... T> class MessageContainer<schema::Tuple<T...>> {
private:
using ValueType = std::tuple<Message<T, MessageContainer<T>>...>;
ValueType values;
ValueType values_;
public:
using SchemaType = schema::Tuple<T...>;
@ -146,7 +149,7 @@ public:
using ElementType = typename MessageParameterPackType<
i, Message<T, MessageContainer<T>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values); }
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
};
/*
@ -212,14 +215,14 @@ public:
typename PrimitiveTypeHelper<schema::Primitive<T, N>>::Type;
private:
ValueType value;
ValueType value_;
public:
MessageContainer() : value{0} {}
MessageContainer() : value_{0} {}
void set(const ValueType &v) { value = v; }
void set(const ValueType &v) { value_ = v; }
const ValueType &get() const { return value; }
const ValueType &get() const { return value_; }
};
template <> class MessageContainer<schema::String> {
@ -229,13 +232,13 @@ public:
using ValueViewType = std::string_view;
private:
ValueType value;
ValueType value_;
public:
void set(ValueType &&v) { value = std::move(v); }
void set(const ValueType &v) { value = v; }
void set(const ValueViewType v) { value = std::string{v}; }
void set(ValueType &&v) { value_ = std::move(v); }
void set(const ValueType &v) { value_ = v; }
void set(const ValueViewType v) { value_ = std::string{v}; }
const ValueType &get() const { return value; }
const ValueType &get() const { return value_; }
};
} // namespace saw