From 947004fd655792f3cb503e50a4192d62e4f3bd5c Mon Sep 17 00:00:00 2001 From: Claudius Holeksa Date: Mon, 5 Dec 2022 01:49:38 +0100 Subject: [PATCH] in process Camel to snake case --- .clang-tidy | 8 + SConstruct | 16 +- driver/io-unix.cpp | 42 +- source/forstio/async.cpp | 163 ++++---- source/forstio/async.h | 765 ++++++++++++++++++------------------ source/forstio/async.tmpl.h | 458 ++++++++++----------- source/forstio/common.h | 32 +- source/forstio/error.cpp | 50 +-- source/forstio/error.h | 127 +++--- 9 files changed, 856 insertions(+), 805 deletions(-) create mode 100644 .clang-tidy diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 0000000..25d1993 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,8 @@ +Checks: '-*,readability-identifier-naming' +CheckOptions: + - { key: readability-identifier-naming.NamespaceCase, value: lower_case } + - { key: readability-identifier-naming.ClassCase, value: lower_case } + - { key: readability-identifier-naming.StructCase, value: lower_case } + - { key: readability-identifier-naming.FunctionCase, value: lower_case } + - { key: readability-identifier-naming.VariableCase, value: lower_case } + - { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE } diff --git a/SConstruct b/SConstruct index f023fea..1c9c46e 100644 --- a/SConstruct +++ b/SConstruct @@ -32,16 +32,18 @@ def add_kel_source_files(self, sources, filetype, lib_env=None, shared=False, ta def isAbsolutePath(key, dirname, env): assert os.path.isabs(dirname), "%r must have absolute path syntax" % (key,) +## Environment variables env_vars = Variables( args=ARGUMENTS ) - env_vars.Add('prefix', help='Installation target location of build results and headers', default='/usr/local/', validator=isAbsolutePath ) +## Environment setup + env=Environment(ENV=os.environ, variables=env_vars, CPPPATH=['#source/forstio','#source','#','#driver'], CXX='clang++', CPPDEFINES=['SAW_UNIX'], @@ -73,15 +75,23 @@ env.Alias('test', env.test_program) # Clang format part env.Append(BUILDERS={'ClangFormat' : Builder(action = 'clang-format --style=file -i $SOURCE')}) +env.Append(BUILDERS={'ClangTidyFix' : Builder(action = 'clang-tidy -extra-arg-before=-xc++ --fix $SOURCE -- -std=c++17 -DSAW_UNIX -Isource')}) env.format_actions = [] def format_iter(env,files): for f in files: - env.format_actions.append(env.AlwaysBuild(env.ClangFormat(target=f+"-clang-format",source=f))) + env.format_actions.append(env.AlwaysBuild(env.ClangFormat(target=f+"-clang-format",source=f))); + pass + +env.tidy_actions = [] +def tidy_iter(env,files): + for f in files: + env.tidy_actions.append(env.AlwaysBuild(env.ClangTidyFix(target=f+"-clang-tidy-fix",source=f))); pass format_iter(env,env.sources + env.driver_sources + env.headers + env.driver_headers) -env.Alias('format', env.format_actions) +env.Alias('format', env.format_actions); +env.Alias('tidy', env.tidy_actions); env.Alias('cdb', env.cdb); env.Alias('all', ['format', 'library', 'test']) diff --git a/driver/io-unix.cpp b/driver/io-unix.cpp index 3767a8c..65973a5 100644 --- a/driver/io-unix.cpp +++ b/driver/io-unix.cpp @@ -1,4 +1,4 @@ -#include "driver/io-unix.h" +#include "io-unix.h" #include @@ -129,7 +129,7 @@ UnixDatagram::UnixDatagram(UnixEventPort &event_port, int file_descriptor, : IFdOwner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {} namespace { -ssize_t unixReadMsg(int fd, void *buffer, size_t length) { +ssize_t unix_read_msg(int fd, void *buffer, size_t length) { struct ::sockaddr_storage their_addr; socklen_t addr_len = sizeof(sockaddr_storage); return ::recvfrom(fd, buffer, length, 0, @@ -137,15 +137,15 @@ ssize_t unixReadMsg(int fd, void *buffer, size_t length) { &addr_len); } -ssize_t unixWriteMsg(int fd, const void *buffer, size_t length, - ::sockaddr *dest_addr, socklen_t dest_addr_len) { +ssize_t unix_write_msg(int fd, const void *buffer, size_t length, + ::sockaddr *dest_addr, socklen_t dest_addr_len) { return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len); } } // namespace ErrorOr UnixDatagram::read(void *buffer, size_t length) { - ssize_t read_bytes = unixReadMsg(fd(), buffer, length); + ssize_t read_bytes = unix_read_msg(fd(), buffer, length); if (read_bytes > 0) { return static_cast(read_bytes); } @@ -163,8 +163,8 @@ ErrorOr UnixDatagram::write(const void *buffer, size_t length, UnixNetworkAddress &unix_dest = static_cast(dest); SocketAddress &sock_addr = unix_dest.unixAddress(); socklen_t sock_addr_length = sock_addr.getRawLength(); - ssize_t write_bytes = unixWriteMsg(fd(), buffer, length, sock_addr.getRaw(), - sock_addr_length); + ssize_t write_bytes = unix_write_msg(fd(), buffer, length, + sock_addr.getRaw(), sock_addr_length); if (write_bytes > 0) { return static_cast(write_bytes); } @@ -192,14 +192,14 @@ void UnixDatagram::notify(uint32_t mask) { } namespace { -bool beginsWith(const std::string_view &viewed, - const std::string_view &begins) { +bool string_view_begins_with(const std::string_view &viewed, + const std::string_view &begins) { return viewed.size() >= begins.size() && viewed.compare(0, begins.size(), begins) == 0; } std::variant -translateNetworkAddressToUnixNetworkAddress(NetworkAddress &addr) { +translate_network_address_to_unix_network_address(NetworkAddress &addr) { auto addr_variant = addr.representation(); std::variant os_addr = std::visit( [](auto &arg) @@ -220,7 +220,7 @@ translateNetworkAddressToUnixNetworkAddress(NetworkAddress &addr) { return os_addr; } -UnixNetworkAddress &translateToUnixAddressRef( +UnixNetworkAddress &translate_to_unix_address_ref( std::variant &addr_variant) { return std::visit( [](auto &arg) -> UnixNetworkAddress & { @@ -240,8 +240,10 @@ UnixNetworkAddress &translateToUnixAddressRef( } // namespace Own UnixNetwork::listen(NetworkAddress &addr) { - auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); - UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage); + auto unix_addr_storage = + translate_network_address_to_unix_network_address(addr); + UnixNetworkAddress &address = + translate_to_unix_address_ref(unix_addr_storage); assert(address.unixAddressSize() > 0); if (address.unixAddressSize() == 0) { @@ -272,8 +274,10 @@ Own UnixNetwork::listen(NetworkAddress &addr) { } Conveyor> UnixNetwork::connect(NetworkAddress &addr) { - auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); - UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage); + auto unix_addr_storage = + translate_network_address_to_unix_network_address(addr); + UnixNetworkAddress &address = + translate_to_unix_address_ref(unix_addr_storage); assert(address.unixAddressSize() > 0); if (address.unixAddressSize() == 0) { @@ -332,8 +336,10 @@ Conveyor> UnixNetwork::connect(NetworkAddress &addr) { } Own UnixNetwork::datagram(NetworkAddress &addr) { - auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); - UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage); + auto unix_addr_storage = + translate_network_address_to_unix_network_address(addr); + UnixNetworkAddress &address = + translate_to_unix_address_ref(unix_addr_storage); SAW_ASSERT(address.unixAddressSize() > 0) { return nullptr; } @@ -375,7 +381,7 @@ UnixNetwork::resolveAddress(const std::string &path, uint16_t port_hint) { std::string_view addr_view{path}; { std::string_view begins_with = "unix:"; - if (beginsWith(addr_view, begins_with)) { + if (string_view_begins_with(addr_view, begins_with)) { addr_view.remove_prefix(begins_with.size()); } } diff --git a/source/forstio/async.cpp b/source/forstio/async.cpp index 79fc2c4..2c03f87 100644 --- a/source/forstio/async.cpp +++ b/source/forstio/async.cpp @@ -7,38 +7,38 @@ namespace saw { namespace { -thread_local EventLoop *local_loop = nullptr; +thread_local event_loop *local_loop = nullptr; -EventLoop ¤tEventLoop() { - EventLoop *loop = local_loop; +event_loop ¤t_event_loop() { + event_loop *loop = local_loop; assert(loop); return *loop; } } // namespace -ConveyorNode::ConveyorNode() {} +conveyor_node::conveyor_node() {} -ConveyorNodeWithChildMixin::ConveyorNodeWithChildMixin( - Own &&child_, ConveyorNode &owner) +conveyor_node_with_child_mixin::conveyor_node_with_child_mixin( + own &&child_, conveyor_node &owner) : child{std::move(child_)} { assert(child); child->notifyParentAttached(owner); } -ErrorOr> -ConveyorNodeWithChildMixin::swapChild(Own &&swapee) { +error_or> +conveyor_node_with_child_mixin::swap_child(own &&swapee) { SAW_ASSERT(child) { - return criticalError("Child should exist if this function is called"); + return criticalerror("Child should exist if this function is called"); } - Own old_child = std::move(child); + own old_child = std::move(child); /** * We need the parent of the old_child's next storage */ - ConveyorStorage *old_storage = old_child->nextStorage(); - ConveyorStorage *old_storage_parent = old_storage ? old_storage->getParent() - : nullptr; + conveyor_storage *old_storage = old_child->nextStorage(); + conveyor_storage *old_storage_parent = + old_storage ? old_storage->getParent() : nullptr; /** * Swap in the new child @@ -51,7 +51,7 @@ ConveyorNodeWithChildMixin::swapChild(Own &&swapee) { * storage has a nullptr set And if the old_storage_parent is a nullptr, * then it doesn't matter. So we don't check for it */ - ConveyorStorage *swapee_storage = child->nextStorage(); + conveyor_storage *swapee_storage = child->nextStorage(); if (swapee_storage) { swapee_storage->setParent(old_storage_parent); } @@ -60,13 +60,13 @@ ConveyorNodeWithChildMixin::swapChild(Own &&swapee) { return old_child; } -ConveyorStorage::ConveyorStorage() {} +conveyor_storage::conveyor_storage() {} -ConveyorStorage::~ConveyorStorage() {} +conveyor_storage::~conveyor_storage() {} -ConveyorStorage *ConveyorStorage::getParent() const { return parent; } +conveyor_storage *conveyor_storage::getParent() const { return parent; } -void ConveyorEventStorage::setParent(ConveyorStorage *p) { +void conveyor_event_storage::setParent(conveyor_storage *p) { /* * parent check isn't needed, but is used * for the assert, because the storage should @@ -83,24 +83,24 @@ void ConveyorEventStorage::setParent(ConveyorStorage *p) { parent = p; } -ConveyorEventStorage::ConveyorEventStorage() : ConveyorStorage{} {} +conveyor_event_storage::conveyor_event_storage() : conveyor_storage{} {} -ConveyorBase::ConveyorBase(Own &&node_p) +conveyor_base::conveyor_base(own &&node_p) : node{std::move(node_p)} {} -Error PropagateError::operator()(const Error &error) const { - return error.copyError(); +error propagate_error::operator()(const error &error) const { + return error.copyerror(); } -Error PropagateError::operator()(Error &&error) { return std::move(error); } +error propagate_error::operator()(error &&error) { return std::move(error); } -Event::Event() : Event(currentEventLoop()) {} +event::event() : event(current_event_loop()) {} -Event::Event(EventLoop &loop) : loop{loop} {} +event::event(event_loop &loop) : loop{loop} {} -Event::~Event() { disarm(); } +event::~event() { disarm(); } -void Event::armNext() { +void event::armNext() { assert(&loop == local_loop); if (prev == nullptr) { // Push the next_insert_point back by one @@ -133,7 +133,7 @@ void Event::armNext() { } } -void Event::armLater() { +void event::armLater() { assert(&loop == local_loop); if (prev == nullptr) { @@ -153,7 +153,7 @@ void Event::armLater() { } } -void Event::armLast() { +void event::armLast() { assert(&loop == local_loop); if (prev == nullptr) { @@ -172,7 +172,7 @@ void Event::armLast() { } } -void Event::disarm() { +void event::disarm() { if (prev != nullptr) { if (loop.tail == &next) { loop.tail = prev; @@ -192,33 +192,33 @@ void Event::disarm() { } } -bool Event::isArmed() const { return prev != nullptr; } +bool event::isArmed() const { return prev != nullptr; } -ConveyorSink::ConveyorSink() : node{nullptr} {} +conveyorSink::conveyorSink() : node{nullptr} {} -ConveyorSink::ConveyorSink(Own &&node_p) +conveyorSink::conveyorSink(own &&node_p) : node{std::move(node_p)} {} -void EventLoop::setRunnable(bool runnable) { is_runnable = runnable; } +void event_loop::setRunnable(bool runnable) { is_runnable = runnable; } -EventLoop::EventLoop() {} +event_loop::event_loop() {} -EventLoop::EventLoop(Own &&event_port) +event_loop::event_loop(own &&event_port) : event_port{std::move(event_port)} {} -EventLoop::~EventLoop() { assert(local_loop != this); } +event_loop::~event_loop() { assert(local_loop != this); } -void EventLoop::enterScope() { +void event_loop::enterScope() { assert(!local_loop); local_loop = this; } -void EventLoop::leaveScope() { +void event_loop::leaveScope() { assert(local_loop == this); local_loop = nullptr; } -bool EventLoop::turnLoop() { +bool event_loop::turnLoop() { size_t turn_step = 0; while (head && turn_step < 65536) { if (!turn()) { @@ -229,8 +229,8 @@ bool EventLoop::turnLoop() { return true; } -bool EventLoop::turn() { - Event *event = head; +bool event_loop::turn() { + event *event = head; if (!event) { return false; @@ -259,7 +259,7 @@ bool EventLoop::turn() { return true; } -bool EventLoop::wait(const std::chrono::steady_clock::duration &duration) { +bool event_loop::wait(const std::chrono::steady_clock::duration &duration) { if (event_port) { event_port->wait(duration); } @@ -267,7 +267,7 @@ bool EventLoop::wait(const std::chrono::steady_clock::duration &duration) { return turnLoop(); } -bool EventLoop::wait(const std::chrono::steady_clock::time_point &time_point) { +bool event_loop::wait(const std::chrono::steady_clock::time_point &time_point) { if (event_port) { event_port->wait(time_point); } @@ -275,7 +275,7 @@ bool EventLoop::wait(const std::chrono::steady_clock::time_point &time_point) { return turnLoop(); } -bool EventLoop::wait() { +bool event_loop::wait() { if (event_port) { event_port->wait(); } @@ -283,7 +283,7 @@ bool EventLoop::wait() { return turnLoop(); } -bool EventLoop::poll() { +bool event_loop::poll() { if (event_port) { event_port->poll(); } @@ -291,16 +291,16 @@ bool EventLoop::poll() { return turnLoop(); } -EventPort *EventLoop::eventPort() { return event_port.get(); } +eventPort *event_loop::eventPort() { return event_port.get(); } -ConveyorSinkSet &EventLoop::daemon() { +conveyor_sink_set &event_loop::daemon() { if (!daemon_sink) { - daemon_sink = heap(); + daemon_sink = heap(); } return *daemon_sink; } -WaitScope::WaitScope(EventLoop &loop) : loop{loop} { loop.enterScope(); } +WaitScope::WaitScope(event_loop &loop) : loop{loop} { loop.enterScope(); } WaitScope::~WaitScope() { loop.leaveScope(); } @@ -316,29 +316,29 @@ void WaitScope::wait(const std::chrono::steady_clock::time_point &time_point) { void WaitScope::poll() { loop.poll(); } -ErrorOr> -ConvertConveyorNodeBase::swapChild(Own &&swapee) noexcept { - return child_mixin.swapChild(std::move(swapee)); +error_or> +convert_conveyor_node_base::swap_child(own &&swapee) noexcept { + return child_mixin.swap_child(std::move(swapee)); } -ConveyorStorage *ConvertConveyorNodeBase::nextStorage() noexcept { +conveyor_storage *convert_conveyor_node_base::nextStorage() noexcept { if (!child_mixin.child) { return nullptr; } return child_mixin.child->nextStorage(); } -ImmediateConveyorNodeBase::ImmediateConveyorNodeBase() - : ConveyorEventStorage{} {} +Immediateconveyor_nodeBase::Immediateconveyor_nodeBase() + : conveyor_event_storage{} {} -MergeConveyorNodeBase::MergeConveyorNodeBase() : ConveyorEventStorage{} {} +Mergeconveyor_nodeBase::Mergeconveyor_nodeBase() : conveyor_event_storage{} {} -ErrorOr> -QueueBufferConveyorNodeBase::swapChild(Own &&swapee_) noexcept { - return child_mixin.swapChild(std::move(swapee_)); +error_or> QueueBufferconveyor_nodeBase::swap_child( + own &&swapee_) noexcept { + return child_mixin.swap_child(std::move(swapee_)); } -void ConveyorSinkSet::destroySinkConveyorNode(ConveyorNode &node) { +void conveyor_sink_set::destroysink_conveyor_node(conveyor_node &node) { if (!isArmed()) { armLast(); } @@ -346,20 +346,21 @@ void ConveyorSinkSet::destroySinkConveyorNode(ConveyorNode &node) { delete_nodes.push(&node); } -void ConveyorSinkSet::fail(Error &&error) { +void conveyor_sink_set::fail(error &&error) { /// @todo call error_handler } -ConveyorSinkSet::ConveyorSinkSet(EventLoop &event_loop) : Event{event_loop} {} +conveyor_sink_set::conveyor_sink_set(event_loop &event_loop) + : event{event_loop} {} -void ConveyorSinkSet::add(Conveyor &&sink) { - auto nas = Conveyor::fromConveyor(std::move(sink)); +void conveyor_sink_set::add(conveyor &&sink) { + auto nas = conveyor::fromconveyor(std::move(sink)); SAW_ASSERT(nas) { return; } - ConveyorStorage *storage = nas->nextStorage(); + conveyor_storage *storage = nas->nextStorage(); - Own sink_node = nullptr; + own sink_node = nullptr; try { - sink_node = heap(std::move(nas), *this); + sink_node = heap(std::move(nas), *this); } catch (std::bad_alloc &) { return; } @@ -370,36 +371,36 @@ void ConveyorSinkSet::add(Conveyor &&sink) { sink_nodes.emplace_back(std::move(sink_node)); } -void ConveyorSinkSet::fire() { +void conveyor_sink_set::fire() { while (!delete_nodes.empty()) { - ConveyorNode *node = delete_nodes.front(); + conveyor_node *node = delete_nodes.front(); /*auto erased = */ std::remove_if(sink_nodes.begin(), sink_nodes.end(), - [node](Own &element) { + [node](own &element) { return node == element.get(); }); delete_nodes.pop(); } } -ConvertConveyorNodeBase::ConvertConveyorNodeBase(Own &&dep) +convert_conveyor_node_base::convert_conveyor_node_base(own &&dep) : child_mixin{std::move(dep), *this} {} -void ConvertConveyorNodeBase::getResult(ErrorOrValue &err_or_val) { +void convert_conveyor_node_base::getResult(error_or_value &err_or_val) { getImpl(err_or_val); } -void AttachConveyorNodeBase::getResult(ErrorOrValue &err_or_val) noexcept { +void attach_conveyor_node_base::getResult(error_or_value &err_or_val) noexcept { if (child_mixin.child) { child_mixin.child->getResult(err_or_val); } } -ErrorOr> -AttachConveyorNodeBase::swapChild(Own &&swapee_) noexcept { - return child_mixin.swapChild(std::move(swapee_)); +error_or> +attach_conveyor_node_base::swap_child(own &&swapee_) noexcept { + return child_mixin.swap_child(std::move(swapee_)); } -ConveyorStorage *AttachConveyorNodeBase::nextStorage() noexcept { +conveyor_storage *attach_conveyor_node_base::nextStorage() noexcept { if (!child_mixin.child) { return nullptr; } @@ -407,9 +408,9 @@ ConveyorStorage *AttachConveyorNodeBase::nextStorage() noexcept { return child_mixin.child->nextStorage(); } -void detachConveyor(Conveyor &&conveyor) { - EventLoop &loop = currentEventLoop(); - ConveyorSinkSet &sink = loop.daemon(); +void detach_conveyor(conveyor &&conveyor) { + event_loop &loop = current_event_loop(); + conveyor_sink_set &sink = loop.daemon(); sink.add(std::move(conveyor)); } } // namespace saw diff --git a/source/forstio/async.h b/source/forstio/async.h index eb7dc83..a24a596 100644 --- a/source/forstio/async.h +++ b/source/forstio/async.h @@ -11,220 +11,222 @@ #include namespace saw { -class ConveyorStorage; -class ConveyorNode { +class conveyor_storage; +class conveyor_node { public: - ConveyorNode(); - virtual ~ConveyorNode() = default; + conveyor_node(); + virtual ~conveyor_node() = default; /** * Internal method to retrieve results from children */ - virtual void getResult(ErrorOrValue &err_or_val) = 0; + virtual void get_result(error_or_value &err_or_val) = 0; /** * Swap out child with another one */ - virtual ErrorOr> - swapChild(Own &&swapee_) = 0; + virtual error_or> + swap_child(own &&swapee_) = 0; /** * Retrieve the next storage node */ - virtual ConveyorStorage *nextStorage() = 0; + virtual conveyor_storage *next_storage() = 0; /** * Notify that a new parent was attached * Only relevant for the feeding nodes */ - virtual void notifyParentAttached(ConveyorNode &){}; + virtual void notify_parent_attached(conveyor_node &){}; }; -class ConveyorNodeWithChildMixin final { +class conveyor_node_with_child_mixin final { public: - Own child = nullptr; + own child = nullptr; - ConveyorNodeWithChildMixin(Own &&child_, - ConveyorNode &owner_); - ~ConveyorNodeWithChildMixin() = default; + conveyor_node_with_child_mixin(own &&child_, + conveyor_node &owner_); + ~conveyor_node_with_child_mixin() = default; /** * Swap out children and return the child ptr, since the caller is the child * itself. Stack needs to be cleared before the child is destroyed, so the * swapped out node is returned as well. */ - ErrorOr> swapChild(Own &&swapee); + error_or> swap_child(own &&swapee); }; -class ConveyorNodeWithParentMixin final { +class conveyor_node_with_parent_mixin final { public: - ConveyorNode *parent = nullptr; + conveyor_node *parent = nullptr; - ErrorOr> swapChildOfParent(Own &&swapee) { + error_or> + swap_child_of_parent(own &&swapee) { SAW_ASSERT(parent) { - return criticalError( + return critical_error( "Can't swap child, because parent doesn't exist"); } - return parent->swapChild(std::move(swapee)); + return parent->swap_child(std::move(swapee)); } - void changeParent(ConveyorNode *p) { parent = p; } + void change_parent(conveyor_node *p) { parent = p; } }; -class EventLoop; -class WaitScope; +class event_loop; +class wait_scope; /* * Event class similar to capn'proto. * https://github.com/capnproto/capnproto */ -class Event { +class event { private: - EventLoop &loop; - Event **prev = nullptr; - Event *next = nullptr; + event_loop &loop; + event **prev = nullptr; + event *next = nullptr; - friend class EventLoop; + friend class event_loop; public: - Event(); - Event(EventLoop &loop); - virtual ~Event(); + event(); + event(event_loop &loop); + virtual ~event(); virtual void fire() = 0; - void armNext(); - void armLater(); - void armLast(); + void arm_next(); + void arm_later(); + void arm_last(); void disarm(); - bool isArmed() const; + bool is_armed() const; }; -class ConveyorStorage { +class conveyor_storage { protected: - ConveyorStorage *parent = nullptr; + conveyor_storage *parent = nullptr; public: - ConveyorStorage(); - virtual ~ConveyorStorage(); + conveyor_storage(); + virtual ~conveyor_storage(); virtual size_t space() const = 0; virtual size_t queued() const = 0; - virtual void childHasFired() = 0; - virtual void parentHasFired() = 0; + virtual void child_has_fired() = 0; + virtual void parent_has_fired() = 0; - virtual void setParent(ConveyorStorage *parent) = 0; - ConveyorStorage *getParent() const; + virtual void set_parent(conveyor_storage *parent) = 0; + conveyor_storage *get_parent() const; }; -class ConveyorEventStorage : public ConveyorStorage, public Event { +class conveyor_event_storage : public conveyor_storage, public event { public: - ConveyorEventStorage(); - virtual ~ConveyorEventStorage() = default; + conveyor_event_storage(); + virtual ~conveyor_event_storage() = default; - void setParent(ConveyorStorage *parent) override; + void set_parent(conveyor_storage *parent) override; }; -class ConveyorBase { +class conveyor_base { protected: - Own node; + own node; public: - ConveyorBase(Own &&node_p); - virtual ~ConveyorBase() = default; + conveyor_base(own &&node_p); + virtual ~conveyor_base() = default; - ConveyorBase(ConveyorBase &&) = default; - ConveyorBase &operator=(ConveyorBase &&) = default; + conveyor_base(conveyor_base &&) = default; + conveyor_base &operator=(conveyor_base &&) = default; - void get(ErrorOrValue &err_or_val); + void get(error_or_value &err_or_val); }; -template class Conveyor; +template class conveyor; -template Conveyor chainedConveyorType(T *); +template conveyor chained_conveyor_type(T *); -// template Conveyor chainedConveyorType(Conveyor *); +// template conveyor chainedconveyorType(conveyor *); -template T removeErrorOrType(T *); +template T remove_error_or_type(T *); -template T removeErrorOrType(ErrorOr *); +template T remove_error_or_type(error_or *); template -using RemoveErrorOr = decltype(removeErrorOrType((T *)nullptr)); +using remove_error_or = decltype(removeerror_orType((T *)nullptr)); template -using ChainedConveyors = decltype(chainedConveyorType((T *)nullptr)); +using chained_conveyors = decltype(chainedconveyorType((T *)nullptr)); template -using ConveyorResult = ChainedConveyors>>; +using conveyor_result = + chained_conveyors>>; -struct PropagateError { +struct propagate_error { public: - Error operator()(const Error &error) const; - Error operator()(Error &&error); + error operator()(const error &error) const; + error operator()(error &&error); }; -class ConveyorSink { +class conveyor_sink { private: - Own node; + own node; public: - ConveyorSink(); - ConveyorSink(Own &&node); + conveyor_sink(); + conveyor_sink(own &&node); - ConveyorSink(ConveyorSink &&) = default; - ConveyorSink &operator=(ConveyorSink &&) = default; + conveyor_sink(conveyor_sink &&) = default; + conveyor_sink &operator=(conveyor_sink &&) = default; }; -template class MergeConveyorNodeData; +template class merge_conveyor_node_data; -template class MergeConveyor { +template class merge_conveyor { private: - Lent> data; + lent> data; public: - MergeConveyor() = default; - MergeConveyor(Lent> d); - ~MergeConveyor(); + merge_conveyor() = default; + merge_conveyor(lent> d); + ~merge_conveyor(); - void attach(Conveyor conveyor); + void attach(conveyor conveyor); }; /** * Main interface for async operations. */ -template class Conveyor final : public ConveyorBase { +template class conveyor final : public conveyor_base { public: /** * Construct an immediately fulfilled node */ - Conveyor(FixVoid value); + conveyor(fix_void value); /** * Construct an immediately failed node */ - Conveyor(Error &&error); + conveyor(error &&error); /** * Construct a conveyor with a child node */ - Conveyor(Own node_p); + conveyor(own node_p); - Conveyor(Conveyor &&) = default; - Conveyor &operator=(Conveyor &&) = default; + conveyor(conveyor &&) = default; + conveyor &operator=(conveyor &&) = default; /** * This method converts values or errors from children */ - template - [[nodiscard]] ConveyorResult - then(Func &&func, ErrorFunc &&error_func = PropagateError()); + template + [[nodiscard]] conveyor_result + then(Func &&func, errorFunc &&error_func = propagate_error()); /** * This method adds a buffer node in the conveyor chains which acts as a * scheduler interrupt point and collects elements up to the supplied limit. */ - [[nodiscard]] Conveyor + [[nodiscard]] conveyor buffer(size_t limit = std::numeric_limits::max()); /** @@ -233,7 +235,7 @@ public: * Useful for resource lifetime control. */ template - [[nodiscard]] Conveyor attach(Args &&...args); + [[nodiscard]] conveyor attach(Args &&...args); /** @todo implement * This method limits the total amount of passed elements @@ -241,89 +243,90 @@ public: * If you meant to fork it and destroy paths you shouldn't place * an interrupt point between the fork and this limiter */ - [[nodiscard]] Conveyor limit(size_t val = 1); + [[nodiscard]] conveyor limit(size_t val = 1); /** * */ - [[nodiscard]] std::pair, MergeConveyor> merge(); + [[nodiscard]] std::pair, merge_conveyor> merge(); /** * Moves the conveyor chain into a thread local storage point which drops * every element. Use sink() if you want to control the lifetime of a * conveyor chain */ - template - void detach(ErrorFunc &&err_func = PropagateError()); + template + void detach(errorFunc &&err_func = propagate_error()); /** * Creates a local sink which drops elements, but lifetime control remains * in your hand. */ - template - [[nodiscard]] ConveyorSink sink(ErrorFunc &&error_func = PropagateError()); + template + [[nodiscard]] conveyor_sink + sink(errorFunc &&error_func = propagate_error()); /** * If no sink() or detach() is used you have to take elements out of the * chain yourself. */ - ErrorOr> take(); + error_or> take(); /** @todo implement * Specifically pump elements through this chain with the provided * wait_scope */ - void poll(WaitScope &wait_scope); + void poll(wait_scope &wait_scope); // helper - static Conveyor toConveyor(Own node); + static conveyor to_conveyor(own node); // helper - static Own fromConveyor(Conveyor conveyor); + static own from_conveyor(conveyor conveyor); }; -template ConveyorResult execLater(Func &&func); +template conveyor_result exec_later(Func &&func); /* - * Join Conveyors into a single one + * Join conveyors into a single one */ template -Conveyor> -joinConveyors(std::tuple...> &conveyors); +conveyor> +join_conveyors(std::tuple...> &conveyors); -template class ConveyorFeeder { +template class conveyor_feeder { public: - virtual ~ConveyorFeeder() = default; + virtual ~conveyor_feeder() = default; virtual void feed(T &&data) = 0; - virtual void fail(Error &&error) = 0; + virtual void fail(error &&error) = 0; virtual size_t space() const = 0; virtual size_t queued() const = 0; - virtual Error swap(Conveyor &&conveyor) noexcept = 0; + virtual error swap(conveyor &&conveyor) noexcept = 0; }; -template <> class ConveyorFeeder { +template <> class conveyor_feeder { public: - virtual ~ConveyorFeeder() = default; + virtual ~conveyor_feeder() = default; virtual void feed(Void &&value = Void{}) = 0; - virtual void fail(Error &&error) = 0; + virtual void fail(error &&error) = 0; virtual size_t space() const = 0; virtual size_t queued() const = 0; - virtual Error swap(Conveyor &&conveyor) noexcept = 0; + virtual error swap(conveyor &&conveyor) noexcept = 0; }; -template struct ConveyorAndFeeder { - Own> feeder; - Conveyor conveyor; +template struct conveyor_and_feeder { + own> feeder; + conveyor conveyor; }; -template ConveyorAndFeeder newConveyorAndFeeder(); +template conveyor_and_feeder new_conveyor_and_feeder(); -template ConveyorAndFeeder oneTimeConveyorAndFeeder(); +template conveyor_and_feeder one_time_conveyor_and_feeder(); enum class Signal : uint8_t { Terminate, User1 }; @@ -332,11 +335,11 @@ enum class Signal : uint8_t { Terminate, User1 }; * events which may be signals from the operating system or just other threads. * Default EventPorts are supplied by setupAsyncIo() in io.h */ -class EventPort { +class event_port { public: - virtual ~EventPort() = default; + virtual ~event_port() = default; - virtual Conveyor onSignal(Signal signal) = 0; + virtual conveyor on_signal(Signal signal) = 0; virtual void poll() = 0; virtual void wait() = 0; @@ -346,110 +349,110 @@ public: virtual void wake() = 0; }; -class SinkConveyorNode; +class sink_conveyor_node; -class ConveyorSinkSet final : public Event { +class conveyor_sink_set final : public event { private: /* class Helper final : public Event { private: - void destroySinkConveyorNode(ConveyorNode& sink); - void fail(Error&& error); + void destroysink_conveyor_node(conveyorNode& sink); + void fail(error&& error); - std::vector> sink_nodes; - std::queue delete_nodes; - std::function error_handler; + std::vector> sink_nodes; + std::queue delete_nodes; + std::function error_handler; public: - ConveyorSinks() = default; - ConveyorSinks(EventLoop& event_loop); + conveyorSinks() = default; + conveyorSinks(event_loop& event_loop); - void add(Conveyor node); + void add(conveyor node); void fire() override {} }; - gin::Own helper; + gin::own helper; */ - friend class SinkConveyorNode; + friend class sink_conveyor_node; - void destroySinkConveyorNode(ConveyorNode &sink_node); - void fail(Error &&error); + void destroy_sink_conveyor_node(conveyor_node &sink_node); + void fail(error &&error); - std::list> sink_nodes; + std::list> sink_nodes; - std::queue delete_nodes; + std::queue delete_nodes; - std::function error_handler; + std::function error_handler; public: - // ConveyorSinks(); - // ConveyorSinks(EventLoop& event_loop); - ConveyorSinkSet() = default; - ConveyorSinkSet(EventLoop &event_loop); + // conveyorSinks(); + // conveyorSinks(event_loop& event_loop); + conveyor_sink_set() = default; + conveyor_sink_set(event_loop &event_loop); - void add(Conveyor &&node); + void add(conveyor &&node); void fire() override; }; /* - * EventLoop class similar to capn'proto. + * event_loop class similar to capn'proto. * https://github.com/capnproto/capnproto */ -class EventLoop { +class event_loop { private: - friend class Event; - Event *head = nullptr; - Event **tail = &head; - Event **next_insert_point = &head; - Event **later_insert_point = &head; + friend class event; + event *head = nullptr; + event **tail = &head; + event **next_insert_point = &head; + event **later_insert_point = &head; bool is_runnable = false; - Own event_port = nullptr; + own event_port_ = nullptr; - Own daemon_sink = nullptr; + own daemon_sink = nullptr; // functions - void setRunnable(bool runnable); + void set_runnable(bool runnable); - friend class WaitScope; - void enterScope(); - void leaveScope(); + friend class wait_scope; + void enter_scope(); + void leave_scope(); - bool turnLoop(); + bool turn_loop(); bool turn(); public: - EventLoop(); - EventLoop(Own &&port); - ~EventLoop(); + event_loop(); + event_loop(own &&port); + ~event_loop(); - EventLoop(EventLoop &&) = default; - EventLoop &operator=(EventLoop &&) = default; + event_loop(event_loop &&) = default; + event_loop &operator=(event_loop &&) = default; bool wait(); bool wait(const std::chrono::steady_clock::duration &); bool wait(const std::chrono::steady_clock::time_point &); bool poll(); - EventPort *eventPort(); + event_port *event_port(); - ConveyorSinkSet &daemon(); + conveyor_sink_set &daemon(); }; /* - * WaitScope class similar to capn'proto. + * wait_scope class similar to capn'proto. * https://github.com/capnproto/capnproto */ -class WaitScope { +class wait_scope { private: - EventLoop &loop; + event_loop &loop; public: - WaitScope(EventLoop &loop); - ~WaitScope(); + wait_scope(event_loop &loop); + ~wait_scope(); void wait(); void wait(const std::chrono::steady_clock::duration &); @@ -457,38 +460,38 @@ public: void poll(); }; -template ConveyorResult yieldNext(Func &&func); +template conveyor_result yield_next(Func &&func); -template ConveyorResult yieldLater(Func &&func); +template conveyor_result yield_later(Func &&func); -template ConveyorResult yieldLast(Func &&func); +template conveyor_result yield_last(Func &&func); } // namespace saw // Secret stuff // Aka private semi hidden classes namespace saw { -template struct FixVoidCaller { +template struct fix_void_caller { template static Out apply(Func &func, In &&in) { return func(std::move(in)); } }; -template struct FixVoidCaller { +template struct fix_void_caller { template static Out apply(Func &func, Void &&in) { (void)in; return func(); } }; -template struct FixVoidCaller { +template struct fix_void_caller { template static Void apply(Func &func, In &&in) { func(std::move(in)); return Void{}; } }; -template <> struct FixVoidCaller { +template <> struct fix_void_caller { template static Void apply(Func &func, Void &&in) { (void)in; func(); @@ -496,114 +499,115 @@ template <> struct FixVoidCaller { } }; -template class AdaptConveyorNode; +template class adapt_conveyor_node; template -class AdaptConveyorFeeder final : public ConveyorFeeder> { +class adapt_conveyor_feeder final : public conveyor_feeder> { private: - AdaptConveyorNode *feedee = nullptr; + adapt_conveyor_node *feedee = nullptr; public: - ~AdaptConveyorFeeder(); + ~adapt_conveyor_feeder(); - void setFeedee(AdaptConveyorNode *feedee); + void set_feedee(adapt_conveyor_node *feedee); void feed(T &&value) override; - void fail(Error &&error) override; + void fail(error &&error) override; size_t space() const override; size_t queued() const override; - Error swap(Conveyor &&conv) noexcept override; + error swap(conveyor &&conv) noexcept override; }; template -class AdaptConveyorNode final : public ConveyorNode, - public ConveyorEventStorage { +class adapt_conveyor_node final : public conveyor_node, + public conveyor_event_storage { private: - AdaptConveyorFeeder *feeder = nullptr; + adapt_conveyor_feeder *feeder = nullptr; - std::queue>> storage; + std::queue>> storage; - ConveyorNodeWithParentMixin parent_node; + conveyor_node_with_parent_mixin parent_node; public: - AdaptConveyorNode(); - ~AdaptConveyorNode(); + adapt_conveyor_node(); + ~adapt_conveyor_node(); - void setFeeder(AdaptConveyorFeeder *feeder); + void set_feeder(adapt_conveyor_feeder *feeder); void feed(T &&value); - void fail(Error &&error); + void fail(error &&error); - // ConveyorNode - void getResult(ErrorOrValue &err_or_val) override; + // conveyorNode + void get_result(error_or_value &err_or_val) override; - ErrorOr> - swapChild(Own &&swapee) noexcept override; + error_or> + swap_child(own &&swapee) noexcept override; - ConveyorStorage *nextStorage() noexcept override; - void notifyParentAttached(ConveyorNode &) noexcept override; + conveyor_storage *next_storage() noexcept override; + void notify_parent_attached(conveyor_node &) noexcept override; - // ConveyorStorage + // conveyor_storage size_t space() const override; size_t queued() const override; - void childHasFired() override; - void parentHasFired() override; + void child_has_fired() override; + void parent_has_fired() override; // Event void fire() override; }; -template class OneTimeConveyorNode; +template class OneTimeconveyorNode; template -class OneTimeConveyorFeeder final : public ConveyorFeeder> { +class one_time_conveyor_feeder final : public conveyor_feeder> { private: - OneTimeConveyorNode *feedee = nullptr; + OneTimeconveyorNode *feedee = nullptr; public: - ~OneTimeConveyorFeeder(); + ~one_time_conveyor_feeder(); - void setFeedee(OneTimeConveyorNode *feedee); + void set_feedee(OneTimeconveyorNode *feedee); void feed(T &&value) override; - void fail(Error &&error) override; + void fail(error &&error) override; size_t space() const override; size_t queued() const override; }; template -class OneTimeConveyorNode final : public ConveyorNode, - public ConveyorStorage, - public Event { +class OneTimeconveyorNode final : public conveyor_node, + public conveyor_storage, + public event { private: - OneTimeConveyorFeeder *feeder = nullptr; + one_time_conveyor_feeder *feeder = nullptr; bool passed = false; - Maybe> storage = std::nullopt; + maybe> storage = std::nullopt; public: - ~OneTimeConveyorNode(); + ~OneTimeconveyorNode(); - void setFeeder(OneTimeConveyorFeeder *feeder); + void set_feeder(one_time_conveyor_feeder *feeder); void feed(T &&value); - void fail(Error &&error); + void fail(error &&error); - // ConveyorNode - void getResult(ErrorOrValue &err_or_val) override; + // conveyorNode + void get_result(error_or_value &err_or_val) override; - ErrorOr> swapChild(Own &&swapee) override; + error_or> + swap_child(own &&swapee) override; - // ConveyorStorage + // conveyor_storage size_t space() const override; size_t queued() const override; - void childHasFired() override {} - void parentHasFired() override; + void child_has_fired() override {} + void parent_has_fired() override; // Event void fire() override; @@ -613,156 +617,159 @@ public: * This class buffers and saves incoming elements and acts as an interrupt node * for processing calls */ -class QueueBufferConveyorNodeBase : public ConveyorNode, - public ConveyorEventStorage { +class queue_buffer_conveyor_node_base : public conveyor_node, + public conveyor_event_storage { protected: - ConveyorNodeWithChildMixin child_mixin; + conveyor_node_with_child_mixin child_mixin; public: - QueueBufferConveyorNodeBase(Own child_) - : ConveyorEventStorage{}, child_mixin{std::move(child_), *this} {} - virtual ~QueueBufferConveyorNodeBase() = default; + queue_buffer_conveyor_node_base(own child_) + : conveyor_event_storage{}, child_mixin{std::move(child_), *this} {} + virtual ~queue_buffer_conveyor_node_base() = default; /** * Use mixin */ - ErrorOr> - swapChild(Own &&swapee_) noexcept override; + error_or> + swap_child(own &&swapee_) noexcept override; - ConveyorStorage *nextStorage() noexcept override { - return static_cast(this); + conveyor_storage *next_storage() noexcept override { + return static_cast(this); } }; template -class QueueBufferConveyorNode final : public QueueBufferConveyorNodeBase { +class queue_buffer_conveyor_node final + : public queue_buffer_conveyor_node_base { private: - std::queue> storage; + std::queue> storage; size_t max_store; public: - QueueBufferConveyorNode(Own dep, size_t max_size) - : QueueBufferConveyorNodeBase{std::move(dep)}, max_store{max_size} {} + queue_buffer_conveyor_node(own dep, size_t max_size) + : queue_buffer_conveyor_node_base{std::move(dep)}, max_store{max_size} { + } // Event void fire() override; - // ConveyorNode - void getResult(ErrorOrValue &eov) noexcept override; + // conveyorNode + void get_result(error_or_value &eov) noexcept override; - // ConveyorStorage + // conveyor_storage size_t space() const override; size_t queued() const override; - void childHasFired() override; - void parentHasFired() override; + void child_has_fired() override; + void parent_has_fired() override; }; -class AttachConveyorNodeBase : public ConveyorNode { +class attach_conveyor_node_base : public conveyor_node { protected: - ConveyorNodeWithChildMixin child_mixin; + conveyor_node_with_child_mixin child_mixin; public: - AttachConveyorNodeBase(Own &&child_) + attach_conveyor_node_base(own &&child_) : child_mixin{std::move(child_), *this} {} - virtual ~AttachConveyorNodeBase() = default; + virtual ~attach_conveyor_node_base() = default; - void getResult(ErrorOrValue &err_or_val) noexcept override; + void get_result(error_or_value &err_or_val) noexcept override; /** * Use mixin */ - ErrorOr> - swapChild(Own &&swapee_) noexcept override; + error_or> + swap_child(own &&swapee_) noexcept override; - ConveyorStorage *nextStorage() noexcept override; + conveyor_storage *next_storage() noexcept override; }; template -class AttachConveyorNode final : public AttachConveyorNodeBase { +class attach_conveyor_node final : public attach_conveyor_node_base { public: - AttachConveyorNode(Own &&dep, Args &&...args) - : AttachConveyorNodeBase(std::move(dep)), attached_data{ - std::move(args...)} {} + attach_conveyor_node(own &&dep, Args &&...args) + : attach_conveyor_node_base(std::move(dep)), attached_data{ + std::move(args...)} {} private: std::tuple attached_data; }; -class ConvertConveyorNodeBase : public ConveyorNode { +class convert_conveyor_node_base : public conveyor_node { public: - ConvertConveyorNodeBase(Own &&dep); - virtual ~ConvertConveyorNodeBase() = default; + convert_conveyor_node_base(own &&dep); + virtual ~convert_conveyor_node_base() = default; - void getResult(ErrorOrValue &err_or_val) override; + void get_result(error_or_value &err_or_val) override; - virtual void getImpl(ErrorOrValue &err_or_val) = 0; + virtual void get_impl(error_or_value &err_or_val) = 0; - ErrorOr> - swapChild(Own &&swapee) noexcept override; + error_or> + swap_child(own &&swapee) noexcept override; - ConveyorStorage *nextStorage() noexcept override; + conveyor_storage *next_storage() noexcept override; protected: - ConveyorNodeWithChildMixin child_mixin; + conveyor_node_with_child_mixin child_mixin; }; -template -class ConvertConveyorNode final : public ConvertConveyorNodeBase { +template +class convert_conveyor_node final : public convert_conveyor_node_base { private: Func func; - ErrorFunc error_func; + errorFunc error_func; - static_assert(std::is_same>::value, - "Should never be of type ErrorOr"); + static_assert(std::is_same>::value, + "Should never be of type error_or"); public: - ConvertConveyorNode(Own &&dep, Func &&func, - ErrorFunc &&error_func) - : ConvertConveyorNodeBase(std::move(dep)), func{std::move(func)}, + convert_conveyor_node(own &&dep, Func &&func, + errorFunc &&error_func) + : convert_conveyor_node_base(std::move(dep)), func{std::move(func)}, error_func{std::move(error_func)} {} - void getImpl(ErrorOrValue &err_or_val) noexcept override { - ErrorOr> dep_eov; - ErrorOr>> &eov = - err_or_val.as>>(); + void get_impl(error_or_value &err_or_val) noexcept override { + error_or> dep_eov; + error_or>> &eov = + err_or_val.as>>(); if (child_mixin.child) { - child_mixin.child->getResult(dep_eov); + child_mixin.child->get_result(dep_eov); if (dep_eov.isValue()) { - try { + // try { - eov = FixVoidCaller::apply( - func, std::move(dep_eov.value())); - } catch (const std::bad_alloc &) { - eov = criticalError("Out of memory"); + eov = fix_void_caller::apply( + func, std::move(dep_eov.value())); + /*} catch (const std::bad_alloc &) { + eov = critical_error("Out of memory"); } catch (const std::exception &) { - eov = criticalError( - "Exception in chain occured. Return ErrorOr if you " + eov = critical_error( + "Exception in chain occured. Return error_or if you " "want to handle errors which are recoverable"); } - } else if (dep_eov.isError()) { + */ + } else if (dep_eov.iserror()) { eov = error_func(std::move(dep_eov.error())); } else { - eov = criticalError("No value set in dependency"); + eov = critical_error("No value set in dependency"); } } else { - eov = criticalError("Conveyor doesn't have child"); + eov = critical_error("conveyor doesn't have child"); } } }; -class SinkConveyorNode final : public ConveyorNode, - public ConveyorEventStorage { +class sink_conveyor_node final : public conveyor_node, + public conveyor_event_storage { private: - ConveyorNodeWithChildMixin child_mixin; - ConveyorSinkSet *conveyor_sink; + conveyor_node_with_child_mixin child_mixin; + conveyor_sink_set *conveyor_sink; public: - SinkConveyorNode(Own node, ConveyorSinkSet &conv_sink) - : ConveyorEventStorage{}, child_mixin{std::move(node), *this}, + sink_conveyor_node(own node, conveyor_sink_set &conv_sink) + : conveyor_event_storage{}, child_mixin{std::move(node), *this}, conveyor_sink{&conv_sink} {} - SinkConveyorNode(Own node) - : ConveyorEventStorage{}, child_mixin{std::move(node), *this}, + sink_conveyor_node(own node) + : conveyor_event_storage{}, child_mixin{std::move(node), *this}, conveyor_sink{nullptr} {} // Event only queued if a critical error occured @@ -772,35 +779,35 @@ public: child_mixin.child = nullptr; if (conveyor_sink) { - conveyor_sink->destroySinkConveyorNode(*this); + conveyor_sink->destroy_sink_conveyor_node(*this); conveyor_sink = nullptr; } } - // ConveyorStorage + // conveyor_storage size_t space() const override { return 1; } size_t queued() const override { return 0; } - // ConveyorNode - void getResult(ErrorOrValue &err_or_val) noexcept override { + // conveyorNode + void get_result(error_or_value &err_or_val) noexcept override { err_or_val.as() = - criticalError("In a sink node no result can be returned"); + critical_error("In a sink node no result can be returned"); } - ErrorOr> - swapChild(Own &&swapee) noexcept override { - return child_mixin.swapChild(std::move(swapee)); + error_or> + swap_child(own &&swapee) noexcept override { + return child_mixin.swap_child(std::move(swapee)); } - // ConveyorStorage - void childHasFired() override { + // conveyor_storage + void child_has_fired() override { if (child_mixin.child) { - ErrorOr dep_eov; - child_mixin.child->getResult(dep_eov); - if (dep_eov.isError()) { - if (dep_eov.error().isCritical()) { - if (!isArmed()) { - armLast(); + error_or dep_eov; + child_mixin.child->get_result(dep_eov); + if (dep_eov.is_error()) { + if (dep_eov.error().is_critical()) { + if (!is_armed()) { + arm_last(); } } if (conveyor_sink) { @@ -813,59 +820,59 @@ public: /* * No parent needs to be fired since we always have space */ - void parentHasFired() override {} + void parent_has_fired() override {} - ConveyorStorage *nextStorage() override { + conveyor_storage *next_storage() override { // Should never happen though assert(false); return nullptr; - // return static_cast(this); + // return static_cast(this); } }; -class ImmediateConveyorNodeBase : public ConveyorNode, - public ConveyorEventStorage { +class immediate_conveyor_node_base : public conveyor_node, + public conveyor_event_storage { private: public: - ImmediateConveyorNodeBase(); + immediate_conveyor_node_base(); - virtual ~ImmediateConveyorNodeBase() = default; + virtual ~immediate_conveyor_node_base() = default; - ErrorOr> - swapChild(Own &&swapee) noexcept override { + error_or> + swap_child(own &&swapee) noexcept override { (void)swapee; - return recoverableError("Node doesn't support swapping"); + return recoverable_error("Node doesn't support swapping"); } - ConveyorStorage *nextStorage() noexcept override { - return static_cast(this); + conveyor_storage *next_storage() noexcept override { + return static_cast(this); } }; template -class ImmediateConveyorNode final : public ImmediateConveyorNodeBase { +class immediate_conveyor_node final : public immediate_conveyor_node_base { private: - ErrorOr> value; + error_or> value; uint8_t retrieved; public: - ImmediateConveyorNode(FixVoid &&val); - ImmediateConveyorNode(Error &&error); + immediate_conveyor_node(fix_void &&val); + immediate_conveyor_node(error &&error); - // ConveyorStorage + // conveyor_storage size_t space() const override; size_t queued() const override; - void childHasFired() override; - void parentHasFired() override; + void child_has_fired() override; + void parent_has_fired() override; - // ConveyorNode - void getResult(ErrorOrValue &err_or_val) noexcept override { + // conveyorNode + void get_result(error_or_value &err_or_val) noexcept override { if (retrieved > 0) { - err_or_val.as>() = - makeError("Already taken value", Error::Code::Exhausted); + err_or_val.as>() = + make_error("Already taken value", error::code::exhausted); } else { - err_or_val.as>() = std::move(value); + err_or_val.as>() = std::move(value); } if (queued() > 0) { ++retrieved; @@ -879,128 +886,130 @@ public: /* * Collects every incoming value and throws it in one lane */ -class MergeConveyorNodeBase : public ConveyorNode, public ConveyorEventStorage { +class merge_conveyor_node_base : public conveyor_node, + public conveyor_event_storage { public: - MergeConveyorNodeBase(); + merge_conveyor_node_base(); - virtual ~MergeConveyorNodeBase() = default; + virtual ~merge_conveyor_node_base() = default; - ConveyorStorage *nextStorage() noexcept override { - return static_cast(this); + conveyor_storage *next_storage() noexcept override { + return static_cast(this); } }; -template class MergeConveyorNode : public MergeConveyorNodeBase { +template +class merge_conveyor_node : public merge_conveyor_node_base { private: - class Appendage final : public ConveyorNode, public ConveyorStorage { + class appendage final : public conveyor_node, public conveyor_storage { public: - Own child; - MergeConveyorNode *merger; + own child; + merge_conveyor_node *merger; - Maybe>> error_or_value; + maybe>> error_or_value_data; public: - Appendage(Own n, MergeConveyorNode &m) - : ConveyorStorage{}, child{std::move(n)}, merger{&m}, - error_or_value{std::nullopt} {} + appendage(own n, merge_conveyor_node &m) + : conveyor_storage{}, child{std::move(n)}, merger{&m}, + error_or_value_data{std::nullopt} {} - bool childStorageHasElementQueued() const { + bool child_storage_has_element_queued() const { if (!child) { return false; } - ConveyorStorage *storage = child->nextStorage(); + conveyor_storage *storage = child->next_storage(); if (storage) { return storage->queued() > 0; } return false; } - void getAppendageResult(ErrorOrValue &eov); + void get_appendage_result(error_or_value &eov); /** - * ConveyorNode + * conveyorNode */ - ErrorOr> - swapChild(Own &&swapee_) override; + error_or> + swap_child(own &&swapee_) override; - ConveyorStorage *nextStorage() noexcept override { - return static_cast(this); + conveyor_storage *next_storage() noexcept override { + return static_cast(this); } - void getResult(ErrorOrValue &err_or_val) override; + void get_result(error_or_value &err_or_val) override; /** - * ConveyorStorage + * conveyor_storage */ size_t space() const override; size_t queued() const override; - void childHasFired() override; + void child_has_fired() override; - void parentHasFired() override; + void parent_has_fired() override; - void setParent(ConveyorStorage *par) override; + void set_parent(conveyor_storage *par) override; }; - friend class MergeConveyorNodeData; - friend class Appendage; + friend class merge_conveyor_node_data; + friend class appendage; - Our> data; + our> data; size_t next_appendage = 0; public: - MergeConveyorNode(Our> data); - ~MergeConveyorNode(); - // ConveyorNode - ErrorOr> - swapChild(Own &&c) noexcept override; + merge_conveyor_node(our> data); + ~merge_conveyor_node(); + // conveyorNode + error_or> + swap_child(own &&c) noexcept override; // Event - void getResult(ErrorOrValue &err_or_val) noexcept override; + void get_result(error_or_value &err_or_val) noexcept override; void fire() override; - // ConveyorStorage + // conveyor_storage size_t space() const override; size_t queued() const override; - void childHasFired() override; - void parentHasFired() override; + void child_has_fired() override; + void parent_has_fired() override; }; -template class MergeConveyorNodeData { +template class merge_conveyor_node_data { public: - std::vector::Appendage>> appendages; + std::vector::Appendage>> appendages; - MergeConveyorNode *merger = nullptr; + merge_conveyor_node *merger = nullptr; public: - void attach(Conveyor conv); + void attach(conveyor conv); - void governingNodeDestroyed(); + void governing_node_destroyed(); }; /* -class JoinConveyorNodeBase : public ConveyorNode, public ConveyorEventStorage { +class JoinconveyorNodeBase : public conveyorNode, public conveyorEventStorage { private: public: }; template -class JoinConveyorNode final : public JoinConveyorNodeBase { +class JoinconveyorNode final : public JoinconveyorNodeBase { private: template - class Appendage : public ConveyorEventStorage { + class Appendage : public conveyorEventStorage { private: - Maybe data = std::nullopt; + maybe data = std::nullopt; public: size_t space() const override; size_t queued() const override; void fire() override; - void getResult(ErrorOrValue& eov) override; + void getResult(error_or_value& eov) override; }; std::tuple...> appendages; diff --git a/source/forstio/async.tmpl.h b/source/forstio/async.tmpl.h index be45b35..eb066b1 100644 --- a/source/forstio/async.tmpl.h +++ b/source/forstio/async.tmpl.h @@ -1,6 +1,5 @@ #pragma once -#include "async.h" #include "common.h" #include "error.h" @@ -11,18 +10,18 @@ namespace saw { -template ConveyorResult execLater(Func &&func) { - Conveyor conveyor{FixVoid{}}; +template conveyor_result exec_later(Func &&func) { + conveyor conveyor{fix_void{}}; return conveyor.then(std::move(func)); } template -Conveyor::Conveyor(FixVoid value) : ConveyorBase(nullptr) { +conveyor::conveyor(fix_void value) : conveyor_base(nullptr) { // Is there any way to do this? - // @todo new ConveyorBase constructor for Immediate values + // @todo new conveyorBase constructor for Immediate values - Own>> immediate = - heap>>(std::move(value)); + own>> immediate = + heap>>(std::move(value)); if (!immediate) { return; @@ -32,9 +31,9 @@ Conveyor::Conveyor(FixVoid value) : ConveyorBase(nullptr) { } template -Conveyor::Conveyor(Error &&error) : ConveyorBase(nullptr) { - Own>> immediate = - heap>>(std::move(error)); +conveyor::conveyor(error &&error) : conveyor_base(nullptr) { + own>> immediate = + heap>>(std::move(error)); if (!immediate) { return; @@ -44,145 +43,150 @@ Conveyor::Conveyor(Error &&error) : ConveyorBase(nullptr) { } template -Conveyor::Conveyor(Own node_p) - : ConveyorBase{std::move(node_p)} {} +conveyor::conveyor(own node_p) + : conveyor_base{std::move(node_p)} {} template template -ConveyorResult Conveyor::then(Func &&func, ErrorFunc &&error_func) { - Own conversion_node = - heap>, FixVoid, Func, - ErrorFunc>>(std::move(node), std::move(func), - std::move(error_func)); +conveyor_result conveyor::then(Func &&func, + ErrorFunc &&error_func) { + own conversion_node = + heap>, fix_void, + Func, ErrorFunc>>( + std::move(node), std::move(func), std::move(error_func)); - return Conveyor>>::toConveyor( + return conveyor>>::to_conveyor( std::move(conversion_node)); } -template Conveyor Conveyor::buffer(size_t size) { - SAW_ASSERT(node) { return Conveyor{Own{nullptr}}; } - ConveyorStorage *storage = node->nextStorage(); - SAW_ASSERT(storage) { return Conveyor{Own{nullptr}}; } +template conveyor conveyor::buffer(size_t size) { + SAW_ASSERT(node) { return conveyor{own{nullptr}}; } + conveyor_storage *storage = node->next_storage(); + SAW_ASSERT(storage) { return conveyor{own{nullptr}}; } - Own>> storage_node = - heap>>(std::move(node), size); + own>> storage_node = + heap>>(std::move(node), size); - ConveyorStorage *storage_ptr = - static_cast(storage_node.get()); + conveyor_storage *storage_ptr = + static_cast(storage_node.get()); - storage->setParent(storage_ptr); - return Conveyor{std::move(storage_node)}; + storage->set_parent(storage_ptr); + return conveyor{std::move(storage_node)}; } template template -Conveyor Conveyor::attach(Args &&...args) { - Own> attach_node = - heap>(std::move(node), std::move(args...)); - return Conveyor{std::move(attach_node)}; +conveyor conveyor::attach(Args &&...args) { + own> attach_node = + heap>(std::move(node), + std::move(args...)); + return conveyor{std::move(attach_node)}; } template -std::pair, MergeConveyor> Conveyor::merge() { - Our> data = share>(); +std::pair, merge_conveyor> conveyor::merge() { + our> data = + share>(); - Own> merge_node = heap>(data); + own> merge_node = heap>(data); SAW_ASSERT(node) { - return std::make_pair(Conveyor{Own{nullptr}}, - MergeConveyor{}); + return std::make_pair(conveyor{own{nullptr}}, + merge_conveyor{}); } - ConveyorStorage *storage = node->nextStorage(); + conveyor_storage *storage = node->next_storage(); SAW_ASSERT(storage) { - return std::make_pair(Conveyor{Own{nullptr}}, - MergeConveyor{}); + return std::make_pair(conveyor{own{nullptr}}, + merge_conveyor{}); } - data->attach(Conveyor::toConveyor(std::move(node))); + data->attach(conveyor::to_conveyor(std::move(node))); - MergeConveyor node_ref{data}; + merge_conveyor node_ref{data}; - return std::make_pair(Conveyor{std::move(merge_node)}, + return std::make_pair(conveyor{std::move(merge_node)}, std::move(node_ref)); } template <> template -ConveyorSink Conveyor::sink(ErrorFunc &&error_func) { - ConveyorStorage *storage = node->nextStorage(); - SAW_ASSERT(storage) { return ConveyorSink{}; } +conveyor_sink conveyor::sink(ErrorFunc &&error_func) { + conveyor_storage *storage = node->next_storage(); + SAW_ASSERT(storage) { return conveyor_sink{}; } - Own sink_node = heap(std::move(node)); - ConveyorStorage *storage_ptr = - static_cast(sink_node.get()); + own sink_node = + heap(std::move(node)); + conveyor_storage *storage_ptr = + static_cast(sink_node.get()); - storage->setParent(storage_ptr); + storage->set_parent(storage_ptr); - return ConveyorSink{std::move(sink_node)}; + return conveyor_sink{std::move(sink_node)}; } -void detachConveyor(Conveyor &&conveyor); +void detachconveyor(conveyor &&conveyor); template template -void Conveyor::detach(ErrorFunc &&func) { - detachConveyor(std::move(then([](T &&) {}, std::move(func)))); +void conveyor::detach(ErrorFunc &&func) { + detachconveyor(std::move(then([](T &&) {}, std::move(func)))); } template <> template -void Conveyor::detach(ErrorFunc &&func) { - detachConveyor(std::move(then([]() {}, std::move(func)))); +void conveyor::detach(ErrorFunc &&func) { + detachconveyor(std::move(then([]() {}, std::move(func)))); } template -Conveyor Conveyor::toConveyor(Own node) { - return Conveyor{std::move(node)}; +conveyor conveyor::to_conveyor(own node) { + return conveyor{std::move(node)}; } template -Own Conveyor::fromConveyor(Conveyor conveyor) { +own conveyor::from_conveyor(conveyor conveyor) { return std::move(conveyor.node); } -template ErrorOr> Conveyor::take() { +template error_or> conveyor::take() { SAW_ASSERT(node) { - return ErrorOr>{criticalError("Conveyor in invalid state")}; + return error_or>{ + critical_error("conveyor in invalid state")}; } - ConveyorStorage *storage = node->nextStorage(); + conveyor_storage *storage = node->next_storage(); if (storage) { if (storage->queued() > 0) { - ErrorOr> result; - node->getResult(result); + error_or> result; + node->get_result(result); return result; } else { - return ErrorOr>{ - recoverableError("Conveyor buffer has no elements")}; + return error_or>{ + recoverable_error("conveyor buffer has no elements")}; } } else { - return ErrorOr>{ - criticalError("Conveyor node has no child storage")}; + return error_or>{ + critical_error("conveyor node has no child storage")}; } } -template ConveyorAndFeeder newConveyorAndFeeder() { - Own>> feeder = - heap>>(); - Own>> node = - heap>>(); +template conveyor_and_feeder new_conveyor_and_feeder() { + own>> feeder = + heap>>(); + own>> node = + heap>>(); feeder->setFeedee(node.get()); node->setFeeder(feeder.get()); - return ConveyorAndFeeder{std::move(feeder), - Conveyor::toConveyor(std::move(node))}; + return conveyor_and_feeder{std::move(feeder), + conveyor::to_conveyor(std::move(node))}; } // QueueBuffer -template void QueueBufferConveyorNode::fire() { +template void queue_buffer_conveyor_node::fire() { if (child_mixin.child) { if (!storage.empty()) { - if (storage.front().isError()) { + if (storage.front().is_error()) { if (storage.front().error().isCritical()) { child_mixin.child = nullptr; } @@ -193,9 +197,9 @@ template void QueueBufferConveyorNode::fire() { bool has_space_before_fire = space() > 0; if (parent) { - parent->childHasFired(); + parent->child_has_fired(); if (!storage.empty() && parent->space() > 0) { - armLater(); + arm_later(); } } @@ -206,45 +210,45 @@ template void QueueBufferConveyorNode::fire() { return; } - ConveyorStorage *ch_storage = child_mixin.child->nextStorage(); + conveyor_storage *ch_storage = child_mixin.child->next_storage(); if (ch_storage && !has_space_before_fire) { - ch_storage->parentHasFired(); + ch_storage->parent_has_fired(); } } template -void QueueBufferConveyorNode::getResult(ErrorOrValue &eov) noexcept { - ErrorOr &err_or_val = eov.as(); +void queue_buffer_conveyor_node::get_result(error_or_value &eov) noexcept { + error_or &err_or_val = eov.as(); err_or_val = std::move(storage.front()); storage.pop(); } -template size_t QueueBufferConveyorNode::space() const { +template size_t queue_buffer_conveyor_node::space() const { return max_store - storage.size(); } -template size_t QueueBufferConveyorNode::queued() const { +template size_t queue_buffer_conveyor_node::queued() const { return storage.size(); } -template void QueueBufferConveyorNode::childHasFired() { +template void queue_buffer_conveyor_node::child_has_fired() { if (child_mixin.child && storage.size() < max_store) { - ErrorOr eov; - child_mixin.child->getResult(eov); + error_or eov; + child_mixin.child->get_result(eov); - if (eov.isError()) { + if (eov.is_error()) { if (eov.error().isCritical()) { } } storage.push(std::move(eov)); - if (!isArmed()) { - armLater(); + if (!is_armed()) { + arm_later(); } } } -template void QueueBufferConveyorNode::parentHasFired() { +template void queue_buffer_conveyor_node::parent_has_fired() { SAW_ASSERT(parent) { return; } if (parent->space() == 0) { @@ -252,57 +256,57 @@ template void QueueBufferConveyorNode::parentHasFired() { } if (queued() > 0) { - armLater(); + arm_later(); } } template -ImmediateConveyorNode::ImmediateConveyorNode(FixVoid &&val) +immediate_conveyor_node::immediate_conveyor_node(fix_void &&val) : value{std::move(val)}, retrieved{0} {} template -ImmediateConveyorNode::ImmediateConveyorNode(Error &&error) +immediate_conveyor_node::immediate_conveyor_node(error &&error) : value{std::move(error)}, retrieved{0} {} -template size_t ImmediateConveyorNode::space() const { +template size_t immediate_conveyor_node::space() const { return 0; } -template size_t ImmediateConveyorNode::queued() const { +template size_t immediate_conveyor_node::queued() const { return retrieved > 1 ? 0 : 1; } -template void ImmediateConveyorNode::childHasFired() { +template void immediate_conveyor_node::child_has_fired() { // Impossible case assert(false); } -template void ImmediateConveyorNode::parentHasFired() { +template void immediate_conveyor_node::parent_has_fired() { SAW_ASSERT(parent) { return; } assert(parent->space() > 0); if (queued() > 0) { - armNext(); + arm_next(); } } -template void ImmediateConveyorNode::fire() { +template void immediate_conveyor_node::fire() { if (parent) { - parent->childHasFired(); + parent->child_has_fired(); if (queued() > 0 && parent->space() > 0) { - armLast(); + arm_last(); } } } template -MergeConveyor::MergeConveyor(Lent> d) +merge_conveyor::merge_conveyor(lent> d) : data{std::move(d)} {} -template MergeConveyor::~MergeConveyor() {} +template merge_conveyor::~merge_conveyor() {} -template void MergeConveyor::attach(Conveyor conveyor) { +template void merge_conveyor::attach(conveyor conveyor) { auto sp = data.lock(); SAW_ASSERT(sp) { return; } @@ -310,26 +314,26 @@ template void MergeConveyor::attach(Conveyor conveyor) { } template -MergeConveyorNode::MergeConveyorNode(Our> d) +merge_conveyor_node::merge_conveyor_node(our> d) : data{d} { SAW_ASSERT(data) { return; } data->merger = this; } -template MergeConveyorNode::~MergeConveyorNode() {} +template merge_conveyor_node::~merge_conveyor_node() {} template -ErrorOr> -MergeConveyorNode::swapChild(Own &&swapee_) noexcept { +error_or> +merge_conveyor_node::swap_child(own &&swapee_) noexcept { (void)swapee_; - return criticalError( - "MergeConveyorNode::Appendage should block calls to this class"); + return critical_error( + "MergeconveyorNode::Appendage should block calls to this class"); } template -void MergeConveyorNode::getResult(ErrorOrValue &eov) noexcept { - ErrorOr> &err_or_val = eov.as>(); +void merge_conveyor_node::get_result(error_or_value &eov) noexcept { + error_or> &err_or_val = eov.as>(); SAW_ASSERT(data) { return; } @@ -355,24 +359,24 @@ void MergeConveyorNode::getResult(ErrorOrValue &eov) noexcept { } } - err_or_val = criticalError("No value in Merge Appendages"); + err_or_val = critical_error("No value in Merge Appendages"); } -template void MergeConveyorNode::fire() { +template void merge_conveyor_node::fire() { SAW_ASSERT(queued() > 0) { return; } if (parent) { - parent->childHasFired(); + parent->child_has_fired(); if (queued() > 0 && parent->space() > 0) { - armLater(); + arm_later(); } } } -template size_t MergeConveyorNode::space() const { return 0; } +template size_t merge_conveyor_node::space() const { return 0; } -template size_t MergeConveyorNode::queued() const { +template size_t merge_conveyor_node::queued() const { SAW_ASSERT(data) { return 0; } size_t queue_count = 0; @@ -384,64 +388,65 @@ template size_t MergeConveyorNode::queued() const { return queue_count; } -template void MergeConveyorNode::childHasFired() { +template void merge_conveyor_node::child_has_fired() { /// This can never happen assert(false); } -template void MergeConveyorNode::parentHasFired() { +template void merge_conveyor_node::parent_has_fired() { SAW_ASSERT(parent) { return; } if (queued() > 0) { if (parent->space() > 0) { - armLater(); + arm_later(); } } } /** - * MergeConveyorNode::Apendage + * MergeconveyorNode::Apendage */ template -ErrorOr> -MergeConveyorNode::Appendage::swapChild(Own &&swapee_) { - Own old_child = std::move(child); +error_or> +merge_conveyor_node::appendage::swap_child(own &&swapee_) { + own old_child = std::move(child); child = std::move(swapee_); // This case should never happen - SAW_ASSERT(old_child) { return criticalError("No child exists"); } + SAW_ASSERT(old_child) { return critical_error("No child exists"); } return old_child; } template -void MergeConveyorNode::Appendage::getResult(ErrorOrValue &eov) { - ErrorOr> &err_or_val = eov.as>(); +void merge_conveyor_node::appendage::get_result(error_or_value &eov) { + error_or> &err_or_val = eov.as>(); SAW_ASSERT(queued() > 0) { - err_or_val = criticalError("No element queued in Merge Appendage Node"); + err_or_val = + critical_error("No element queued in Merge Appendage Node"); return; } - err_or_val = std::move(error_or_value.value()); - error_or_value = std::nullopt; + err_or_val = std::move(error_or_value_data.value()); + error_or_value_data = std::nullopt; } -template size_t MergeConveyorNode::Appendage::space() const { +template size_t merge_conveyor_node::appendage::space() const { SAW_ASSERT(merger) { return 0; } - if (error_or_value.has_value()) { + if (error_or_value_data.has_value()) { return 0; } return 1; } -template size_t MergeConveyorNode::Appendage::queued() const { +template size_t merge_conveyor_node::appendage::queued() const { SAW_ASSERT(merger) { return 0; } - if (error_or_value.has_value()) { + if (error_or_value_data.has_value()) { return 1; } @@ -450,39 +455,43 @@ template size_t MergeConveyorNode::Appendage::queued() const { /// @todo delete this function. Replaced by the regular getResult template -void MergeConveyorNode::Appendage::getAppendageResult(ErrorOrValue &eov) { - ErrorOr> &err_or_val = eov.as>(); +void merge_conveyor_node::appendage::get_appendage_result( + error_or_value &eov) { + error_or> &err_or_val = eov.as>(); SAW_ASSERT(queued() > 0) { - err_or_val = criticalError("No element queued in Merge Appendage Node"); + err_or_val = + critical_error("No element queued in Merge Appendage Node"); return; } - err_or_val = std::move(error_or_value.value()); - error_or_value = std::nullopt; + err_or_val = std::move(error_or_value_data.value()); + error_or_value_data = std::nullopt; } -template void MergeConveyorNode::Appendage::childHasFired() { - SAW_ASSERT(!error_or_value.has_value()) { return; } - ErrorOr> eov; - child->getResult(eov); +template +void merge_conveyor_node::appendage::child_has_fired() { + SAW_ASSERT(!error_or_value_data.has_value()) { return; } + error_or> eov; + child->get_result(eov); - error_or_value = std::move(eov); + error_or_value_data = std::move(eov); - if (!merger->isArmed()) { - merger->armLater(); - } -} - -template void MergeConveyorNode::Appendage::parentHasFired() { - ConveyorStorage *child_storage = child->nextStorage(); - if (child_storage) { - child_storage->parentHasFired(); + if (!merger->is_armed()) { + merger->arm_later(); } } template -void MergeConveyorNode::Appendage::setParent(ConveyorStorage *par) { +void merge_conveyor_node::appendage::parent_has_fired() { + conveyor_storage *child_storage = child->next_storage(); + if (child_storage) { + child_storage->parent_has_fired(); + } +} + +template +void merge_conveyor_node::appendage::set_parent(conveyor_storage *par) { SAW_ASSERT(merger) { return; } SAW_ASSERT(child) { return; } @@ -491,38 +500,36 @@ void MergeConveyorNode::Appendage::setParent(ConveyorStorage *par) { } template -void MergeConveyorNodeData::attach(Conveyor conveyor) { - auto nas = Conveyor::fromConveyor(std::move(conveyor)); +void merge_conveyor_node_data::attach(conveyor conveyor) { + auto nas = conveyor::from_conveyor(std::move(conveyor)); SAW_ASSERT(nas) { return; } - ConveyorStorage *storage = nas->nextStorage(); + conveyor_storage *storage = nas->nextStorage(); SAW_ASSERT(storage) { return; } auto merge_node_appendage = - heap::Appendage>(std::move(nas), *merger); + heap::Appendage>(std::move(nas), + *merger); auto merge_node_appendage_ptr = merge_node_appendage.get(); - storage->setParent(merge_node_appendage.get()); + storage->set_parent(merge_node_appendage.get()); SAW_ASSERT(merger) { return; } - ConveyorStorage *mrg_storage = merger->nextStorage(); + conveyor_storage *mrg_storage = merger->nextStorage(); SAW_ASSERT(mrg_storage) { return; } merge_node_appendage->setParent(mrg_storage); appendages.push_back(std::move(merge_node_appendage)); - - /// @todo return this. necessary? maybe for the weird linking setup - /// maybe not - // return merge_node_appendage_ptr; } -template void MergeConveyorNodeData::governingNodeDestroyed() { +template +void merge_conveyor_node_data::governing_node_destroyed() { appendages.clear(); merger = nullptr; } -template AdaptConveyorFeeder::~AdaptConveyorFeeder() { +template adapt_conveyor_feeder::~adapt_conveyor_feeder() { if (feedee) { feedee->setFeeder(nullptr); feedee = nullptr; @@ -530,30 +537,30 @@ template AdaptConveyorFeeder::~AdaptConveyorFeeder() { } template -void AdaptConveyorFeeder::setFeedee(AdaptConveyorNode *feedee_p) { +void adapt_conveyor_feeder::set_feedee(adapt_conveyor_node *feedee_p) { feedee = feedee_p; } -template void AdaptConveyorFeeder::feed(T &&value) { +template void adapt_conveyor_feeder::feed(T &&value) { if (feedee) { feedee->feed(std::move(value)); } } -template void AdaptConveyorFeeder::fail(Error &&error) { +template void adapt_conveyor_feeder::fail(error &&error) { if (feedee) { feedee->fail(std::move(error)); } } -template size_t AdaptConveyorFeeder::queued() const { +template size_t adapt_conveyor_feeder::queued() const { if (feedee) { return feedee->queued(); } return 0; } -template size_t AdaptConveyorFeeder::space() const { +template size_t adapt_conveyor_feeder::space() const { if (feedee) { return feedee->space(); } @@ -561,20 +568,20 @@ template size_t AdaptConveyorFeeder::space() const { } template -Error AdaptConveyorFeeder::swap(Conveyor &&conveyor) noexcept { - SAW_ASSERT(feedee) { return criticalError("No feedee connected"); } +error adapt_conveyor_feeder::swap(conveyor &&conveyor) noexcept { + SAW_ASSERT(feedee) { return critical_error("No feedee connected"); } - auto node = Conveyor::fromConveyor(std::move(conveyor)); + auto node = conveyor::from_conveyor(std::move(conveyor)); feedee->swapChild(std::move(node)); - return noError(); + return no_error(); } template -AdaptConveyorNode::AdaptConveyorNode() : ConveyorEventStorage{} {} +adapt_conveyor_node::adapt_conveyor_node() : conveyor_event_storage{} {} -template AdaptConveyorNode::~AdaptConveyorNode() { +template adapt_conveyor_node::~adapt_conveyor_node() { if (feeder) { feeder->setFeedee(nullptr); feeder = nullptr; @@ -582,12 +589,12 @@ template AdaptConveyorNode::~AdaptConveyorNode() { } template -ErrorOr> -AdaptConveyorNode::swapChild(Own &&swapee) noexcept { +error_or> +adapt_conveyor_node::swap_child(own &&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.swap_child_of_parent(std::move(swapee)); - if (myself_err.isError()) { + if (myself_err.is_error()) { return myself_err; } @@ -599,56 +606,57 @@ AdaptConveyorNode::swapChild(Own &&swapee) noexcept { } template -ConveyorStorage *AdaptConveyorNode::nextStorage() noexcept { - return static_cast(this); +conveyor_storage *adapt_conveyor_node::next_storage() noexcept { + return static_cast(this); } template -void AdaptConveyorNode::notifyParentAttached(ConveyorNode &par) noexcept { - parent_node.changeParent(&par); +void adapt_conveyor_node::notify_parent_attached( + conveyor_node &par) noexcept { + parent_node.change_parent(&par); } template -void AdaptConveyorNode::setFeeder(AdaptConveyorFeeder *feeder_p) { +void adapt_conveyor_node::set_feeder(adapt_conveyor_feeder *feeder_p) { feeder = feeder_p; } -template void AdaptConveyorNode::feed(T &&value) { +template void adapt_conveyor_node::feed(T &&value) { storage.push(std::move(value)); - armNext(); + arm_next(); } -template void AdaptConveyorNode::fail(Error &&error) { +template void adapt_conveyor_node::fail(error &&error) { storage.push(std::move(error)); - armNext(); + arm_next(); } -template size_t AdaptConveyorNode::queued() const { +template size_t adapt_conveyor_node::queued() const { return storage.size(); } -template size_t AdaptConveyorNode::space() const { +template size_t adapt_conveyor_node::space() const { return std::numeric_limits::max() - storage.size(); } template -void AdaptConveyorNode::getResult(ErrorOrValue &err_or_val) { +void adapt_conveyor_node::get_result(error_or_value &err_or_val) { if (!storage.empty()) { err_or_val.as() = std::move(storage.front()); storage.pop(); } else { - err_or_val.as() = - criticalError("Signal for retrieval of storage sent even though no " - "data is present"); + err_or_val.as() = critical_error( + "Signal for retrieval of storage sent even though no " + "data is present"); } } -template void AdaptConveyorNode::childHasFired() { +template void adapt_conveyor_node::child_has_fired() { // Adapt node has no children assert(false); } -template void AdaptConveyorNode::parentHasFired() { +template void adapt_conveyor_node::parent_has_fired() { SAW_ASSERT(parent) { return; } if (parent->space() == 0) { @@ -656,17 +664,17 @@ template void AdaptConveyorNode::parentHasFired() { } } -template void AdaptConveyorNode::fire() { +template void adapt_conveyor_node::fire() { if (parent) { - parent->childHasFired(); + parent->child_has_fired(); if (storage.size() > 0) { - armLater(); + arm_later(); } } } -template OneTimeConveyorFeeder::~OneTimeConveyorFeeder() { +template one_time_conveyor_feeder::~one_time_conveyor_feeder() { if (feedee) { feedee->setFeeder(nullptr); feedee = nullptr; @@ -674,37 +682,38 @@ template OneTimeConveyorFeeder::~OneTimeConveyorFeeder() { } template -void OneTimeConveyorFeeder::setFeedee(OneTimeConveyorNode *feedee_p) { +void one_time_conveyor_feeder::set_feedee( + one_time_conveyor_node *feedee_p) { feedee = feedee_p; } -template void OneTimeConveyorFeeder::feed(T &&value) { +template void one_time_conveyor_feeder::feed(T &&value) { if (feedee) { feedee->feed(std::move(value)); } } -template void OneTimeConveyorFeeder::fail(Error &&error) { +template void one_time_conveyor_feeder::fail(error &&error) { if (feedee) { feedee->fail(std::move(error)); } } -template size_t OneTimeConveyorFeeder::queued() const { +template size_t one_time_conveyor_feeder::queued() const { if (feedee) { return feedee->queued(); } return 0; } -template size_t OneTimeConveyorFeeder::space() const { +template size_t one_time_conveyor_feeder::space() const { if (feedee) { return feedee->space(); } return 0; } -template OneTimeConveyorNode::~OneTimeConveyorNode() { +template one_time_conveyor_node::~one_time_conveyor_node() { if (feeder) { feeder->setFeedee(nullptr); feeder = nullptr; @@ -712,43 +721,44 @@ template OneTimeConveyorNode::~OneTimeConveyorNode() { } template -void OneTimeConveyorNode::setFeeder(OneTimeConveyorFeeder *feeder_p) { +void one_time_conveyor_node::set_feeder( + one_time_conveyor_feeder *feeder_p) { feeder = feeder_p; } -template void OneTimeConveyorNode::feed(T &&value) { +template void one_time_conveyor_node::feed(T &&value) { storage = std::move(value); - armNext(); + arm_next(); } -template void OneTimeConveyorNode::fail(Error &&error) { +template void one_time_conveyor_node::fail(error &&error) { storage = std::move(error); - armNext(); + arm_next(); } -template size_t OneTimeConveyorNode::queued() const { +template size_t one_time_conveyor_node::queued() const { return storage.has_value() ? 1 : 0; } -template size_t OneTimeConveyorNode::space() const { +template size_t one_time_conveyor_node::space() const { return passed ? 0 : 1; } template -void OneTimeConveyorNode::getResult(ErrorOrValue &err_or_val) { +void one_time_conveyor_node::get_result(error_or_value &err_or_val) { if (storage.has_value()) { err_or_val.as() = std::move(storage.value()); storage = std::nullopt; } else { - err_or_val.as() = - criticalError("Signal for retrieval of storage sent even though no " - "data is present"); + err_or_val.as() = critical_error( + "Signal for retrieval of storage sent even though no " + "data is present"); } } -template void OneTimeConveyorNode::fire() { +template void one_time_conveyor_node::fire() { if (parent) { - parent->childHasFired(); + parent->child_has_fired(); } } diff --git a/source/forstio/common.h b/source/forstio/common.h index b5239aa..3b4bd04 100644 --- a/source/forstio/common.h +++ b/source/forstio/common.h @@ -32,43 +32,43 @@ namespace saw { assert(expression); \ if (!(expression)) [[unlikely]] -template using Maybe = std::optional; +template using maybe = std::optional; -template using Own = std::unique_ptr; +template using own = std::unique_ptr; -template using Our = std::shared_ptr; +template using our = std::shared_ptr; -template using Lent = std::weak_ptr; +template using lent = std::weak_ptr; -template Own heap(Args &&...args) { - return Own(new T(std::forward(args)...)); +template own heap(Args &&...args) { + return own(new T(std::forward(args)...)); } -template Our share(Args &&...args) { +template our share(Args &&...args) { return std::make_shared(std::forward(args)...); } template T instance() noexcept; -template struct ReturnTypeHelper { +template struct return_type_helper { typedef decltype(instance()(instance())) Type; }; -template struct ReturnTypeHelper { +template struct return_type_helper { typedef decltype(instance()()) Type; }; template -using ReturnType = typename ReturnTypeHelper::Type; +using return_type = typename return_type_helper::Type; struct Void {}; -template struct VoidFix { typedef T Type; }; -template <> struct VoidFix { typedef Void Type; }; -template using FixVoid = typename VoidFix::Type; +template struct void_fix { typedef T Type; }; +template <> struct void_fix { typedef Void Type; }; +template using fix_void = typename void_fix::Type; -template struct VoidUnfix { typedef T Type; }; -template <> struct VoidUnfix { typedef void Type; }; -template using UnfixVoid = typename VoidUnfix::Type; +template struct void_unfix { typedef T Type; }; +template <> struct void_unfix { typedef void Type; }; +template using unfix_void = typename void_unfix::Type; template constexpr bool always_false = false; diff --git a/source/forstio/error.cpp b/source/forstio/error.cpp index 947c019..7b79e0d 100644 --- a/source/forstio/error.cpp +++ b/source/forstio/error.cpp @@ -1,19 +1,19 @@ #include "error.h" namespace saw { -Error::Error() : error_{static_cast(0)} {} +error::error() : error_{static_cast(0)} {} -Error::Error(const std::string_view &msg, Error::Code code) - : error_message{msg}, error_{static_cast(code)} {} +error::error(const std::string_view &msg, error::code code) + : error_message{msg}, error_{static_cast(code)} {} -Error::Error(std::string &&msg, Error::Code code) - : error_message{std::move(msg)}, error_{static_cast(code)} {} +error::error(std::string &&msg, error::code code) + : error_message{std::move(msg)}, error_{static_cast(code)} {} -Error::Error(Error &&error) +error::error(error &&error) : error_message{std::move(error.error_message)}, error_{std::move( error.error_)} {} -const std::string_view Error::message() const { +const std::string_view error::message() const { return std::visit( [this](auto &&arg) -> const std::string_view { @@ -24,50 +24,50 @@ const std::string_view Error::message() const { } else if constexpr (std::is_same_v) { return arg; } else { - return "Error in class Error. Good luck :)"; + return "error in class error. Good luck :)"; } }, error_message); } -bool Error::failed() const { - return static_cast>(error_) != 0; +bool error::failed() const { + return static_cast>(error_) != 0; } -bool Error::isCritical() const { - return static_cast>(error_) < 0; +bool error::is_critical() const { + return static_cast>(error_) < 0; } -bool Error::isRecoverable() const { - return static_cast>(error_) > 0; +bool error::is_recoverable() const { + return static_cast>(error_) > 0; } -Error Error::copyError() const { - Error error; +error error::copy_error() const { + error error; error.error_ = error_; try { error.error_message = error_message; } catch (const std::bad_alloc &) { error.error_message = - std::string_view{"Error while copying Error string. Out of memory"}; + std::string_view{"error while copying error string. Out of memory"}; } return error; } -Error::Code Error::code() const { return static_cast(error_); } +error::code error::code() const { return static_cast(error_); } -Error makeError(const std::string_view &generic, Error::Code code) { - return Error{generic, code}; +error makeerror(const std::string_view &generic, error::code code) { + return error{generic, code}; } -Error criticalError(const std::string_view &generic, Error::Code c) { - return makeError(generic, c); +error critical_error(const std::string_view &generic, error::code c) { + return makeerror(generic, c); } -Error recoverableError(const std::string_view &generic, Error::Code c) { - return makeError(generic, c); +error recoverable_error(const std::string_view &generic, error::code c) { + return makeerror(generic, c); } -Error noError() { return Error{}; } +error no_error() { return error{}; } } // namespace saw diff --git a/source/forstio/error.h b/source/forstio/error.h index b7b4e41..23cda54 100644 --- a/source/forstio/error.h +++ b/source/forstio/error.h @@ -11,133 +11,140 @@ namespace saw { /** * Utility class for generating errors. Has a base distinction between - * critical and recoverable errors. Additional code ids can be provided to the + * critical and recoverable_ errors. Additional code ids can be provided to the * constructor if additional distinctions are necessary. */ -class Error { +class error { public: - enum class Code : int16_t { - GenericCritical = -1, - GenericRecoverable = 1, - Disconnected = -99, - Exhausted = -98 + enum class code : int16_t { + generic_critical = -1, + generic_recoverable = 1, + disconnected = -99, + exhausted = -98 }; private: std::variant error_message; - Code error_; + code error_; public: - Error(); - Error(const std::string_view &msg, Error::Code code); - Error(std::string &&msg, Error::Code code); - Error(Error &&error); + error(); + error(const std::string_view &msg, error::code code); + error(std::string &&msg, error::code code); + error(error &&error); - SAW_FORBID_COPY(Error); + SAW_FORBID_COPY(error); - Error &operator=(Error &&) = default; + error &operator=(error &&) = default; const std::string_view message() const; bool failed() const; - bool isCritical() const; - bool isRecoverable() const; + bool is_critical() const; + bool is_recoverable() const; - Error copyError() const; + error copy_error() const; - Code code() const; + code error_code() const; }; -Error makeError(const std::string_view &generic, Error::Code c); +error make_error(const std::string_view &generic, error::code c); template -Error makeError(const Formatter &formatter, Error::Code code, - const std::string_view &generic) { +error make_error(const Formatter &formatter, error::code code, + const std::string_view &generic) { + /* try { std::string error_msg = formatter(); - return Error{std::move(error_msg), code}; + return error{std::move(error_msg), code}; } catch (std::bad_alloc &) { - return Error{generic, code}; + return error{generic, code}; } + */ + std::string error_msg = formatter(); + return error{std::move(error_msg), code}; } -Error criticalError(const std::string_view &generic, - Error::Code c = Error::Code::GenericCritical); +error critical_error(const std::string_view &generic, + error::code c = error::code::generic_critical); template -Error criticalError(const Formatter &formatter, const std::string_view &generic, - Error::Code c = Error::Code::GenericCritical) { - return makeError(formatter, c, generic); +error critical_error(const Formatter &formatter, + const std::string_view &generic, + error::code c = error::code::generic_critical) { + return makeerror(formatter, c, generic); } -Error recoverableError(const std::string_view &generic, - Error::Code c = Error::Code::GenericRecoverable); +error recoverable_error(const std::string_view &generic, + error::code c = error::code::generic_recoverable); template -Error recoverableError(const Formatter &formatter, - const std::string_view &generic, - Error::Code c = Error::Code::GenericRecoverable) { - return makeError(formatter, c, generic); +error recoverable_error(const Formatter &formatter, + const std::string_view &generic, + error::code c = error::code::generic_recoverable) { + return makeerror(formatter, c, generic); } -Error noError(); +error no_error(); /** * Exception alternative. Since I code without exceptions this class is * essentially a kind of exception replacement. */ -template class ErrorOr; +template class error_or; -class ErrorOrValue { +class error_or_value { public: - virtual ~ErrorOrValue() = default; + virtual ~error_or_value() = default; - template ErrorOr> &as() { - return static_cast> &>(*this); + template error_or> &as() { + return static_cast> &>(*this); } - template const ErrorOr> &as() const { - return static_cast> &>(*this); + template const error_or> &as() const { + return static_cast> &>(*this); } }; -template class ErrorOr final : public ErrorOrValue { +template class error_or final : public error_or_value { private: - std::variant> value_or_error; + std::variant> value_or_error; static_assert(!std::is_same_v, "Don't use internal private types"); public: - ErrorOr() = default; - ErrorOr(const FixVoid &value) : value_or_error{value} {} + error_or() = default; + error_or(const fix_void &value) : value_or_error{value} {} - ErrorOr(FixVoid &&value) : value_or_error{std::move(value)} {} + error_or(fix_void &&value) : value_or_error{std::move(value)} {} - ErrorOr(const Error &error) : value_or_error{error} {} - ErrorOr(Error &&error) : value_or_error{std::move(error)} {} + error_or(const error &error) : value_or_error{error} {} + error_or(error &&error) : value_or_error{std::move(error)} {} - bool isValue() const { - return std::holds_alternative>(value_or_error); + bool is_value() const { + return std::holds_alternative>(value_or_error); } - bool isError() const { - return std::holds_alternative(value_or_error); + bool is_error() const { + return std::holds_alternative(value_or_error); } - Error &error() { return std::get(value_or_error); } + class error &error() { + return std::get(value_or_error); + } - const Error &error() const { return std::get(value_or_error); } + const class error &error() const { return std::get(value_or_error); } - FixVoid &value() { return std::get>(value_or_error); } + fix_void &value() { return std::get>(value_or_error); } - const FixVoid &value() const { - return std::get>(value_or_error); + const fix_void &value() const { + return std::get>(value_or_error); } }; -template class ErrorOr> { +template class error_or> { private: - ErrorOr() = delete; + error_or() = delete; }; } // namespace saw