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

refactor progress

fb-mini-snake
Claudius Holeksa 2023-01-03 18:00:52 +01:00
parent d87b91d5fc
commit 59451d3a4c
31 changed files with 2295 additions and 2247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

422
driver/io-unix.cpp
View File

@ -1,422 +0,0 @@
#include "io-unix.h"
#include <sstream>
namespace saw {
namespace unix {
IFdOwner::IFdOwner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
uint32_t event_mask)
: event_port_{event_port}, file_descriptor_{file_descriptor},
fd_flags_{fd_flags}, event_mask_{event_mask} {
event_port_.subscribe(*this, file_descriptor, event_mask);
}
IFdOwner::~IFdOwner() {
if (file_descriptor_ >= 0) {
event_port_.unsubscribe(file_descriptor_);
::close(file_descriptor_);
}
}
ssize_t unixRead(int fd, void *buffer, size_t length) {
return ::recv(fd, buffer, length, 0);
}
ssize_t unixWrite(int fd, const void *buffer, size_t length) {
return ::send(fd, buffer, length, 0);
}
UnixIoStream::UnixIoStream(UnixEventPort &event_port, int file_descriptor,
int fd_flags, uint32_t event_mask)
: IFdOwner{event_port, file_descriptor, fd_flags, event_mask | EPOLLRDHUP} {
}
ErrorOr<size_t> UnixIoStream::read(void *buffer, size_t length) {
ssize_t read_bytes = unixRead(fd(), buffer, length);
if (read_bytes > 0) {
return static_cast<size_t>(read_bytes);
} else if (read_bytes == 0) {
return criticalError("Disconnected", Error::Code::Disconnected);
}
return recoverableError("Currently busy");
}
Conveyor<void> UnixIoStream::readReady() {
auto caf = newConveyorAndFeeder<void>();
read_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
Conveyor<void> UnixIoStream::onReadDisconnected() {
auto caf = newConveyorAndFeeder<void>();
on_read_disconnect_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
ErrorOr<size_t> UnixIoStream::write(const void *buffer, size_t length) {
ssize_t write_bytes = unixWrite(fd(), buffer, length);
if (write_bytes > 0) {
return static_cast<size_t>(write_bytes);
}
int error = errno;
if (error == EAGAIN || error == EWOULDBLOCK) {
return recoverableError("Currently busy");
}
return criticalError("Disconnected", Error::Code::Disconnected);
}
Conveyor<void> UnixIoStream::writeReady() {
auto caf = newConveyorAndFeeder<void>();
write_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void UnixIoStream::notify(uint32_t mask) {
if (mask & EPOLLOUT) {
if (write_ready_) {
write_ready_->feed();
}
}
if (mask & EPOLLIN) {
if (read_ready_) {
read_ready_->feed();
}
}
if (mask & EPOLLRDHUP) {
if (on_read_disconnect_) {
on_read_disconnect_->feed();
}
}
}
UnixServer::UnixServer(UnixEventPort &event_port, int file_descriptor,
int fd_flags)
: IFdOwner{event_port, file_descriptor, fd_flags, EPOLLIN} {}
Conveyor<Own<IoStream>> UnixServer::accept() {
auto caf = newConveyorAndFeeder<Own<IoStream>>();
accept_feeder_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void UnixServer::notify(uint32_t mask) {
if (mask & EPOLLIN) {
if (accept_feeder_) {
struct ::sockaddr_storage address;
socklen_t address_length = sizeof(address);
int accept_fd =
::accept4(fd(), reinterpret_cast<struct ::sockaddr *>(&address),
&address_length, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (accept_fd < 0) {
return;
}
auto fd_stream = heap<UnixIoStream>(event_port_, accept_fd, 0,
EPOLLIN | EPOLLOUT);
accept_feeder_->feed(std::move(fd_stream));
}
}
}
UnixDatagram::UnixDatagram(UnixEventPort &event_port, int file_descriptor,
int fd_flags)
: IFdOwner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
namespace {
ssize_t unixReadMsg(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,
reinterpret_cast<struct ::sockaddr *>(&their_addr),
&addr_len);
}
ssize_t unixWriteMsg(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<size_t> UnixDatagram::read(void *buffer, size_t length) {
ssize_t read_bytes = unixReadMsg(fd(), buffer, length);
if (read_bytes > 0) {
return static_cast<size_t>(read_bytes);
}
return recoverableError("Currently busy");
}
Conveyor<void> UnixDatagram::readReady() {
auto caf = newConveyorAndFeeder<void>();
read_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
ErrorOr<size_t> UnixDatagram::write(const void *buffer, size_t length,
NetworkAddress &dest) {
UnixNetworkAddress &unix_dest = static_cast<UnixNetworkAddress &>(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);
if (write_bytes > 0) {
return static_cast<size_t>(write_bytes);
}
return recoverableError("Currently busy");
}
Conveyor<void> UnixDatagram::writeReady() {
auto caf = newConveyorAndFeeder<void>();
write_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void UnixDatagram::notify(uint32_t mask) {
if (mask & EPOLLOUT) {
if (write_ready_) {
write_ready_->feed();
}
}
if (mask & EPOLLIN) {
if (read_ready_) {
read_ready_->feed();
}
}
}
namespace {
bool beginsWith(const std::string_view &viewed,
const std::string_view &begins) {
return viewed.size() >= begins.size() &&
viewed.compare(0, begins.size(), begins) == 0;
}
std::variant<UnixNetworkAddress, UnixNetworkAddress *>
translateNetworkAddressToUnixNetworkAddress(NetworkAddress &addr) {
auto addr_variant = addr.representation();
std::variant<UnixNetworkAddress, UnixNetworkAddress *> os_addr = std::visit(
[](auto &arg)
-> std::variant<UnixNetworkAddress, UnixNetworkAddress *> {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, OsNetworkAddress *>) {
return static_cast<UnixNetworkAddress *>(arg);
}
auto sock_addrs = SocketAddress::resolve(
std::string_view{arg->address()}, arg->port());
return UnixNetworkAddress{arg->address(), arg->port(),
std::move(sock_addrs)};
},
addr_variant);
return os_addr;
}
UnixNetworkAddress &translateToUnixAddressRef(
std::variant<UnixNetworkAddress, UnixNetworkAddress *> &addr_variant) {
return std::visit(
[](auto &arg) -> UnixNetworkAddress & {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, UnixNetworkAddress>) {
return arg;
} else if constexpr (std::is_same_v<T, UnixNetworkAddress *>) {
return *arg;
} else {
static_assert(true, "Cases exhausted");
}
},
addr_variant);
}
} // namespace
Own<Server> UnixNetwork::listen(NetworkAddress &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
assert(address.unixAddressSize() > 0);
if (address.unixAddressSize() == 0) {
return nullptr;
}
int fd = address.unixAddress(0).socket(SOCK_STREAM);
if (fd < 0) {
return nullptr;
}
int val = 1;
int rc = ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
if (rc < 0) {
::close(fd);
return nullptr;
}
bool failed = address.unixAddress(0).bind(fd);
if (failed) {
::close(fd);
return nullptr;
}
::listen(fd, SOMAXCONN);
return heap<UnixServer>(event_port_, fd, 0);
}
Conveyor<Own<IoStream>> UnixNetwork::connect(NetworkAddress &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
assert(address.unixAddressSize() > 0);
if (address.unixAddressSize() == 0) {
return Conveyor<Own<IoStream>>{criticalError("No address found")};
}
int fd = address.unixAddress(0).socket(SOCK_STREAM);
if (fd < 0) {
return Conveyor<Own<IoStream>>{criticalError("Couldn't open socket")};
}
Own<UnixIoStream> io_stream =
heap<UnixIoStream>(event_port_, fd, 0, EPOLLIN | EPOLLOUT);
bool success = false;
for (size_t i = 0; i < address.unixAddressSize(); ++i) {
SocketAddress &addr_iter = address.unixAddress(i);
int status =
::connect(fd, addr_iter.getRaw(), addr_iter.getRawLength());
if (status < 0) {
int error = errno;
/*
* It's not connected yet...
* But edge triggered epolling means that it'll
* be ready when the signal is triggered
*/
/// @todo Add limit node when implemented
if (error == EINPROGRESS) {
/*
Conveyor<void> write_ready = io_stream->writeReady();
return write_ready.then(
[ios{std::move(io_stream)}]() mutable {
ios->write_ready = nullptr;
return std::move(ios);
});
*/
success = true;
break;
} else if (error != EINTR) {
/// @todo Push error message from
return Conveyor<Own<IoStream>>{
criticalError("Couldn't connect")};
}
} else {
success = true;
break;
}
}
if (!success) {
return criticalError("Couldn't connect");
}
return Conveyor<Own<IoStream>>{std::move(io_stream)};
}
Own<Datagram> UnixNetwork::datagram(NetworkAddress &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
UnixNetworkAddress &address = translateToUnixAddressRef(unix_addr_storage);
SAW_ASSERT(address.unixAddressSize() > 0) { return nullptr; }
int fd = address.unixAddress(0).socket(SOCK_DGRAM);
int optval = 1;
int rc =
::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
if (rc < 0) {
::close(fd);
return nullptr;
}
bool failed = address.unixAddress(0).bind(fd);
if (failed) {
::close(fd);
return nullptr;
}
/// @todo
return heap<UnixDatagram>(event_port_, fd, 0);
}
const std::string &UnixNetworkAddress::address() const { return path_; }
uint16_t UnixNetworkAddress::port() const { return port_hint_; }
SocketAddress &UnixNetworkAddress::unixAddress(size_t i) {
assert(i < addresses_.size());
/// @todo change from list to vector?
return addresses_.at(i);
}
size_t UnixNetworkAddress::unixAddressSize() const { return addresses_.size(); }
UnixNetwork::UnixNetwork(UnixEventPort &event) : event_port_{event} {}
Conveyor<Own<NetworkAddress>>
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)) {
addr_view.remove_prefix(begins_with.size());
}
}
std::vector<SocketAddress> addresses =
SocketAddress::resolve(addr_view, port_hint);
return Conveyor<Own<NetworkAddress>>{
heap<UnixNetworkAddress>(path, port_hint, std::move(addresses))};
}
UnixIoProvider::UnixIoProvider(UnixEventPort &port_ref, Own<EventPort> port)
: event_port_{port_ref}, event_loop_{std::move(port)}, unix_network_{
port_ref} {}
Own<InputStream> UnixIoProvider::wrapInputFd(int fd) {
return heap<UnixIoStream>(event_port_, fd, 0, EPOLLIN);
}
Network &UnixIoProvider::network() {
return static_cast<Network &>(unix_network_);
}
EventLoop &UnixIoProvider::eventLoop() { return event_loop_; }
} // namespace unix
ErrorOr<AsyncIoContext> setupAsyncIo() {
using namespace unix;
try {
Own<UnixEventPort> prt = heap<UnixEventPort>();
UnixEventPort &prt_ref = *prt;
Own<UnixIoProvider> io_provider =
heap<UnixIoProvider>(prt_ref, std::move(prt));
EventLoop &loop_ref = io_provider->eventLoop();
return {{std::move(io_provider), loop_ref, prt_ref}};
} catch (std::bad_alloc &) {
return criticalError("Out of memory");
}
}
} // namespace saw

431
driver/io_unix.cpp Normal file
View File

@ -0,0 +1,431 @@
#include "io_unix.h"
#include <sstream>
namespace saw {
namespace unix {
i_fd_owner::i_fd_owner(unix_event_port &event_port, int file_descriptor,
int fd_flags, uint32_t event_mask)
: event_port_{event_port}, file_descriptor_{file_descriptor},
fd_flags_{fd_flags}, event_mask_{event_mask} {
event_port_.subscribe(*this, file_descriptor, event_mask);
}
i_fd_owner::~i_fd_owner() {
if (file_descriptor_ >= 0) {
event_port_.unsubscribe(file_descriptor_);
::close(file_descriptor_);
}
}
ssize_t unix_read(int fd, void *buffer, size_t length) {
return ::recv(fd, buffer, length, 0);
}
ssize_t unix_write(int fd, const void *buffer, size_t length) {
return ::send(fd, buffer, length, 0);
}
unix_io_stream::unix_io_stream(unix_event_port &event_port, int file_descriptor,
int fd_flags, uint32_t event_mask)
: i_fd_owner{event_port, file_descriptor, fd_flags,
event_mask | EPOLLRDHUP} {}
error_or<size_t> unix_io_stream::read(void *buffer, size_t length) {
ssize_t read_bytes = unix_read(fd(), buffer, length);
if (read_bytes > 0) {
return static_cast<size_t>(read_bytes);
} else if (read_bytes == 0) {
return critical_error("Disconnected", error::code::Disconnected);
}
return recoverable_error("Currently busy");
}
conveyor<void> unix_io_stream::read_ready() {
auto caf = new_conveyor_and_feeder<void>();
read_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
conveyor<void> unix_io_stream::on_read_disconnected() {
auto caf = new_conveyor_and_feeder<void>();
on_read_disconnect_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
error_or<size_t> unix_io_stream::write(const void *buffer, size_t length) {
ssize_t write_bytes = unix_write(fd(), buffer, length);
if (write_bytes > 0) {
return static_cast<size_t>(write_bytes);
}
int error = errno;
if (error == EAGAIN || error == EWOULDBLOCK) {
return recoverable_error("Currently busy");
}
return critical_error("Disconnected", error::code::Disconnected);
}
conveyor<void> unix_io_stream::write_ready() {
auto caf = new_conveyor_and_feeder<void>();
write_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void unix_io_stream::notify(uint32_t mask) {
if (mask & EPOLLOUT) {
if (write_ready_) {
write_ready_->feed();
}
}
if (mask & EPOLLIN) {
if (read_ready_) {
read_ready_->feed();
}
}
if (mask & EPOLLRDHUP) {
if (on_read_disconnect_) {
on_read_disconnect_->feed();
}
}
}
unix_server::unix_server(unix_event_port &event_port, int file_descriptor,
int fd_flags)
: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN} {}
conveyor<own<io_stream>> unix_server::accept() {
auto caf = new_conveyor_and_feeder<own<io_stream>>();
accept_feeder_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void unix_server::notify(uint32_t mask) {
if (mask & EPOLLIN) {
if (accept_feeder_) {
struct ::sockaddr_storage address;
socklen_t address_length = sizeof(address);
int accept_fd =
::accept4(fd(), reinterpret_cast<struct ::sockaddr *>(&address),
&address_length, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (accept_fd < 0) {
return;
}
auto fd_stream = heap<unix_io_stream>(event_port_, accept_fd, 0,
EPOLLIN | EPOLLOUT);
accept_feeder_->feed(std::move(fd_stream));
}
}
}
unix_datagram::unix_datagram(unix_event_port &event_port, int file_descriptor,
int fd_flags)
: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
namespace {
ssize_t unixReadMsg(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,
reinterpret_cast<struct ::sockaddr *>(&their_addr),
&addr_len);
}
ssize_t unixWriteMsg(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
error_or<size_t> unix_datagram::read(void *buffer, size_t length) {
ssize_t read_bytes = unixReadMsg(fd(), buffer, length);
if (read_bytes > 0) {
return static_cast<size_t>(read_bytes);
}
return recoverable_error("Currently busy");
}
conveyor<void> unix_datagram::read_ready() {
auto caf = new_conveyor_and_feeder<void>();
read_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
error_or<size_t> unix_datagram::write(const void *buffer, size_t length,
network_address &dest) {
unix_network_address &unix_dest = static_cast<unix_network_address &>(dest);
socket_address &sock_addr = unix_dest.unix_address();
socklen_t sock_addr_length = sock_addr.get_raw_length();
ssize_t write_bytes = unixWriteMsg(fd(), buffer, length,
sock_addr.get_raw(), sock_addr_length);
if (write_bytes > 0) {
return static_cast<size_t>(write_bytes);
}
return recoverable_error("Currently busy");
}
conveyor<void> unix_datagram::write_ready() {
auto caf = new_conveyor_and_feeder<void>();
write_ready_ = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void unix_datagram::notify(uint32_t mask) {
if (mask & EPOLLOUT) {
if (write_ready_) {
write_ready_->feed();
}
}
if (mask & EPOLLIN) {
if (read_ready_) {
read_ready_->feed();
}
}
}
namespace {
bool beginsWith(const std::string_view &viewed,
const std::string_view &begins) {
return viewed.size() >= begins.size() &&
viewed.compare(0, begins.size(), begins) == 0;
}
std::variant<unix_network_address, unix_network_address *>
translateNetworkAddressToUnixNetworkAddress(network_address &addr) {
auto addr_variant = addr.representation();
std::variant<unix_network_address, unix_network_address *> os_addr =
std::visit(
[](auto &arg)
-> std::variant<unix_network_address, unix_network_address *> {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, os_network_address *>) {
return static_cast<unix_network_address *>(arg);
}
auto sock_addrs = socket_address::resolve(
std::string_view{arg->address()}, arg->port());
return unix_network_address{arg->address(), arg->port(),
std::move(sock_addrs)};
},
addr_variant);
return os_addr;
}
unix_network_address &translateToUnixAddressRef(
std::variant<unix_network_address, unix_network_address *> &addr_variant) {
return std::visit(
[](auto &arg) -> unix_network_address & {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, unix_network_address>) {
return arg;
} else if constexpr (std::is_same_v<T, unix_network_address *>) {
return *arg;
} else {
static_assert(true, "Cases exhausted");
}
},
addr_variant);
}
} // namespace
own<server> unix_network::listen(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage);
assert(address.unix_address_size() > 0);
if (address.unix_address_size() == 0) {
return nullptr;
}
int fd = address.unix_address(0).socket(SOCK_STREAM);
if (fd < 0) {
return nullptr;
}
int val = 1;
int rc = ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
if (rc < 0) {
::close(fd);
return nullptr;
}
bool failed = address.unix_address(0).bind(fd);
if (failed) {
::close(fd);
return nullptr;
}
::listen(fd, SOMAXCONN);
return heap<unix_server>(event_port_, fd, 0);
}
conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage);
assert(address.unix_address_size() > 0);
if (address.unix_address_size() == 0) {
return conveyor<own<io_stream>>{critical_error("No address found")};
}
int fd = address.unix_address(0).socket(SOCK_STREAM);
if (fd < 0) {
return conveyor<own<io_stream>>{critical_error("Couldn't open socket")};
}
own<unix_io_stream> io_str =
heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN | EPOLLOUT);
bool success = false;
for (size_t i = 0; i < address.unix_address_size(); ++i) {
socket_address &addr_iter = address.unix_address(i);
int status =
::connect(fd, addr_iter.get_raw(), addr_iter.get_raw_length());
if (status < 0) {
int error = errno;
/*
* It's not connected yet...
* But edge triggered epolling means that it'll
* be ready when the signal is triggered
*/
/// @todo Add limit node when implemented
if (error == EINPROGRESS) {
/*
Conveyor<void> write_ready = io_stream->writeReady();
return write_ready.then(
[ios{std::move(io_stream)}]() mutable {
ios->write_ready = nullptr;
return std::move(ios);
});
*/
success = true;
break;
} else if (error != EINTR) {
/// @todo Push error message from
return conveyor<own<io_stream>>{
critical_error("Couldn't connect")};
}
} else {
success = true;
break;
}
}
if (!success) {
return critical_error("Couldn't connect");
}
return conveyor<own<io_stream>>{std::move(io_str)};
}
own<datagram> unix_network::datagram(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage);
SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; }
int fd = address.unix_address(0).socket(SOCK_DGRAM);
int optval = 1;
int rc =
::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
if (rc < 0) {
::close(fd);
return nullptr;
}
bool failed = address.unix_address(0).bind(fd);
if (failed) {
::close(fd);
return nullptr;
}
/// @todo
return heap<unix_datagram>(event_port_, fd, 0);
}
const std::string &unix_network_address::address() const { return path_; }
uint16_t unix_network_address::port() const { return port_hint_; }
socket_address &unix_network_address::unix_address(size_t i) {
assert(i < addresses_.size());
/// @todo change from list to vector?
return addresses_.at(i);
}
size_t unix_network_address::unix_address_size() const {
return addresses_.size();
}
unix_network::unix_network(unix_event_port &event) : event_port_{event} {}
conveyor<own<network_address>>
unix_network::resolve_address(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)) {
addr_view.remove_prefix(begins_with.size());
}
}
std::vector<socket_address> addresses =
socket_address::resolve(addr_view, port_hint);
return conveyor<own<network_address>>{
heap<unix_network_address>(path, port_hint, std::move(addresses))};
}
unix_io_provider::unix_io_provider(unix_event_port &port_ref,
own<event_port> port)
: event_port_{port_ref}, event_loop_{std::move(port)}, unix_network_{
port_ref} {}
own<input_stream> unix_io_provider::wrap_input_fd(int fd) {
return heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN);
}
class network &unix_io_provider::network() {
return static_cast<class network &>(unix_network_);
}
class event_loop &unix_io_provider::event_loop() {
return event_loop_;
}
} // namespace unix
error_or<async_io_context> setup_async_io() {
using namespace unix;
try {
own<unix_event_port> prt = heap<unix_event_port>();
unix_event_port &prt_ref = *prt;
own<unix_io_provider> io_provider =
heap<unix_io_provider>(prt_ref, std::move(prt));
event_loop &loop_ref = io_provider->event_loop();
return {{std::move(io_provider), loop_ref, prt_ref}};
} catch (std::bad_alloc &) {
return critical_error("Out of memory");
}
}
} // namespace saw

183
driver/io-unix.h → driver/io_unix.h
View File

@ -26,16 +26,16 @@
#include <unordered_map>
#include <vector>
#include "forstio/io.h"
#include "io.h"
namespace saw {
namespace unix {
constexpr int MAX_EPOLL_EVENTS = 256;
class UnixEventPort;
class IFdOwner {
class unix_event_port;
class i_fd_owner {
protected:
UnixEventPort &event_port_;
unix_event_port &event_port_;
private:
int file_descriptor_;
@ -43,29 +43,29 @@ private:
uint32_t event_mask_;
public:
IFdOwner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
uint32_t event_mask);
i_fd_owner(unix_event_port &event_port, int file_descriptor, int fd_flags,
uint32_t event_mask);
virtual ~IFdOwner();
virtual ~i_fd_owner();
virtual void notify(uint32_t mask) = 0;
int fd() const { return file_descriptor_; }
};
class UnixEventPort final : public EventPort {
class unix_event_port final : public event_port {
private:
int epoll_fd_;
int signal_fd_;
sigset_t signal_fd_set_;
std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>>
std::unordered_multimap<Signal, own<conveyor_feeder<void>>>
signal_conveyors_;
int pipefds_[2];
std::vector<int> toUnixSignal(Signal signal) const {
std::vector<int> to_unix_signal(Signal signal) const {
switch (signal) {
case Signal::User1:
return {SIGUSR1};
@ -75,7 +75,7 @@ private:
}
}
Signal fromUnixSignal(int signal) const {
Signal from_unix_signal(int signal) const {
switch (signal) {
case SIGUSR1:
return Signal::User1;
@ -87,8 +87,8 @@ private:
}
}
void notifySignalListener(int sig) {
Signal signal = fromUnixSignal(sig);
void notify_signal_listener(int sig) {
Signal signal = from_unix_signal(sig);
auto equal_range = signal_conveyors_.equal_range(signal);
for (auto iter = equal_range.first; iter != equal_range.second;
@ -102,7 +102,7 @@ private:
}
}
bool pollImpl(int time) {
bool poll_impl(int time) {
epoll_event events[MAX_EPOLL_EVENTS];
int nfds = 0;
do {
@ -124,7 +124,7 @@ private:
}
assert(n == sizeof(siginfo));
notifySignalListener(siginfo.ssi_signo);
notify_signal_listener(siginfo.ssi_signo);
}
} else if (events[i].data.u64 == 1) {
uint8_t i;
@ -138,8 +138,8 @@ private:
}
}
} else {
IFdOwner *owner =
reinterpret_cast<IFdOwner *>(events[i].data.ptr);
i_fd_owner *owner =
reinterpret_cast<i_fd_owner *>(events[i].data.ptr);
if (owner) {
owner->notify(events[i].events);
}
@ -151,7 +151,7 @@ private:
}
public:
UnixEventPort() : epoll_fd_{-1}, signal_fd_{-1} {
unix_event_port() : epoll_fd_{-1}, signal_fd_{-1} {
::signal(SIGPIPE, SIG_IGN);
epoll_fd_ = ::epoll_create1(EPOLL_CLOEXEC);
@ -182,19 +182,19 @@ public:
::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, pipefds_[0], &event);
}
~UnixEventPort() {
~unix_event_port() {
::close(epoll_fd_);
::close(signal_fd_);
::close(pipefds_[0]);
::close(pipefds_[1]);
}
Conveyor<void> onSignal(Signal signal) override {
auto caf = newConveyorAndFeeder<void>();
conveyor<void> on_signal(Signal signal) override {
auto caf = new_conveyor_and_feeder<void>();
signal_conveyors_.insert(std::make_pair(signal, std::move(caf.feeder)));
std::vector<int> sig = toUnixSignal(signal);
std::vector<int> sig = to_unix_signal(signal);
for (auto iter = sig.begin(); iter != sig.end(); ++iter) {
::sigaddset(&signal_fd_set_, *iter);
@ -202,17 +202,18 @@ public:
::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));
auto node = conveyor<void>::from_conveyor(std::move(caf.conveyor));
return conveyor<void>::to_conveyor(std::move(node));
}
void poll() override { pollImpl(0); }
void poll() override { poll_impl(0); }
void wait() override { pollImpl(-1); }
void wait() override { poll_impl(-1); }
void wait(const std::chrono::steady_clock::duration &duration) override {
pollImpl(std::chrono::duration_cast<std::chrono::milliseconds>(duration)
.count());
poll_impl(
std::chrono::duration_cast<std::chrono::milliseconds>(duration)
.count());
}
void
wait(const std::chrono::steady_clock::time_point &time_point) override {
@ -220,9 +221,9 @@ public:
if (time_point <= now) {
poll();
} else {
pollImpl(std::chrono::duration_cast<std::chrono::milliseconds>(
time_point - now)
.count());
poll_impl(std::chrono::duration_cast<std::chrono::milliseconds>(
time_point - now)
.count());
}
}
@ -236,7 +237,7 @@ public:
::send(pipefds_[1], &i, sizeof(i), MSG_DONTWAIT);
}
void subscribe(IFdOwner &owner, int fd, uint32_t event_mask) {
void subscribe(i_fd_owner &owner, int fd, uint32_t event_mask) {
if (epoll_fd_ < 0 || fd < 0) {
return;
}
@ -262,28 +263,28 @@ public:
}
};
ssize_t unixRead(int fd, void *buffer, size_t length);
ssize_t unixWrite(int fd, const void *buffer, size_t length);
ssize_t unix_read(int fd, void *buffer, size_t length);
ssize_t unix_write(int fd, const void *buffer, size_t length);
class UnixIoStream final : public IoStream, public IFdOwner {
class unix_io_stream final : public io_stream, public i_fd_owner {
private:
Own<ConveyorFeeder<void>> read_ready_ = nullptr;
Own<ConveyorFeeder<void>> on_read_disconnect_ = nullptr;
Own<ConveyorFeeder<void>> write_ready_ = nullptr;
own<conveyor_feeder<void>> read_ready_ = nullptr;
own<conveyor_feeder<void>> on_read_disconnect_ = nullptr;
own<conveyor_feeder<void>> write_ready_ = nullptr;
public:
UnixIoStream(UnixEventPort &event_port, int file_descriptor, int fd_flags,
uint32_t event_mask);
unix_io_stream(unix_event_port &event_port, int file_descriptor,
int fd_flags, uint32_t event_mask);
ErrorOr<size_t> read(void *buffer, size_t length) override;
error_or<size_t> read(void *buffer, size_t length) override;
Conveyor<void> readReady() override;
conveyor<void> read_ready() override;
Conveyor<void> onReadDisconnected() override;
conveyor<void> on_read_disconnected() override;
ErrorOr<size_t> write(const void *buffer, size_t length) override;
error_or<size_t> write(const void *buffer, size_t length) override;
Conveyor<void> writeReady() override;
conveyor<void> write_ready() override;
/*
void read(void *buffer, size_t min_length, size_t max_length) override;
@ -300,32 +301,33 @@ public:
void notify(uint32_t mask) override;
};
class UnixServer final : public Server, public IFdOwner {
class unix_server final : public server, public i_fd_owner {
private:
Own<ConveyorFeeder<Own<IoStream>>> accept_feeder_ = nullptr;
own<conveyor_feeder<own<io_stream>>> accept_feeder_ = nullptr;
public:
UnixServer(UnixEventPort &event_port, int file_descriptor, int fd_flags);
unix_server(unix_event_port &event_port, int file_descriptor, int fd_flags);
Conveyor<Own<IoStream>> accept() override;
conveyor<own<io_stream>> accept() override;
void notify(uint32_t mask) override;
};
class UnixDatagram final : public Datagram, public IFdOwner {
class unix_datagram final : public datagram, public i_fd_owner {
private:
Own<ConveyorFeeder<void>> read_ready_ = nullptr;
Own<ConveyorFeeder<void>> write_ready_ = nullptr;
own<conveyor_feeder<void>> read_ready_ = nullptr;
own<conveyor_feeder<void>> write_ready_ = nullptr;
public:
UnixDatagram(UnixEventPort &event_port, int file_descriptor, int fd_flags);
unix_datagram(unix_event_port &event_port, int file_descriptor,
int fd_flags);
ErrorOr<size_t> read(void *buffer, size_t length) override;
Conveyor<void> readReady() override;
error_or<size_t> read(void *buffer, size_t length) override;
conveyor<void> read_ready() override;
ErrorOr<size_t> write(const void *buffer, size_t length,
NetworkAddress &dest) override;
Conveyor<void> writeReady() override;
error_or<size_t> write(const void *buffer, size_t length,
network_address &dest) override;
conveyor<void> write_ready() override;
void notify(uint32_t mask) override;
};
@ -333,7 +335,7 @@ public:
/**
* Helper class which provides potential addresses to NetworkAddress
*/
class SocketAddress {
class socket_address {
private:
union {
struct sockaddr generic;
@ -346,10 +348,10 @@ private:
socklen_t address_length_;
bool wildcard_;
SocketAddress() : wildcard_{false} {}
socket_address() : wildcard_{false} {}
public:
SocketAddress(const void *sockaddr, socklen_t len, bool wildcard)
socket_address(const void *sockaddr, socklen_t len, bool wildcard)
: address_length_{len}, wildcard_{wildcard} {
assert(len <= sizeof(address_));
memcpy(&address_.generic, sockaddr, len);
@ -371,17 +373,17 @@ public:
return error < 0;
}
struct ::sockaddr *getRaw() {
struct ::sockaddr *get_raw() {
return &address_.generic;
}
const struct ::sockaddr *getRaw() const { return &address_.generic; }
const struct ::sockaddr *get_raw() const { return &address_.generic; }
socklen_t getRawLength() const { return address_length_; }
socklen_t get_raw_length() const { return address_length_; }
static std::vector<SocketAddress> resolve(std::string_view str,
uint16_t port_hint) {
std::vector<SocketAddress> results;
static std::vector<socket_address> resolve(std::string_view str,
uint16_t port_hint) {
std::vector<socket_address> results;
struct ::addrinfo *head;
struct ::addrinfo hints;
@ -400,7 +402,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(socket_address::address_)) {
continue;
}
results.push_back({it->ai_addr, it->ai_addrlen, wildcard});
@ -410,15 +412,15 @@ public:
}
};
class UnixNetworkAddress final : public OsNetworkAddress {
class unix_network_address final : public os_network_address {
private:
const std::string path_;
uint16_t port_hint_;
std::vector<SocketAddress> addresses_;
std::vector<socket_address> addresses_;
public:
UnixNetworkAddress(const std::string &path, uint16_t port_hint,
std::vector<SocketAddress> &&addr)
unix_network_address(const std::string &path, uint16_t port_hint,
std::vector<socket_address> &&addr)
: path_{path}, port_hint_{port_hint}, addresses_{std::move(addr)} {}
const std::string &address() const override;
@ -426,42 +428,43 @@ public:
uint16_t port() const override;
// Custom address info
SocketAddress &unixAddress(size_t i = 0);
size_t unixAddressSize() const;
socket_address &unix_address(size_t i = 0);
size_t unix_address_size() const;
};
class UnixNetwork final : public Network {
class unix_network final : public network {
private:
UnixEventPort &event_port_;
unix_event_port &event_port_;
public:
UnixNetwork(UnixEventPort &event_port);
unix_network(unix_event_port &event_port);
Conveyor<Own<NetworkAddress>>
resolveAddress(const std::string &address, uint16_t port_hint = 0) override;
conveyor<own<network_address>>
resolve_address(const std::string &address,
uint16_t port_hint = 0) override;
Own<Server> listen(NetworkAddress &addr) override;
own<server> listen(network_address &addr) override;
Conveyor<Own<IoStream>> connect(NetworkAddress &addr) override;
conveyor<own<io_stream>> connect(network_address &addr) override;
Own<Datagram> datagram(NetworkAddress &addr) override;
own<class datagram> datagram(network_address &addr) override;
};
class UnixIoProvider final : public IoProvider {
class unix_io_provider final : public io_provider {
private:
UnixEventPort &event_port_;
EventLoop event_loop_;
unix_event_port &event_port_;
class event_loop event_loop_;
UnixNetwork unix_network_;
unix_network unix_network_;
public:
UnixIoProvider(UnixEventPort &port_ref, Own<EventPort> port);
unix_io_provider(unix_event_port &port_ref, own<event_port> port);
Network &network() override;
class network &network() override;
Own<InputStream> wrapInputFd(int fd) override;
own<input_stream> wrap_input_fd(int fd) override;
EventLoop &eventLoop();
class event_loop &event_loop();
};
} // namespace unix
} // namespace saw

213
source/forstio/async.cpp
View File

@ -7,38 +7,38 @@
namespace saw {
namespace {
thread_local EventLoop *local_loop = nullptr;
thread_local event_loop *local_loop = nullptr;
EventLoop &currentEventLoop() {
EventLoop *loop = local_loop;
event_loop &current_event_loop() {
event_loop *loop = local_loop;
assert(loop);
return *loop;
}
} // namespace
ConveyorNode::ConveyorNode() {}
conveyor_node::conveyor_node() {}
ConveyorNodeWithChildMixin::ConveyorNodeWithChildMixin(
Own<ConveyorNode> &&child_, ConveyorNode &owner)
conveyor_node_with_child_mixin::conveyor_node_with_child_mixin(
own<conveyor_node> &&child_, conveyor_node &owner)
: child{std::move(child_)} {
assert(child);
child->notifyParentAttached(owner);
child->notify_parent_attached(owner);
}
ErrorOr<Own<ConveyorNode>>
ConveyorNodeWithChildMixin::swapChild(Own<ConveyorNode> &&swapee) {
error_or<own<conveyor_node>>
conveyor_node_with_child_mixin::swap_child(own<conveyor_node> &&swapee) {
SAW_ASSERT(child) {
return criticalError("Child should exist if this function is called");
return critical_error("Child should exist if this function is called");
}
Own<ConveyorNode> old_child = std::move(child);
own<conveyor_node> 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->next_storage();
conveyor_storage *old_storage_parent =
old_storage ? old_storage->get_parent() : nullptr;
/**
* Swap in the new child
@ -51,56 +51,56 @@ ConveyorNodeWithChildMixin::swapChild(Own<ConveyorNode> &&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->next_storage();
if (swapee_storage) {
swapee_storage->setParent(old_storage_parent);
swapee_storage->set_parent(old_storage_parent);
}
}
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::get_parent() const { return parent_; }
void ConveyorEventStorage::setParent(ConveyorStorage *p) {
void conveyor_event_storage::set_parent(conveyor_storage *p) {
/*
* parent check isn't needed, but is used
* for the assert, because the storage should
* be armed if there was an element present
* and a valid parent
*/
if (/*!parent && */ p && !isArmed() && queued() > 0) {
if (/*!parent && */ p && !is_armed() && queued() > 0) {
assert(!parent_);
if (p->space() > 0) {
armLater();
arm_later();
}
}
parent_ = p;
}
ConveyorEventStorage::ConveyorEventStorage() : ConveyorStorage{} {}
conveyor_event_storage::conveyor_event_storage() : conveyor_storage{} {}
ConveyorBase::ConveyorBase(Own<ConveyorNode> &&node_p)
conveyor_base::conveyor_base(own<conveyor_node> &&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.copy_error();
}
Error PropagateError::operator()(Error &&error) { return std::move(error); }
error propagate_error::operator()(error &&err) { return std::move(err); }
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::arm_next() {
assert(&loop_ == local_loop);
if (prev_ == nullptr) {
// Push the next_insert_point back by one
@ -129,11 +129,11 @@ void Event::armNext() {
loop_.tail_ = &next_;
}
loop_.setRunnable(true);
loop_.set_runnable(true);
}
}
void Event::armLater() {
void event::arm_later() {
assert(&loop_ == local_loop);
if (prev_ == nullptr) {
@ -149,11 +149,11 @@ void Event::armLater() {
loop_.tail_ = &next_;
}
loop_.setRunnable(true);
loop_.set_runnable(true);
}
}
void Event::armLast() {
void event::arm_last() {
assert(&loop_ == local_loop);
if (prev_ == nullptr) {
@ -168,11 +168,11 @@ void Event::armLast() {
loop_.tail_ = &next_;
}
loop_.setRunnable(true);
loop_.set_runnable(true);
}
}
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::is_armed() const { return prev_ != nullptr; }
ConveyorSink::ConveyorSink() : node_{nullptr} {}
conveyor_sink::conveyor_sink() : node_{nullptr} {}
ConveyorSink::ConveyorSink(Own<ConveyorNode> &&node_p)
conveyor_sink::conveyor_sink(own<conveyor_node> &&node_p)
: node_{std::move(node_p)} {}
void EventLoop::setRunnable(bool runnable) { is_runnable_ = runnable; }
void event_loop::set_runnable(bool runnable) { is_runnable_ = runnable; }
EventLoop::EventLoop() {}
event_loop::event_loop() {}
EventLoop::EventLoop(Own<EventPort> &&event_port)
: event_port_{std::move(event_port)} {}
event_loop::event_loop(own<class event_port> &&ep)
: event_port_{std::move(ep)} {}
EventLoop::~EventLoop() { assert(local_loop != this); }
event_loop::~event_loop() { assert(local_loop != this); }
void EventLoop::enterScope() {
void event_loop::enter_scope() {
assert(!local_loop);
local_loop = this;
}
void EventLoop::leaveScope() {
void event_loop::leave_scope() {
assert(local_loop == this);
local_loop = nullptr;
}
bool EventLoop::turnLoop() {
bool event_loop::turn_loop() {
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,158 +259,161 @@ 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);
}
return turnLoop();
return turn_loop();
}
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);
}
return turnLoop();
return turn_loop();
}
bool EventLoop::wait() {
bool event_loop::wait() {
if (event_port_) {
event_port_->wait();
}
return turnLoop();
return turn_loop();
}
bool EventLoop::poll() {
bool event_loop::poll() {
if (event_port_) {
event_port_->poll();
}
return turnLoop();
return turn_loop();
}
EventPort *EventLoop::eventPort() { return event_port_.get(); }
event_port *event_loop::event_port() { return event_port_.get(); }
ConveyorSinkSet &EventLoop::daemon() {
conveyor_sink_set &event_loop::daemon() {
if (!daemon_sink_) {
daemon_sink_ = heap<ConveyorSinkSet>();
daemon_sink_ = heap<conveyor_sink_set>();
}
return *daemon_sink_;
}
WaitScope::WaitScope(EventLoop &loop) : loop_{loop} { loop_.enterScope(); }
wait_scope::wait_scope(event_loop &loop) : loop_{loop} { loop_.enter_scope(); }
WaitScope::~WaitScope() { loop_.leaveScope(); }
wait_scope::~wait_scope() { loop_.leave_scope(); }
void WaitScope::wait() { loop_.wait(); }
void wait_scope::wait() { loop_.wait(); }
void WaitScope::wait(const std::chrono::steady_clock::duration &duration) {
void wait_scope::wait(const std::chrono::steady_clock::duration &duration) {
loop_.wait(duration);
}
void WaitScope::wait(const std::chrono::steady_clock::time_point &time_point) {
void wait_scope::wait(const std::chrono::steady_clock::time_point &time_point) {
loop_.wait(time_point);
}
void WaitScope::poll() { loop_.poll(); }
void wait_scope::poll() { loop_.poll(); }
ErrorOr<Own<ConveyorNode>>
ConvertConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee) noexcept {
return child_mixin_.swapChild(std::move(swapee));
error_or<own<conveyor_node>>
convert_conveyor_node_base::swap_child(own<conveyor_node> &&swapee) noexcept {
return child_mixin_.swap_child(std::move(swapee));
}
ConveyorStorage *ConvertConveyorNodeBase::nextStorage() noexcept {
conveyor_storage *convert_conveyor_node_base::next_storage() noexcept {
if (!child_mixin_.child) {
return nullptr;
}
return child_mixin_.child->nextStorage();
return child_mixin_.child->next_storage();
}
ImmediateConveyorNodeBase::ImmediateConveyorNodeBase()
: ConveyorEventStorage{} {}
immediate_conveyor_node_base::immediate_conveyor_node_base()
: conveyor_event_storage{} {}
MergeConveyorNodeBase::MergeConveyorNodeBase() : ConveyorEventStorage{} {}
merge_conveyor_node_base::merge_conveyor_node_base()
: conveyor_event_storage{} {}
ErrorOr<Own<ConveyorNode>>
QueueBufferConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
return child_mixin_.swapChild(std::move(swapee_));
error_or<own<conveyor_node>> queue_buffer_conveyor_node_base::swap_child(
own<conveyor_node> &&swapee_) noexcept {
return child_mixin_.swap_child(std::move(swapee_));
}
void ConveyorSinkSet::destroySinkConveyorNode(ConveyorNode &node) {
if (!isArmed()) {
armLast();
void conveyor_sink_set::destroy_sink_conveyor_node(conveyor_node &node) {
if (!is_armed()) {
arm_last();
}
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<void> &&sink) {
auto nas = Conveyor<void>::fromConveyor(std::move(sink));
void conveyor_sink_set::add(conveyor<void> &&sink) {
auto nas = conveyor<void>::from_conveyor(std::move(sink));
SAW_ASSERT(nas) { return; }
ConveyorStorage *storage = nas->nextStorage();
conveyor_storage *storage = nas->next_storage();
Own<SinkConveyorNode> sink_node = nullptr;
own<sink_conveyor_node> sink_node = nullptr;
try {
sink_node = heap<SinkConveyorNode>(std::move(nas), *this);
sink_node = heap<sink_conveyor_node>(std::move(nas), *this);
} catch (std::bad_alloc &) {
return;
}
if (storage) {
storage->setParent(sink_node.get());
storage->set_parent(sink_node.get());
}
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<ConveyorNode> &element) {
[node](own<conveyor_node> &element) {
return node == element.get();
});
delete_nodes_.pop();
}
}
ConvertConveyorNodeBase::ConvertConveyorNodeBase(Own<ConveyorNode> &&dep)
convert_conveyor_node_base::convert_conveyor_node_base(own<conveyor_node> &&dep)
: child_mixin_{std::move(dep), *this} {}
void ConvertConveyorNodeBase::getResult(ErrorOrValue &err_or_val) {
getImpl(err_or_val);
void convert_conveyor_node_base::get_result(error_or_value &err_or_val) {
get_impl(err_or_val);
}
void AttachConveyorNodeBase::getResult(ErrorOrValue &err_or_val) noexcept {
void attach_conveyor_node_base::get_result(
error_or_value &err_or_val) noexcept {
if (child_mixin_.child) {
child_mixin_.child->getResult(err_or_val);
child_mixin_.child->get_result(err_or_val);
}
}
ErrorOr<Own<ConveyorNode>>
AttachConveyorNodeBase::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
return child_mixin_.swapChild(std::move(swapee_));
error_or<own<conveyor_node>>
attach_conveyor_node_base::swap_child(own<conveyor_node> &&swapee_) noexcept {
return child_mixin_.swap_child(std::move(swapee_));
}
ConveyorStorage *AttachConveyorNodeBase::nextStorage() noexcept {
conveyor_storage *attach_conveyor_node_base::next_storage() noexcept {
if (!child_mixin_.child) {
return nullptr;
}
return child_mixin_.child->nextStorage();
return child_mixin_.child->next_storage();
}
void detachConveyor(Conveyor<void> &&conveyor) {
EventLoop &loop = currentEventLoop();
ConveyorSinkSet &sink = loop.daemon();
void detach_conveyor(conveyor<void> &&conveyor) {
event_loop &loop = current_event_loop();
conveyor_sink_set &sink = loop.daemon();
sink.add(std::move(conveyor));
}
} // namespace saw

682
source/forstio/async.h
View File

File diff suppressed because it is too large Load Diff

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

@ -10,18 +10,18 @@
namespace saw {
template <typename Func> ConveyorResult<Func, void> execLater(Func &&func) {
Conveyor<void> conveyor{FixVoid<void>{}};
template <typename Func> conveyor_result<Func, void> execLater(Func &&func) {
conveyor<void> conveyor{fix_void<void>{}};
return conveyor.then(std::move(func));
}
template <typename T>
Conveyor<T>::Conveyor(FixVoid<T> value) : ConveyorBase(nullptr) {
conveyor<T>::conveyor(fix_void<T> value) : conveyor_base(nullptr) {
// Is there any way to do this?
// @todo new ConveyorBase constructor for Immediate values
// @todo new conveyor_base constructor for Immediate values
Own<ImmediateConveyorNode<FixVoid<T>>> immediate =
heap<ImmediateConveyorNode<FixVoid<T>>>(std::move(value));
own<immediate_conveyor_node<fix_void<T>>> immediate =
heap<immediate_conveyor_node<fix_void<T>>>(std::move(value));
if (!immediate) {
return;
@ -31,9 +31,9 @@ Conveyor<T>::Conveyor(FixVoid<T> value) : ConveyorBase(nullptr) {
}
template <typename T>
Conveyor<T>::Conveyor(Error &&error) : ConveyorBase(nullptr) {
Own<ImmediateConveyorNode<FixVoid<T>>> immediate =
heap<ImmediateConveyorNode<FixVoid<T>>>(std::move(error));
conveyor<T>::conveyor(error &&err) : conveyor_base(nullptr) {
own<immediate_conveyor_node<fix_void<T>>> immediate =
heap<immediate_conveyor_node<fix_void<T>>>(std::move(err));
if (!immediate) {
return;
@ -43,146 +43,151 @@ Conveyor<T>::Conveyor(Error &&error) : ConveyorBase(nullptr) {
}
template <typename T>
Conveyor<T>::Conveyor(Own<ConveyorNode> node_p)
: ConveyorBase{std::move(node_p)} {}
conveyor<T>::conveyor(own<conveyor_node> node_p)
: conveyor_base{std::move(node_p)} {}
template <typename T>
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),
std::move(error_func));
conveyor_result<Func, T> conveyor<T>::then(Func &&func,
ErrorFunc &&error_func) {
own<conveyor_node> conversion_node =
heap<convert_conveyor_node<fix_void<return_type<Func, T>>, fix_void<T>,
Func, ErrorFunc>>(
std::move(node_), std::move(func), std::move(error_func));
return Conveyor<RemoveErrorOr<ReturnType<Func, T>>>::toConveyor(
return conveyor<remove_error_or<return_type<Func, T>>>::to_conveyor(
std::move(conversion_node));
}
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(storage) { return Conveyor<T>{Own<ConveyorNode>{nullptr}}; }
template <typename T> conveyor<T> conveyor<T>::buffer(size_t size) {
SAW_ASSERT(node_) { return conveyor<T>{own<conveyor_node>{nullptr}}; }
conveyor_storage *storage = node_->next_storage();
SAW_ASSERT(storage) { return conveyor<T>{own<conveyor_node>{nullptr}}; }
Own<QueueBufferConveyorNode<FixVoid<T>>> storage_node =
heap<QueueBufferConveyorNode<FixVoid<T>>>(std::move(node_), size);
own<queue_buffer_conveyor_node<fix_void<T>>> storage_node =
heap<queue_buffer_conveyor_node<fix_void<T>>>(std::move(node_), size);
ConveyorStorage *storage_ptr =
static_cast<ConveyorStorage *>(storage_node.get());
conveyor_storage *storage_ptr =
static_cast<conveyor_storage *>(storage_node.get());
storage->setParent(storage_ptr);
return Conveyor<T>{std::move(storage_node)};
storage->set_parent(storage_ptr);
return conveyor<T>{std::move(storage_node)};
}
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...));
return Conveyor<T>{std::move(attach_node)};
conveyor<T> conveyor<T>::attach(Args &&...args) {
own<attach_conveyor_node<Args...>> attach_node =
heap<attach_conveyor_node<Args...>>(std::move(node_),
std::move(args...));
return conveyor<T>{std::move(attach_node)};
}
template <typename T>
std::pair<Conveyor<T>, MergeConveyor<T>> Conveyor<T>::merge() {
Our<MergeConveyorNodeData<T>> data = share<MergeConveyorNodeData<T>>();
std::pair<conveyor<T>, merge_conveyor<T>> conveyor<T>::merge() {
our<merge_conveyor_node_data<T>> data =
share<merge_conveyor_node_data<T>>();
Own<MergeConveyorNode<T>> merge_node = heap<MergeConveyorNode<T>>(data);
own<merge_conveyor_node<T>> merge_node = heap<merge_conveyor_node<T>>(data);
SAW_ASSERT(node_) {
return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
MergeConveyor<T>{});
return std::make_pair(conveyor<T>{own<conveyor_node>{nullptr}},
merge_conveyor<T>{});
}
ConveyorStorage *storage = node_->nextStorage();
conveyor_storage *storage = node_->next_storage();
SAW_ASSERT(storage) {
return std::make_pair(Conveyor<T>{Own<ConveyorNode>{nullptr}},
MergeConveyor<T>{});
return std::make_pair(conveyor<T>{own<conveyor_node>{nullptr}},
merge_conveyor<T>{});
}
data->attach(Conveyor<T>::toConveyor(std::move(node_)));
data->attach(conveyor<T>::to_conveyor(std::move(node_)));
MergeConveyor<T> node_ref{data};
merge_conveyor<T> node_ref{data};
return std::make_pair(Conveyor<T>{std::move(merge_node)},
return std::make_pair(conveyor<T>{std::move(merge_node)},
std::move(node_ref));
}
template <>
template <typename ErrorFunc>
ConveyorSink Conveyor<void>::sink(ErrorFunc &&error_func) {
ConveyorStorage *storage = node_->nextStorage();
SAW_ASSERT(storage) { return ConveyorSink{}; }
conveyor_sink conveyor<void>::sink(ErrorFunc &&error_func) {
conveyor_storage *storage = node_->next_storage();
SAW_ASSERT(storage) { return conveyor_sink{}; }
Own<SinkConveyorNode> sink_node = heap<SinkConveyorNode>(std::move(node_));
ConveyorStorage *storage_ptr =
static_cast<ConveyorStorage *>(sink_node.get());
own<sink_conveyor_node> sink_node =
heap<sink_conveyor_node>(std::move(node_));
conveyor_storage *storage_ptr =
static_cast<conveyor_storage *>(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<void> &&conveyor);
void detach_conveyor(conveyor<void> &&conveyor);
template <typename T>
template <typename ErrorFunc>
void Conveyor<T>::detach(ErrorFunc &&func) {
detachConveyor(std::move(then([](T &&) {}, std::move(func))));
void conveyor<T>::detach(ErrorFunc &&func) {
detach_conveyor(std::move(then([](T &&) {}, std::move(func))));
}
template <>
template <typename ErrorFunc>
void Conveyor<void>::detach(ErrorFunc &&func) {
detachConveyor(std::move(then([]() {}, std::move(func))));
void conveyor<void>::detach(ErrorFunc &&func) {
detach_conveyor(std::move(then([]() {}, std::move(func))));
}
template <typename T>
Conveyor<T> Conveyor<T>::toConveyor(Own<ConveyorNode> node) {
return Conveyor<T>{std::move(node)};
conveyor<T> conveyor<T>::to_conveyor(own<conveyor_node> node) {
return conveyor<T>{std::move(node)};
}
template <typename T>
Own<ConveyorNode> Conveyor<T>::fromConveyor(Conveyor<T> conveyor) {
own<conveyor_node> conveyor<T>::from_conveyor(conveyor<T> conveyor) {
return std::move(conveyor.node_);
}
template <typename T> ErrorOr<FixVoid<T>> Conveyor<T>::take() {
template <typename T> error_or<fix_void<T>> conveyor<T>::take() {
SAW_ASSERT(node_) {
return ErrorOr<FixVoid<T>>{criticalError("Conveyor in invalid state")};
return error_or<fix_void<T>>{
critical_error("conveyor in invalid state")};
}
ConveyorStorage *storage = node_->nextStorage();
conveyor_storage *storage = node_->next_storage();
if (storage) {
if (storage->queued() > 0) {
ErrorOr<FixVoid<T>> result;
node_->getResult(result);
error_or<fix_void<T>> result;
node_->get_result(result);
return result;
} else {
return ErrorOr<FixVoid<T>>{
recoverableError("Conveyor buffer has no elements")};
return error_or<fix_void<T>>{
recoverable_error("conveyor buffer has no elements")};
}
} else {
return ErrorOr<FixVoid<T>>{
criticalError("Conveyor node has no child storage")};
return error_or<fix_void<T>>{
critical_error("conveyor node has no child storage")};
}
}
template <typename T> ConveyorAndFeeder<T> newConveyorAndFeeder() {
Own<AdaptConveyorFeeder<FixVoid<T>>> feeder =
heap<AdaptConveyorFeeder<FixVoid<T>>>();
Own<AdaptConveyorNode<FixVoid<T>>> node =
heap<AdaptConveyorNode<FixVoid<T>>>();
template <typename T> conveyor_and_feeder<T> new_conveyor_and_feeder() {
own<adapt_conveyor_feeder<fix_void<T>>> feeder =
heap<adapt_conveyor_feeder<fix_void<T>>>();
own<adapt_conveyor_node<fix_void<T>>> node =
heap<adapt_conveyor_node<fix_void<T>>>();
feeder->setFeedee(node.get());
node->setFeeder(feeder.get());
feeder->set_feedee(node.get());
node->set_feeder(feeder.get());
return ConveyorAndFeeder<T>{std::move(feeder),
Conveyor<T>::toConveyor(std::move(node))};
return conveyor_and_feeder<T>{std::move(feeder),
conveyor<T>::to_conveyor(std::move(node))};
}
// QueueBuffer
template <typename T> void QueueBufferConveyorNode<T>::fire() {
template <typename T> void queue_buffer_conveyor_node<T>::fire() {
if (child_mixin_.child) {
if (!storage_.empty()) {
if (storage_.front().isError()) {
if (storage_.front().error().isCritical()) {
if (storage_.front().is_error()) {
if (storage_.front().error().is_critical()) {
child_mixin_.child = nullptr;
}
}
@ -192,9 +197,9 @@ template <typename T> void QueueBufferConveyorNode<T>::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();
}
}
@ -205,45 +210,45 @@ template <typename T> void QueueBufferConveyorNode<T>::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 <typename T>
void QueueBufferConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
ErrorOr<T> &err_or_val = eov.as<T>();
void queue_buffer_conveyor_node<T>::get_result(error_or_value &eov) noexcept {
error_or<T> &err_or_val = eov.as<T>();
err_or_val = std::move(storage_.front());
storage_.pop();
}
template <typename T> size_t QueueBufferConveyorNode<T>::space() const {
template <typename T> size_t queue_buffer_conveyor_node<T>::space() const {
return max_store_ - storage_.size();
}
template <typename T> size_t QueueBufferConveyorNode<T>::queued() const {
template <typename T> size_t queue_buffer_conveyor_node<T>::queued() const {
return storage_.size();
}
template <typename T> void QueueBufferConveyorNode<T>::childHasFired() {
template <typename T> void queue_buffer_conveyor_node<T>::child_has_fired() {
if (child_mixin_.child && storage_.size() < max_store_) {
ErrorOr<T> eov;
child_mixin_.child->getResult(eov);
error_or<T> eov;
child_mixin_.child->get_result(eov);
if (eov.isError()) {
if (eov.error().isCritical()) {
if (eov.is_error()) {
if (eov.error().is_critical()) {
}
}
storage_.push(std::move(eov));
if (!isArmed()) {
armLater();
if (!is_armed()) {
arm_later();
}
}
}
template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
template <typename T> void queue_buffer_conveyor_node<T>::parent_has_fired() {
SAW_ASSERT(parent_) { return; }
if (parent_->space() == 0) {
@ -251,57 +256,57 @@ template <typename T> void QueueBufferConveyorNode<T>::parentHasFired() {
}
if (queued() > 0) {
armLater();
arm_later();
}
}
template <typename T>
ImmediateConveyorNode<T>::ImmediateConveyorNode(FixVoid<T> &&val)
immediate_conveyor_node<T>::immediate_conveyor_node(fix_void<T> &&val)
: value_{std::move(val)}, retrieved_{0} {}
template <typename T>
ImmediateConveyorNode<T>::ImmediateConveyorNode(Error &&error)
immediate_conveyor_node<T>::immediate_conveyor_node(error &&error)
: value_{std::move(error)}, retrieved_{0} {}
template <typename T> size_t ImmediateConveyorNode<T>::space() const {
template <typename T> size_t immediate_conveyor_node<T>::space() const {
return 0;
}
template <typename T> size_t ImmediateConveyorNode<T>::queued() const {
template <typename T> size_t immediate_conveyor_node<T>::queued() const {
return retrieved_ > 1 ? 0 : 1;
}
template <typename T> void ImmediateConveyorNode<T>::childHasFired() {
template <typename T> void immediate_conveyor_node<T>::child_has_fired() {
// Impossible case
assert(false);
}
template <typename T> void ImmediateConveyorNode<T>::parentHasFired() {
template <typename T> void immediate_conveyor_node<T>::parent_has_fired() {
SAW_ASSERT(parent_) { return; }
assert(parent_->space() > 0);
if (queued() > 0) {
armNext();
arm_next();
}
}
template <typename T> void ImmediateConveyorNode<T>::fire() {
template <typename T> void immediate_conveyor_node<T>::fire() {
if (parent_) {
parent_->childHasFired();
parent_->child_has_fired();
if (queued() > 0 && parent_->space() > 0) {
armLast();
arm_last();
}
}
}
template <typename T>
MergeConveyor<T>::MergeConveyor(Lent<MergeConveyorNodeData<T>> d)
merge_conveyor<T>::merge_conveyor(lent<merge_conveyor_node_data<T>> d)
: data_{std::move(d)} {}
template <typename T> MergeConveyor<T>::~MergeConveyor() {}
template <typename T> merge_conveyor<T>::~merge_conveyor() {}
template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
template <typename T> void merge_conveyor<T>::attach(conveyor<T> conveyor) {
auto sp = data_.lock();
SAW_ASSERT(sp) { return; }
@ -309,26 +314,26 @@ template <typename T> void MergeConveyor<T>::attach(Conveyor<T> conveyor) {
}
template <typename T>
MergeConveyorNode<T>::MergeConveyorNode(Our<MergeConveyorNodeData<T>> d)
merge_conveyor_node<T>::merge_conveyor_node(our<merge_conveyor_node_data<T>> d)
: data_{d} {
SAW_ASSERT(data_) { return; }
data_->merger = this;
}
template <typename T> MergeConveyorNode<T>::~MergeConveyorNode() {}
template <typename T> merge_conveyor_node<T>::~merge_conveyor_node() {}
template <typename T>
ErrorOr<Own<ConveyorNode>>
MergeConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee_) noexcept {
error_or<own<conveyor_node>>
merge_conveyor_node<T>::swap_child(own<conveyor_node> &&swapee_) noexcept {
(void)swapee_;
return criticalError(
"MergeConveyorNode<T>::Appendage should block calls to this class");
return critical_error(
"merge_conveyor_node<T>::appendage should block calls to this class");
}
template <typename T>
void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
void merge_conveyor_node<T>::get_result(error_or_value &eov) noexcept {
error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
SAW_ASSERT(data_) { return; }
@ -339,39 +344,39 @@ void MergeConveyorNode<T>::getResult(ErrorOrValue &eov) noexcept {
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;
err_or_val = std::move(appendages[i]->error_or_value_.value());
appendages[i]->error_or_value_ = std::nullopt;
next_appendage_ = i + 1;
return;
}
}
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;
err_or_val = std::move(appendages[i]->error_or_value_.value());
appendages[i]->error_or_value_ = std::nullopt;
next_appendage_ = i + 1;
return;
}
}
err_or_val = criticalError("No value in Merge Appendages");
err_or_val = critical_error("No value in Merge appendages");
}
template <typename T> void MergeConveyorNode<T>::fire() {
template <typename T> void merge_conveyor_node<T>::fire() {
SAW_ASSERT(queued() > 0) { return; }
if (parent_) {
parent_->childHasFired();
parent_->child_has_fired();
if (queued() > 0 && parent_->space() > 0) {
armLater();
arm_later();
}
}
}
template <typename T> size_t MergeConveyorNode<T>::space() const { return 0; }
template <typename T> size_t merge_conveyor_node<T>::space() const { return 0; }
template <typename T> size_t MergeConveyorNode<T>::queued() const {
template <typename T> size_t merge_conveyor_node<T>::queued() const {
SAW_ASSERT(data_) { return 0; }
size_t queue_count = 0;
@ -383,105 +388,110 @@ template <typename T> size_t MergeConveyorNode<T>::queued() const {
return queue_count;
}
template <typename T> void MergeConveyorNode<T>::childHasFired() {
template <typename T> void merge_conveyor_node<T>::child_has_fired() {
/// This can never happen
assert(false);
}
template <typename T> void MergeConveyorNode<T>::parentHasFired() {
template <typename T> void merge_conveyor_node<T>::parent_has_fired() {
SAW_ASSERT(parent_) { return; }
if (queued() > 0) {
if (parent_->space() > 0) {
armLater();
arm_later();
}
}
}
/**
* MergeConveyorNode<T>::Apendage
* merge_conveyor_node<T>::Apendage
*/
template <typename T>
ErrorOr<Own<ConveyorNode>>
MergeConveyorNode<T>::Appendage::swapChild(Own<ConveyorNode> &&swapee_) {
Own<ConveyorNode> old_child = std::move(child);
error_or<own<conveyor_node>>
merge_conveyor_node<T>::appendage::swap_child(own<conveyor_node> &&swapee_) {
own<conveyor_node> 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 <typename T>
void MergeConveyorNode<T>::Appendage::getResult(ErrorOrValue &eov) {
ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
void merge_conveyor_node<T>::appendage::get_result(error_or_value &eov) {
error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
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_.value());
error_or_value_ = std::nullopt;
}
template <typename T> size_t MergeConveyorNode<T>::Appendage::space() const {
template <typename T> size_t merge_conveyor_node<T>::appendage::space() const {
SAW_ASSERT(merger) { return 0; }
if (error_or_value.has_value()) {
if (error_or_value_.has_value()) {
return 0;
}
return 1;
}
template <typename T> size_t MergeConveyorNode<T>::Appendage::queued() const {
template <typename T> size_t merge_conveyor_node<T>::appendage::queued() const {
SAW_ASSERT(merger) { return 0; }
if (error_or_value.has_value()) {
if (error_or_value_.has_value()) {
return 1;
}
return 0;
}
/// @todo delete this function. Replaced by the regular getResult
/// @todo delete this function. Replaced by the regular get_result
template <typename T>
void MergeConveyorNode<T>::Appendage::getAppendageResult(ErrorOrValue &eov) {
ErrorOr<FixVoid<T>> &err_or_val = eov.as<FixVoid<T>>();
void merge_conveyor_node<T>::appendage::get_appendage_result(
error_or_value &eov) {
error_or<fix_void<T>> &err_or_val = eov.as<fix_void<T>>();
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_.value());
error_or_value_ = std::nullopt;
}
template <typename T> void MergeConveyorNode<T>::Appendage::childHasFired() {
SAW_ASSERT(!error_or_value.has_value()) { return; }
ErrorOr<FixVoid<T>> eov;
child->getResult(eov);
template <typename T>
void merge_conveyor_node<T>::appendage::child_has_fired() {
SAW_ASSERT(!error_or_value_.has_value()) { return; }
error_or<fix_void<T>> eov;
child->get_result(eov);
error_or_value = std::move(eov);
error_or_value_ = std::move(eov);
if (!merger->isArmed()) {
merger->armLater();
}
}
template <typename T> void MergeConveyorNode<T>::Appendage::parentHasFired() {
ConveyorStorage *child_storage = child->nextStorage();
if (child_storage) {
child_storage->parentHasFired();
if (!merger->is_armed()) {
merger->arm_later();
}
}
template <typename T>
void MergeConveyorNode<T>::Appendage::setParent(ConveyorStorage *par) {
void merge_conveyor_node<T>::appendage::parent_has_fired() {
conveyor_storage *child_storage = child->next_storage();
if (child_storage) {
child_storage->parent_has_fired();
}
}
template <typename T>
void merge_conveyor_node<T>::appendage::set_parent(conveyor_storage *par) {
SAW_ASSERT(merger) { return; }
SAW_ASSERT(child) { return; }
@ -490,24 +500,25 @@ void MergeConveyorNode<T>::Appendage::setParent(ConveyorStorage *par) {
}
template <typename T>
void MergeConveyorNodeData<T>::attach(Conveyor<T> conveyor) {
auto nas = Conveyor<T>::fromConveyor(std::move(conveyor));
void merge_conveyor_node_data<T>::attach(conveyor<T> conv) {
auto nas = conveyor<T>::from_conveyor(std::move(conv));
SAW_ASSERT(nas) { return; }
ConveyorStorage *storage = nas->nextStorage();
conveyor_storage *storage = nas->next_storage();
SAW_ASSERT(storage) { return; }
auto merge_node_appendage =
heap<typename MergeConveyorNode<T>::Appendage>(std::move(nas), *merger);
heap<typename merge_conveyor_node<T>::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->next_storage();
SAW_ASSERT(mrg_storage) { return; }
merge_node_appendage->setParent(mrg_storage);
merge_node_appendage->set_parent(mrg_storage);
appendages.push_back(std::move(merge_node_appendage));
@ -516,43 +527,44 @@ void MergeConveyorNodeData<T>::attach(Conveyor<T> conveyor) {
// return merge_node_appendage_ptr;
}
template <typename T> void MergeConveyorNodeData<T>::governingNodeDestroyed() {
template <typename T>
void merge_conveyor_node_data<T>::governing_node_destroyed() {
appendages.clear();
merger = nullptr;
}
template <typename T> AdaptConveyorFeeder<T>::~AdaptConveyorFeeder() {
template <typename T> adapt_conveyor_feeder<T>::~adapt_conveyor_feeder() {
if (feedee_) {
feedee_->setFeeder(nullptr);
feedee_->set_feeder(nullptr);
feedee_ = nullptr;
}
}
template <typename T>
void AdaptConveyorFeeder<T>::setFeedee(AdaptConveyorNode<T> *feedee_p) {
void adapt_conveyor_feeder<T>::set_feedee(adapt_conveyor_node<T> *feedee_p) {
feedee_ = feedee_p;
}
template <typename T> void AdaptConveyorFeeder<T>::feed(T &&value) {
template <typename T> void adapt_conveyor_feeder<T>::feed(T &&value) {
if (feedee_) {
feedee_->feed(std::move(value));
}
}
template <typename T> void AdaptConveyorFeeder<T>::fail(Error &&error) {
template <typename T> void adapt_conveyor_feeder<T>::fail(error &&error) {
if (feedee_) {
feedee_->fail(std::move(error));
}
}
template <typename T> size_t AdaptConveyorFeeder<T>::queued() const {
template <typename T> size_t adapt_conveyor_feeder<T>::queued() const {
if (feedee_) {
return feedee_->queued();
}
return 0;
}
template <typename T> size_t AdaptConveyorFeeder<T>::space() const {
template <typename T> size_t adapt_conveyor_feeder<T>::space() const {
if (feedee_) {
return feedee_->space();
}
@ -560,33 +572,33 @@ template <typename T> size_t AdaptConveyorFeeder<T>::space() const {
}
template <typename T>
Error AdaptConveyorFeeder<T>::swap(Conveyor<T> &&conveyor) noexcept {
SAW_ASSERT(feedee_) { return criticalError("No feedee connected"); }
error adapt_conveyor_feeder<T>::swap(conveyor<T> &&conv) noexcept {
SAW_ASSERT(feedee_) { return critical_error("No feedee connected"); }
auto node = Conveyor<T>::fromConveyor(std::move(conveyor));
auto node = conveyor<T>::from_conveyor(std::move(conv));
feedee_->swapChild(std::move(node));
feedee_->swap_child(std::move(node));
return noError();
return no_error();
}
template <typename T>
AdaptConveyorNode<T>::AdaptConveyorNode() : ConveyorEventStorage{} {}
adapt_conveyor_node<T>::adapt_conveyor_node() : conveyor_event_storage{} {}
template <typename T> AdaptConveyorNode<T>::~AdaptConveyorNode() {
template <typename T> adapt_conveyor_node<T>::~adapt_conveyor_node() {
if (feeder_) {
feeder_->setFeedee(nullptr);
feeder_->set_feedee(nullptr);
feeder_ = nullptr;
}
}
template <typename T>
ErrorOr<Own<ConveyorNode>>
AdaptConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee) noexcept {
error_or<own<conveyor_node>>
adapt_conveyor_node<T>::swap_child(own<conveyor_node> &&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;
}
@ -598,56 +610,57 @@ AdaptConveyorNode<T>::swapChild(Own<ConveyorNode> &&swapee) noexcept {
}
template <typename T>
ConveyorStorage *AdaptConveyorNode<T>::nextStorage() noexcept {
return static_cast<ConveyorStorage *>(this);
conveyor_storage *adapt_conveyor_node<T>::next_storage() noexcept {
return static_cast<conveyor_storage *>(this);
}
template <typename T>
void AdaptConveyorNode<T>::notifyParentAttached(ConveyorNode &par) noexcept {
parent_node_.changeParent(&par);
void adapt_conveyor_node<T>::notify_parent_attached(
conveyor_node &par) noexcept {
parent_node_.change_parent(&par);
}
template <typename T>
void AdaptConveyorNode<T>::setFeeder(AdaptConveyorFeeder<T> *feeder_p) {
void adapt_conveyor_node<T>::set_feeder(adapt_conveyor_feeder<T> *feeder_p) {
feeder_ = feeder_p;
}
template <typename T> void AdaptConveyorNode<T>::feed(T &&value) {
template <typename T> void adapt_conveyor_node<T>::feed(T &&value) {
storage_.push(std::move(value));
armNext();
arm_next();
}
template <typename T> void AdaptConveyorNode<T>::fail(Error &&error) {
template <typename T> void adapt_conveyor_node<T>::fail(error &&error) {
storage_.push(std::move(error));
armNext();
arm_next();
}
template <typename T> size_t AdaptConveyorNode<T>::queued() const {
template <typename T> size_t adapt_conveyor_node<T>::queued() const {
return storage_.size();
}
template <typename T> size_t AdaptConveyorNode<T>::space() const {
template <typename T> size_t adapt_conveyor_node<T>::space() const {
return std::numeric_limits<size_t>::max() - storage_.size();
}
template <typename T>
void AdaptConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
void adapt_conveyor_node<T>::get_result(error_or_value &err_or_val) {
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 "
"data is present");
err_or_val.as<T>() = critical_error(
"Signal for retrieval of storage sent even though no "
"data is present");
}
}
template <typename T> void AdaptConveyorNode<T>::childHasFired() {
template <typename T> void adapt_conveyor_node<T>::child_has_fired() {
// Adapt node has no children
assert(false);
}
template <typename T> void AdaptConveyorNode<T>::parentHasFired() {
template <typename T> void adapt_conveyor_node<T>::parent_has_fired() {
SAW_ASSERT(parent_) { return; }
if (parent_->space() == 0) {
@ -655,99 +668,101 @@ template <typename T> void AdaptConveyorNode<T>::parentHasFired() {
}
}
template <typename T> void AdaptConveyorNode<T>::fire() {
template <typename T> void adapt_conveyor_node<T>::fire() {
if (parent_) {
parent_->childHasFired();
parent_->child_has_fired();
if (storage_.size() > 0) {
armLater();
arm_later();
}
}
}
template <typename T> OneTimeConveyorFeeder<T>::~OneTimeConveyorFeeder() {
template <typename T> one_time_conveyor_feeder<T>::~one_time_conveyor_feeder() {
if (feedee_) {
feedee_->setFeeder(nullptr);
feedee_->set_feeder(nullptr);
feedee_ = nullptr;
}
}
template <typename T>
void OneTimeConveyorFeeder<T>::setFeedee(OneTimeConveyorNode<T> *feedee_p) {
void one_time_conveyor_feeder<T>::set_feedee(
one_time_conveyor_node<T> *feedee_p) {
feedee_ = feedee_p;
}
template <typename T> void OneTimeConveyorFeeder<T>::feed(T &&value) {
template <typename T> void one_time_conveyor_feeder<T>::feed(T &&value) {
if (feedee_) {
feedee_->feed(std::move(value));
}
}
template <typename T> void OneTimeConveyorFeeder<T>::fail(Error &&error) {
template <typename T> void one_time_conveyor_feeder<T>::fail(error &&error) {
if (feedee_) {
feedee_->fail(std::move(error));
}
}
template <typename T> size_t OneTimeConveyorFeeder<T>::queued() const {
template <typename T> size_t one_time_conveyor_feeder<T>::queued() const {
if (feedee_) {
return feedee_->queued();
}
return 0;
}
template <typename T> size_t OneTimeConveyorFeeder<T>::space() const {
template <typename T> size_t one_time_conveyor_feeder<T>::space() const {
if (feedee_) {
return feedee_->space();
}
return 0;
}
template <typename T> OneTimeConveyorNode<T>::~OneTimeConveyorNode() {
template <typename T> one_time_conveyor_node<T>::~one_time_conveyor_node() {
if (feeder_) {
feeder_->setFeedee(nullptr);
feeder_->set_feedee(nullptr);
feeder_ = nullptr;
}
}
template <typename T>
void OneTimeConveyorNode<T>::setFeeder(OneTimeConveyorFeeder<T> *feeder_p) {
void one_time_conveyor_node<T>::set_feeder(
one_time_conveyor_feeder<T> *feeder_p) {
feeder_ = feeder_p;
}
template <typename T> void OneTimeConveyorNode<T>::feed(T &&value) {
template <typename T> void one_time_conveyor_node<T>::feed(T &&value) {
storage_ = std::move(value);
armNext();
arm_next();
}
template <typename T> void OneTimeConveyorNode<T>::fail(Error &&error) {
template <typename T> void one_time_conveyor_node<T>::fail(error &&error) {
storage_ = std::move(error);
armNext();
arm_next();
}
template <typename T> size_t OneTimeConveyorNode<T>::queued() const {
template <typename T> size_t one_time_conveyor_node<T>::queued() const {
return storage_.has_value() ? 1 : 0;
}
template <typename T> size_t OneTimeConveyorNode<T>::space() const {
template <typename T> size_t one_time_conveyor_node<T>::space() const {
return passed_ ? 0 : 1;
}
template <typename T>
void OneTimeConveyorNode<T>::getResult(ErrorOrValue &err_or_val) {
void one_time_conveyor_node<T>::get_result(error_or_value &err_or_val) {
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 "
"data is present");
err_or_val.as<T>() = critical_error(
"Signal for retrieval of storage sent even though no "
"data is present");
}
}
template <typename T> void OneTimeConveyorNode<T>::fire() {
template <typename T> void one_time_conveyor_node<T>::fire() {
if (parent_) {
parent_->childHasFired();
parent_->child_has_fired();
}
}

257
source/forstio/buffer.cpp
View File

@ -7,223 +7,223 @@
#include <sstream>
namespace saw {
Error Buffer::push(const uint8_t &value) {
size_t write_remain = writeCompositeLength();
error buffer::push(const uint8_t &value) {
size_t write_remain = write_composite_length();
if (write_remain > 0) {
write() = value;
writeAdvance(1);
write_advance(1);
} else {
return recoverableError("Buffer too small");
return recoverable_error("Buffer too small");
}
return noError();
return no_error();
}
Error Buffer::push(const uint8_t &buffer, size_t size) {
Error error = writeRequireLength(size);
error buffer::push(const uint8_t &buffer, size_t size) {
error error = write_require_length(size);
if (error.failed()) {
return error;
}
const uint8_t *buffer_ptr = &buffer;
while (size > 0) {
size_t segment = std::min(writeSegmentLength(), size);
size_t segment = std::min(write_segment_length(), size);
memcpy(&write(), buffer_ptr, segment);
writeAdvance(segment);
write_advance(segment);
size -= segment;
buffer_ptr += segment;
}
return noError();
return no_error();
}
Error Buffer::pop(uint8_t &value) {
if (readCompositeLength() > 0) {
error buffer::pop(uint8_t &value) {
if (read_composite_length() > 0) {
value = read();
readAdvance(1);
read_advance(1);
} else {
return recoverableError("Buffer too small");
return recoverable_error("Buffer too small");
}
return noError();
return no_error();
}
Error Buffer::pop(uint8_t &buffer, size_t size) {
if (readCompositeLength() >= size) {
error buffer::pop(uint8_t &buffer, size_t size) {
if (read_composite_length() >= size) {
uint8_t *buffer_ptr = &buffer;
while (size > 0) {
size_t segment = std::min(readSegmentLength(), size);
size_t segment = std::min(read_segment_length(), size);
memcpy(buffer_ptr, &read(), segment);
readAdvance(segment);
read_advance(segment);
size -= segment;
buffer_ptr += segment;
}
} else {
return recoverableError("Buffer too small");
return recoverable_error("Buffer too small");
}
return noError();
return no_error();
}
std::string Buffer::toString() const {
std::string buffer::to_string() const {
std::ostringstream oss;
for (size_t i = 0; i < readCompositeLength(); ++i) {
for (size_t i = 0; i < read_composite_length(); ++i) {
oss << read(i);
}
return oss.str();
}
std::string Buffer::toHex() const {
std::string buffer::to_hex() const {
std::ostringstream oss;
oss << std::hex << std::setfill('0');
for (size_t i = 0; i < readCompositeLength(); ++i) {
for (size_t i = 0; i < read_composite_length(); ++i) {
oss << std::setw(2) << (uint16_t)read(i);
if ((i + 1) < readCompositeLength()) {
if ((i + 1) < read_composite_length()) {
oss << ((i % 4 == 3) ? '\n' : ' ');
}
}
return oss.str();
}
BufferView::BufferView(Buffer &buffer)
buffer_view::buffer_view(buffer &buffer)
: buffer_{buffer}, read_offset_{0}, write_offset_{0} {}
size_t BufferView::readPosition() const {
return read_offset_ + buffer_.readPosition();
size_t buffer_view::read_position() const {
return read_offset_ + buffer_.read_position();
}
size_t BufferView::readCompositeLength() const {
assert(read_offset_ <= buffer_.readCompositeLength());
if (read_offset_ > buffer_.readCompositeLength()) {
size_t buffer_view::read_composite_length() const {
assert(read_offset_ <= buffer_.read_composite_length());
if (read_offset_ > buffer_.read_composite_length()) {
return 0;
}
return buffer_.readCompositeLength() - read_offset_;
return buffer_.read_composite_length() - read_offset_;
}
size_t BufferView::readSegmentLength(size_t offset) const {
size_t buffer_view::read_segment_length(size_t offset) const {
size_t off = offset + read_offset_;
assert(off <= buffer_.readCompositeLength());
if (off > buffer_.readCompositeLength()) {
assert(off <= buffer_.read_composite_length());
if (off > buffer_.read_composite_length()) {
return 0;
}
return buffer_.readSegmentLength(off);
return buffer_.read_segment_length(off);
}
void BufferView::readAdvance(size_t bytes) {
void buffer_view::read_advance(size_t bytes) {
size_t offset = bytes + read_offset_;
assert(offset <= buffer_.readCompositeLength());
if (offset > buffer_.readCompositeLength()) {
read_offset_ += buffer_.readCompositeLength();
assert(offset <= buffer_.read_composite_length());
if (offset > buffer_.read_composite_length()) {
read_offset_ += buffer_.read_composite_length();
return;
}
read_offset_ += bytes;
}
uint8_t &BufferView::read(size_t i) {
uint8_t &buffer_view::read(size_t i) {
size_t pos = i + read_offset_;
assert(pos < buffer_.readCompositeLength());
assert(pos < buffer_.read_composite_length());
return buffer_.read(pos);
}
const uint8_t &BufferView::read(size_t i) const {
const uint8_t &buffer_view::read(size_t i) const {
size_t pos = i + read_offset_;
assert(pos < buffer_.readCompositeLength());
assert(pos < buffer_.read_composite_length());
return buffer_.read(pos);
}
size_t BufferView::writePosition() const {
return write_offset_ + buffer_.writePosition();
size_t buffer_view::write_position() const {
return write_offset_ + buffer_.write_position();
}
size_t BufferView::writeCompositeLength() const {
assert(write_offset_ <= buffer_.writeCompositeLength());
if (write_offset_ > buffer_.writeCompositeLength()) {
size_t buffer_view::write_composite_length() const {
assert(write_offset_ <= buffer_.write_composite_length());
if (write_offset_ > buffer_.write_composite_length()) {
return 0;
}
return buffer_.writeCompositeLength() - write_offset_;
return buffer_.write_composite_length() - write_offset_;
}
size_t BufferView::writeSegmentLength(size_t offset) const {
size_t buffer_view::write_segment_length(size_t offset) const {
size_t off = offset + write_offset_;
assert(off <= buffer_.writeCompositeLength());
if (off > buffer_.writeCompositeLength()) {
assert(off <= buffer_.write_composite_length());
if (off > buffer_.write_composite_length()) {
return 0;
}
return buffer_.writeSegmentLength(off);
return buffer_.write_segment_length(off);
}
void BufferView::writeAdvance(size_t bytes) {
void buffer_view::write_advance(size_t bytes) {
size_t offset = bytes + write_offset_;
assert(offset <= buffer_.writeCompositeLength());
if (offset > buffer_.writeCompositeLength()) {
write_offset_ += buffer_.writeCompositeLength();
assert(offset <= buffer_.write_composite_length());
if (offset > buffer_.write_composite_length()) {
write_offset_ += buffer_.write_composite_length();
return;
}
write_offset_ += bytes;
}
uint8_t &BufferView::write(size_t i) {
uint8_t &buffer_view::write(size_t i) {
size_t pos = i + write_offset_;
assert(pos < buffer_.writeCompositeLength());
assert(pos < buffer_.write_composite_length());
return buffer_.write(pos);
}
const uint8_t &BufferView::write(size_t i) const {
const uint8_t &buffer_view::write(size_t i) const {
size_t pos = i + write_offset_;
assert(pos < buffer_.writeCompositeLength());
assert(pos < buffer_.write_composite_length());
return buffer_.write(pos);
}
Error BufferView::writeRequireLength(size_t bytes) {
return buffer_.writeRequireLength(bytes + write_offset_);
error buffer_view::write_require_length(size_t bytes) {
return buffer_.write_require_length(bytes + write_offset_);
}
size_t BufferView::readOffset() const { return read_offset_; }
size_t buffer_view::read_offset() const { return read_offset_; }
size_t BufferView::writeOffset() const { return write_offset_; }
size_t buffer_view::write_offset() const { return write_offset_; }
RingBuffer::RingBuffer() : read_position_{0}, write_position_{0} {
ring_buffer::ring_buffer() : read_position_{0}, write_position_{0} {
buffer_.resize(RING_BUFFER_MAX_SIZE);
}
RingBuffer::RingBuffer(size_t size) : read_position_{0}, write_position_{0} {
ring_buffer::ring_buffer(size_t size) : read_position_{0}, write_position_{0} {
buffer_.resize(size);
}
size_t RingBuffer::readPosition() const { return read_position_; }
size_t ring_buffer::read_position() const { return read_position_; }
/*
* If write is ahead of read it is a simple distance, but if read ist ahead of
* write then there are two segments
*
*/
size_t RingBuffer::readCompositeLength() const {
return writePosition() < readPosition()
? buffer_.size() - (readPosition() - writePosition())
size_t ring_buffer::read_composite_length() const {
return write_position() < read_position()
? buffer_.size() - (read_position() - write_position())
: (write_reached_read_ ? buffer_.size()
: writePosition() - readPosition());
: write_position() - read_position());
}
/*
* If write is ahead then it's the simple distance again. If read is ahead it's
* until the end of the buffer/segment
*/
size_t RingBuffer::readSegmentLength(size_t offset) const {
size_t read_composite = readCompositeLength();
size_t ring_buffer::read_segment_length(size_t offset) const {
size_t read_composite = read_composite_length();
assert(offset <= read_composite);
offset = std::min(offset, read_composite);
size_t remaining = read_composite - offset;
size_t read_offset = readPosition() + offset;
size_t read_offset = read_position() + offset;
read_offset = read_offset >= buffer_.size() ? read_offset - buffer_.size()
: read_offset;
@ -233,11 +233,11 @@ size_t RingBuffer::readSegmentLength(size_t offset) const {
// then it is set to zero by readCompositeLength()
// case 3 write is located after read
// since std::min you can use simple subtraction
if (writePosition() < read_offset) {
if (write_position() < read_offset) {
return buffer_.size() - read_offset;
}
if (writePosition() == read_offset) {
if (write_position() == read_offset) {
if (remaining > 0) {
return buffer_.size() - read_offset;
} else {
@ -245,11 +245,11 @@ size_t RingBuffer::readSegmentLength(size_t offset) const {
}
}
return writePosition() - read_offset;
return write_position() - read_offset;
}
void RingBuffer::readAdvance(size_t bytes) {
size_t read_composite = readCompositeLength();
void ring_buffer::read_advance(size_t bytes) {
size_t read_composite = read_composite_length();
assert(bytes <= read_composite);
bytes = std::min(bytes, read_composite);
@ -259,36 +259,36 @@ void RingBuffer::readAdvance(size_t bytes) {
write_reached_read_ = bytes > 0 ? false : write_reached_read_;
}
uint8_t &RingBuffer::read(size_t i) {
assert(i < readCompositeLength());
uint8_t &ring_buffer::read(size_t i) {
assert(i < read_composite_length());
size_t pos = read_position_ + i;
pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
return buffer_[pos];
}
const uint8_t &RingBuffer::read(size_t i) const {
assert(i < readCompositeLength());
const uint8_t &ring_buffer::read(size_t i) const {
assert(i < read_composite_length());
size_t pos = read_position_ + i;
pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
return buffer_[pos];
}
size_t RingBuffer::writePosition() const { return write_position_; }
size_t ring_buffer::write_position() const { return write_position_; }
size_t RingBuffer::writeCompositeLength() const {
return readPosition() > writePosition()
? (readPosition() - writePosition())
size_t ring_buffer::write_composite_length() const {
return read_position() > write_position()
? (read_position() - write_position())
: (write_reached_read_
? 0
: buffer_.size() - (writePosition() - readPosition()));
: buffer_.size() - (write_position() - read_position()));
}
size_t RingBuffer::writeSegmentLength(size_t offset) const {
size_t write_composite = writeCompositeLength();
size_t ring_buffer::write_segment_length(size_t offset) const {
size_t write_composite = write_composite_length();
assert(offset <= write_composite);
offset = std::min(offset, write_composite);
size_t write_offset = writePosition() + offset;
size_t write_offset = write_position() + offset;
write_offset = write_offset >= buffer_.size()
? write_offset - buffer_.size()
: write_offset;
@ -304,8 +304,8 @@ size_t RingBuffer::writeSegmentLength(size_t offset) const {
return buffer_.size() - write_offset;
}
void RingBuffer::writeAdvance(size_t bytes) {
assert(bytes <= writeCompositeLength());
void ring_buffer::write_advance(size_t bytes) {
assert(bytes <= write_composite_length());
size_t advanced = write_position_ + bytes;
write_position_ = advanced >= buffer_.size() ? advanced - buffer_.size()
: advanced;
@ -314,15 +314,15 @@ void RingBuffer::writeAdvance(size_t bytes) {
(write_position_ == read_position_ && bytes > 0 ? true : false);
}
uint8_t &RingBuffer::write(size_t i) {
assert(i < writeCompositeLength());
uint8_t &ring_buffer::write(size_t i) {
assert(i < write_composite_length());
size_t pos = write_position_ + i;
pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
return buffer_[pos];
}
const uint8_t &RingBuffer::write(size_t i) const {
assert(i < writeCompositeLength());
const uint8_t &ring_buffer::write(size_t i) const {
assert(i < write_composite_length());
size_t pos = write_position_ + i;
pos = pos >= buffer_.size() ? pos - buffer_.size() : pos;
return buffer_[pos];
@ -345,26 +345,27 @@ const uint8_t &RingBuffer::write(size_t i) const {
return noError();
}
*/
Error RingBuffer::writeRequireLength(size_t bytes) {
size_t write_remain = writeCompositeLength();
error ring_buffer::write_require_length(size_t bytes) {
size_t write_remain = write_composite_length();
if (bytes > write_remain) {
return recoverableError("Buffer too small");
return recoverable_error("Buffer too small");
}
return noError();
return no_error();
}
ArrayBuffer::ArrayBuffer(size_t size) : read_position_{0}, write_position_{0} {
array_buffer::array_buffer(size_t size)
: read_position_{0}, write_position_{0} {
buffer_.resize(size);
}
size_t ArrayBuffer::readPosition() const { return read_position_; }
size_t array_buffer::read_position() const { return read_position_; }
size_t ArrayBuffer::readCompositeLength() const {
size_t array_buffer::read_composite_length() const {
return write_position_ - read_position_;
}
size_t ArrayBuffer::readSegmentLength(size_t offset) const {
size_t read_composite = readCompositeLength();
size_t array_buffer::read_segment_length(size_t offset) const {
size_t read_composite = read_composite_length();
assert(offset <= read_composite);
offset = std::min(read_composite, offset);
@ -373,33 +374,33 @@ size_t ArrayBuffer::readSegmentLength(size_t offset) const {
return write_position_ - read_offset;
}
void ArrayBuffer::readAdvance(size_t bytes) {
assert(bytes <= readCompositeLength());
void array_buffer::read_advance(size_t bytes) {
assert(bytes <= read_composite_length());
read_position_ += bytes;
}
uint8_t &ArrayBuffer::read(size_t i) {
assert(i < readCompositeLength());
uint8_t &array_buffer::read(size_t i) {
assert(i < read_composite_length());
return buffer_[i + read_position_];
}
const uint8_t &ArrayBuffer::read(size_t i) const {
const uint8_t &array_buffer::read(size_t i) const {
assert(i + read_position_ < buffer_.size());
return buffer_[i + read_position_];
}
size_t ArrayBuffer::writePosition() const { return write_position_; }
size_t array_buffer::write_position() const { return write_position_; }
size_t ArrayBuffer::writeCompositeLength() const {
size_t array_buffer::write_composite_length() const {
assert(write_position_ <= buffer_.size());
return buffer_.size() - write_position_;
}
size_t ArrayBuffer::writeSegmentLength(size_t offset) const {
size_t array_buffer::write_segment_length(size_t offset) const {
assert(write_position_ <= buffer_.size());
size_t write_composite = writeCompositeLength();
size_t write_composite = write_composite_length();
assert(offset <= write_composite);
offset = std::min(write_composite, offset);
@ -408,26 +409,26 @@ size_t ArrayBuffer::writeSegmentLength(size_t offset) const {
return buffer_.size() - write_offset;
}
void ArrayBuffer::writeAdvance(size_t bytes) {
assert(bytes <= writeCompositeLength());
void array_buffer::write_advance(size_t bytes) {
assert(bytes <= write_composite_length());
write_position_ += bytes;
}
uint8_t &ArrayBuffer::write(size_t i) {
assert(i < writeCompositeLength());
uint8_t &array_buffer::write(size_t i) {
assert(i < write_composite_length());
return buffer_[i + write_position_];
}
const uint8_t &ArrayBuffer::write(size_t i) const {
assert(i < writeCompositeLength());
const uint8_t &array_buffer::write(size_t i) const {
assert(i < write_composite_length());
return buffer_[i + write_position_];
}
Error ArrayBuffer::writeRequireLength(size_t bytes) {
size_t write_remain = writeCompositeLength();
error array_buffer::write_require_length(size_t bytes) {
size_t write_remain = write_composite_length();
if (bytes > write_remain) {
return recoverableError("Buffer too small");
return recoverable_error("Buffer too small");
}
return noError();
return no_error();
}
} // namespace saw

135
source/forstio/buffer.h
View File

@ -13,23 +13,23 @@ namespace saw {
/*
* Access class to reduce templated BufferSegments bloat
*/
class Buffer {
class buffer {
protected:
~Buffer() = default;
~buffer() = default;
public:
virtual size_t readPosition() const = 0;
virtual size_t readCompositeLength() const = 0;
virtual size_t readSegmentLength(size_t offset = 0) const = 0;
virtual void readAdvance(size_t bytes) = 0;
virtual size_t read_position() const = 0;
virtual size_t read_composite_length() const = 0;
virtual size_t read_segment_length(size_t offset = 0) const = 0;
virtual void read_advance(size_t bytes) = 0;
virtual uint8_t &read(size_t i = 0) = 0;
virtual const uint8_t &read(size_t i = 0) const = 0;
virtual size_t writePosition() const = 0;
virtual size_t writeCompositeLength() const = 0;
virtual size_t writeSegmentLength(size_t offset = 0) const = 0;
virtual void writeAdvance(size_t bytes) = 0;
virtual size_t write_position() const = 0;
virtual size_t write_composite_length() const = 0;
virtual size_t write_segment_length(size_t offset = 0) const = 0;
virtual void write_advance(size_t bytes) = 0;
virtual uint8_t &write(size_t i = 0) = 0;
virtual const uint8_t &write(size_t i = 0) const = 0;
@ -40,50 +40,53 @@ public:
* There is nothing you can do if read hasn't been filled, but at
* least write can be increased if it is demanded.
*/
virtual Error writeRequireLength(size_t bytes) = 0;
virtual error write_require_length(size_t bytes) = 0;
Error push(const uint8_t &value);
Error push(const uint8_t &buffer, size_t size);
Error pop(uint8_t &value);
Error pop(uint8_t &buffer, size_t size);
error push(const uint8_t &value);
error push(const uint8_t &buffer, size_t size);
error pop(uint8_t &value);
error pop(uint8_t &buffer, size_t size);
std::string toString() const;
std::string toHex() const;
/*
* Subject to change
*/
std::string to_string() const;
std::string to_hex() const;
};
/*
* A viewer class for buffers.
* Working on the reference buffer invalidates the buffer view
*/
class BufferView : public Buffer {
class buffer_view : public buffer {
private:
Buffer &buffer_;
buffer &buffer_;
size_t read_offset_;
size_t write_offset_;
public:
BufferView(Buffer &);
buffer_view(buffer &);
size_t readPosition() const override;
size_t readCompositeLength() const override;
size_t readSegmentLength(size_t offset = 0) const override;
void readAdvance(size_t bytes) override;
size_t read_position() const override;
size_t read_composite_length() const override;
size_t read_segment_length(size_t offset = 0) const override;
void read_advance(size_t bytes) override;
uint8_t &read(size_t i = 0) override;
const uint8_t &read(size_t i = 0) const override;
size_t writePosition() const override;
size_t writeCompositeLength() const override;
size_t writeSegmentLength(size_t offset = 0) const override;
void writeAdvance(size_t bytes) override;
size_t write_position() const override;
size_t write_composite_length() const override;
size_t write_segment_length(size_t offset = 0) const override;
void write_advance(size_t bytes) override;
uint8_t &write(size_t i = 0) override;
const uint8_t &write(size_t i = 0) const override;
Error writeRequireLength(size_t bytes) override;
error write_require_length(size_t bytes) override;
size_t readOffset() const;
size_t writeOffset() const;
size_t read_offset() const;
size_t write_offset() const;
};
/*
@ -94,7 +97,7 @@ constexpr size_t RING_BUFFER_MAX_SIZE = 4096;
/*
* Buffer wrapping around if read caught up
*/
class RingBuffer final : public Buffer {
class ring_buffer final : public buffer {
private:
std::vector<uint8_t> buffer_;
size_t read_position_;
@ -102,37 +105,37 @@ private:
bool write_reached_read_ = false;
public:
RingBuffer();
RingBuffer(size_t size);
ring_buffer();
ring_buffer(size_t 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]; }
size_t readPosition() const override;
size_t readCompositeLength() const override;
size_t readSegmentLength(size_t offset = 0) const override;
void readAdvance(size_t bytes) override;
size_t read_position() const override;
size_t read_composite_length() const override;
size_t read_segment_length(size_t offset = 0) const override;
void read_advance(size_t bytes) override;
uint8_t &read(size_t i = 0) override;
const uint8_t &read(size_t i = 0) const override;
size_t writePosition() const override;
size_t writeCompositeLength() const override;
size_t writeSegmentLength(size_t offset = 0) const override;
void writeAdvance(size_t bytes) override;
size_t write_position() const override;
size_t write_composite_length() const override;
size_t write_segment_length(size_t offset = 0) const override;
void write_advance(size_t bytes) override;
uint8_t &write(size_t i = 0) override;
const uint8_t &write(size_t i = 0) const override;
Error writeRequireLength(size_t bytes) override;
error write_require_length(size_t bytes) override;
};
/*
* One time buffer
*/
class ArrayBuffer : public Buffer {
class array_buffer : public buffer {
private:
std::vector<uint8_t> buffer_;
@ -140,53 +143,53 @@ private:
size_t write_position_;
public:
ArrayBuffer(size_t size);
array_buffer(size_t size);
size_t readPosition() const override;
size_t readCompositeLength() const override;
size_t readSegmentLength(size_t offset = 0) const override;
void readAdvance(size_t bytes) override;
size_t read_position() const override;
size_t read_composite_length() const override;
size_t read_segment_length(size_t offset = 0) const override;
void read_advance(size_t bytes) override;
uint8_t &read(size_t i = 0) override;
const uint8_t &read(size_t i = 0) const override;
size_t writePosition() const override;
size_t writeCompositeLength() const override;
size_t writeSegmentLength(size_t offset = 0) const override;
void writeAdvance(size_t bytes) override;
size_t write_position() const override;
size_t write_composite_length() const override;
size_t write_segment_length(size_t offset = 0) const override;
void write_advance(size_t bytes) override;
uint8_t &write(size_t i = 0) override;
const uint8_t &write(size_t i = 0) const override;
Error writeRequireLength(size_t bytes) override;
error write_require_length(size_t bytes) override;
};
class ChainArrayBuffer : public Buffer {
class chain_array_buffer : public buffer {
private:
std::deque<ArrayBuffer> buffer_;
std::deque<array_buffer> buffer_;
size_t read_position_;
size_t write_position_;
public:
ChainArrayBuffer();
chain_array_buffer();
size_t readPosition() const override;
size_t readCompositeLength() const override;
size_t readSegmentLength(size_t offset = 0) const override;
void readAdvance(size_t bytes) override;
size_t read_position() const override;
size_t read_composite_length() const override;
size_t read_segment_length(size_t offset = 0) const override;
void read_advance(size_t bytes) override;
uint8_t &read(size_t i = 0) override;
const uint8_t &read(size_t i = 0) const override;
size_t writePosition() const override;
size_t writeCompositeLength() const override;
size_t writeSegmentLength(size_t offset = 0) const override;
void writeAdvance(size_t bytes) override;
size_t write_position() const override;
size_t write_composite_length() const override;
size_t write_segment_length(size_t offset = 0) const override;
void write_advance(size_t bytes) override;
uint8_t &write(size_t i = 0) override;
const uint8_t &write(size_t i = 0) const override;
Error writeRequireLength(size_t bytes) override;
error write_require_length(size_t bytes) override;
};
} // namespace saw

32
source/forstio/common.h
View File

@ -32,43 +32,43 @@ namespace saw {
assert(expression); \
if (!(expression)) [[unlikely]]
template <typename T> using Maybe = std::optional<T>;
template <typename T> using maybe = std::optional<T>;
template <typename T> using Own = std::unique_ptr<T>;
template <typename T> using own = std::unique_ptr<T>;
template <typename T> using Our = std::shared_ptr<T>;
template <typename T> using our = std::shared_ptr<T>;
template <typename T> using Lent = std::weak_ptr<T>;
template <typename T> using lent = std::weak_ptr<T>;
template <typename T, class... Args> Own<T> heap(Args &&...args) {
return Own<T>(new T(std::forward<Args>(args)...));
template <typename T, class... Args> own<T> heap(Args &&...args) {
return own<T>(new T(std::forward<Args>(args)...));
}
template <typename T, class... Args> Our<T> share(Args &&...args) {
template <typename T, class... Args> our<T> share(Args &&...args) {
return std::make_shared<T>(std::forward<Args>(args)...);
}
template <typename T> T instance() noexcept;
template <typename Func, typename T> struct ReturnTypeHelper {
template <typename Func, typename T> struct return_type_helper {
typedef decltype(instance<Func>()(instance<T>())) Type;
};
template <typename Func> struct ReturnTypeHelper<Func, void> {
template <typename Func> struct return_type_helper<Func, void> {
typedef decltype(instance<Func>()()) Type;
};
template <typename Func, typename T>
using ReturnType = typename ReturnTypeHelper<Func, T>::Type;
using return_type = typename return_type_helper<Func, T>::Type;
struct Void {};
template <typename T> struct VoidFix { typedef T Type; };
template <> struct VoidFix<void> { typedef Void Type; };
template <typename T> using FixVoid = typename VoidFix<T>::Type;
template <typename T> struct void_fix { typedef T Type; };
template <> struct void_fix<void> { typedef Void Type; };
template <typename T> using fix_void = typename void_fix<T>::Type;
template <typename T> struct VoidUnfix { typedef T Type; };
template <> struct VoidUnfix<Void> { typedef void Type; };
template <typename T> using UnfixVoid = typename VoidUnfix<T>::Type;
template <typename T> struct void_unfix { typedef T Type; };
template <> struct void_unfix<Void> { typedef void Type; };
template <typename T> using unfix_void = typename void_unfix<T>::Type;
template <typename... T> constexpr bool always_false = false;

46
source/forstio/error.cpp
View File

@ -1,19 +1,19 @@
#include "error.h"
namespace saw {
Error::Error() : error_{static_cast<Error::Code>(0)} {}
error::error() : error_{static_cast<error::code>(0)} {}
Error::Error(const std::string_view &msg, Error::Code code)
: error_message_{msg}, error_{static_cast<Error::Code>(code)} {}
error::error(const std::string_view &msg, error::code code)
: error_message_{msg}, error_{static_cast<error::code>(code)} {}
Error::Error(std::string &&msg, Error::Code code)
: error_message_{std::move(msg)}, error_{static_cast<Error::Code>(code)} {}
error::error(std::string &&msg, error::code code)
: error_message_{std::move(msg)}, error_{static_cast<error::code>(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 {
@ -30,20 +30,20 @@ const std::string_view Error::message() const {
error_message_);
}
bool Error::failed() const {
return static_cast<std::underlying_type_t<Error::Code>>(error_) != 0;
bool error::failed() const {
return static_cast<std::underlying_type_t<error::code>>(error_) != 0;
}
bool Error::isCritical() const {
return static_cast<std::underlying_type_t<Error::Code>>(error_) < 0;
bool error::is_critical() const {
return static_cast<std::underlying_type_t<error::code>>(error_) < 0;
}
bool Error::isRecoverable() const {
return static_cast<std::underlying_type_t<Error::Code>>(error_) > 0;
bool error::is_recoverable() const {
return static_cast<std::underlying_type_t<error::code>>(error_) > 0;
}
Error Error::copyError() const {
Error error;
error error::copy_error() const {
error error;
error.error_ = error_;
try {
error.error_message_ = error_message_;
@ -54,20 +54,20 @@ Error Error::copyError() const {
return error;
}
Error::Code Error::code() const { return static_cast<Error::Code>(error_); }
error::code error::id() const { return static_cast<error::code>(error_); }
Error makeError(const std::string_view &generic, Error::Code code) {
return Error{generic, code};
error make_error(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 make_error(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 make_error(generic, c);
}
Error noError() { return Error{}; }
error no_error() { return error{}; }
} // namespace saw

115
source/forstio/error.h
View File

@ -14,9 +14,9 @@ namespace saw {
* 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 {
enum class code : int16_t {
GenericCritical = -1,
GenericRecoverable = 1,
Disconnected = -99,
@ -25,119 +25,124 @@ public:
private:
std::variant<std::string_view, std::string> 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 id);
error(std::string &&msg, error::code id);
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 id() const;
};
Error makeError(const std::string_view &generic, Error::Code c);
error make_error(const std::string_view &generic, error::code c);
template <typename Formatter>
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};
}
}
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::GenericCritical);
template <typename Formatter>
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::GenericCritical) {
return make_error(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::GenericRecoverable);
template <typename Formatter>
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::GenericRecoverable) {
return make_error(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 <typename T> class ErrorOr;
template <typename T> class error_or;
class ErrorOrValue {
class error_or_value {
public:
virtual ~ErrorOrValue() = default;
virtual ~error_or_value() = default;
template <typename T> ErrorOr<UnfixVoid<T>> &as() {
return static_cast<ErrorOr<UnfixVoid<T>> &>(*this);
template <typename T> error_or<unfix_void<T>> &as() {
return static_cast<error_or<unfix_void<T>> &>(*this);
}
template <typename T> const ErrorOr<UnfixVoid<T>> &as() const {
return static_cast<const ErrorOr<UnfixVoid<T>> &>(*this);
template <typename T> const error_or<unfix_void<T>> &as() const {
return static_cast<const error_or<unfix_void<T>> &>(*this);
}
};
template <typename T> class ErrorOr final : public ErrorOrValue {
template <typename T> class error_or final : public error_or_value {
private:
std::variant<Error, FixVoid<T>> value_or_error_;
std::variant<error, fix_void<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} {}
error_or() = default;
error_or(const fix_void<T> &value) : value_or_error_{value} {}
ErrorOr(FixVoid<T> &&value) : value_or_error_{std::move(value)} {}
error_or(fix_void<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)} {}
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<FixVoid<T>>(value_or_error_);
bool is_value() const {
return std::holds_alternative<fix_void<T>>(value_or_error_);
}
bool isError() const {
return std::holds_alternative<Error>(value_or_error_);
bool is_error() const {
return std::holds_alternative<class error>(value_or_error_);
}
Error &error() { return std::get<Error>(value_or_error_); }
class error &error() {
return std::get<class error>(value_or_error_);
}
const Error &error() const { return std::get<Error>(value_or_error_); }
const class error &error() const {
return std::get<class error>(value_or_error_);
}
FixVoid<T> &value() { return std::get<FixVoid<T>>(value_or_error_); }
fix_void<T> &value() { return std::get<fix_void<T>>(value_or_error_); }
const FixVoid<T> &value() const {
return std::get<FixVoid<T>>(value_or_error_);
const fix_void<T> &value() const {
return std::get<fix_void<T>>(value_or_error_);
}
};
template <typename T> class ErrorOr<ErrorOr<T>> {
template <typename T> class error_or<error_or<T>> {
private:
ErrorOr() = delete;
error_or() = delete;
};
} // namespace saw

42
source/forstio/io.cpp
View File

@ -4,15 +4,15 @@
namespace saw {
AsyncIoStream::AsyncIoStream(Own<IoStream> str)
async_io_stream::async_io_stream(own<io_stream> str)
: stream_{std::move(str)},
read_ready_{stream_->readReady()
.then([this]() { read_stepper_.readStep(*stream_); })
read_ready_{stream_->read_ready()
.then([this]() { read_stepper_.read_step(*stream_); })
.sink()},
write_ready_{stream_->writeReady()
write_ready_{stream_->write_ready()
.then([this]() { write_stepper_.writeStep(*stream_); })
.sink()},
read_disconnected_{stream_->onReadDisconnected()
read_disconnected_{stream_->on_read_disconnected()
.then([this]() {
if (read_stepper_.on_read_disconnect) {
read_stepper_.on_read_disconnect->feed();
@ -20,51 +20,51 @@ AsyncIoStream::AsyncIoStream(Own<IoStream> str)
})
.sink()} {}
void AsyncIoStream::read(void *buffer, size_t min_length, size_t max_length) {
void async_io_stream::read(void *buffer, size_t min_length, size_t max_length) {
SAW_ASSERT(buffer && max_length >= min_length && min_length > 0) { return; }
SAW_ASSERT(!read_stepper_.read_task.has_value()) { return; }
read_stepper_.read_task =
ReadTaskAndStepHelper::ReadIoTask{buffer, min_length, max_length, 0};
read_stepper_.readStep(*stream_);
read_stepper_.read_task = read_task_and_step_helper::read_io_task{
buffer, min_length, max_length, 0};
read_stepper_.read_step(*stream_);
}
Conveyor<size_t> AsyncIoStream::readDone() {
auto caf = newConveyorAndFeeder<size_t>();
conveyor<size_t> async_io_stream::read_done() {
auto caf = new_conveyor_and_feeder<size_t>();
read_stepper_.read_done = std::move(caf.feeder);
return std::move(caf.conveyor);
}
Conveyor<void> AsyncIoStream::onReadDisconnected() {
auto caf = newConveyorAndFeeder<void>();
conveyor<void> async_io_stream::on_read_disconnected() {
auto caf = new_conveyor_and_feeder<void>();
read_stepper_.on_read_disconnect = std::move(caf.feeder);
return std::move(caf.conveyor);
}
void AsyncIoStream::write(const void *buffer, size_t length) {
void async_io_stream::write(const void *buffer, size_t length) {
SAW_ASSERT(buffer && length > 0) { return; }
SAW_ASSERT(!write_stepper_.write_task.has_value()) { return; }
write_stepper_.write_task =
WriteTaskAndStepHelper::WriteIoTask{buffer, length, 0};
write_task_and_step_helper::write_io_task{buffer, length, 0};
write_stepper_.writeStep(*stream_);
}
Conveyor<size_t> AsyncIoStream::writeDone() {
auto caf = newConveyorAndFeeder<size_t>();
conveyor<size_t> async_io_stream::write_done() {
auto caf = new_conveyor_and_feeder<size_t>();
write_stepper_.write_done = std::move(caf.feeder);
return std::move(caf.conveyor);
}
StringNetworkAddress::StringNetworkAddress(const std::string &address,
uint16_t port)
string_network_address::string_network_address(const std::string &address,
uint16_t port)
: address_value_{address}, port_value_{port} {}
const std::string &StringNetworkAddress::address() const {
const std::string &string_network_address::address() const {
return address_value_;
}
uint16_t StringNetworkAddress::port() const { return port_value_; }
uint16_t string_network_address::port() const { return port_value_; }
} // namespace saw

143
source/forstio/io.h
View File

@ -11,155 +11,156 @@ namespace saw {
/*
* Input stream
*/
class InputStream {
class input_stream {
public:
virtual ~InputStream() = default;
virtual ~input_stream() = default;
virtual ErrorOr<size_t> read(void *buffer, size_t length) = 0;
virtual error_or<size_t> read(void *buffer, size_t length) = 0;
virtual Conveyor<void> readReady() = 0;
virtual conveyor<void> read_ready() = 0;
virtual Conveyor<void> onReadDisconnected() = 0;
virtual conveyor<void> on_read_disconnected() = 0;
};
/*
* Output stream
*/
class OutputStream {
class output_stream {
public:
virtual ~OutputStream() = default;
virtual ~output_stream() = default;
virtual ErrorOr<size_t> write(const void *buffer, size_t length) = 0;
virtual error_or<size_t> write(const void *buffer, size_t length) = 0;
virtual Conveyor<void> writeReady() = 0;
virtual conveyor<void> write_ready() = 0;
};
/*
* Io stream
*/
class IoStream : public InputStream, public OutputStream {
class io_stream : public input_stream, public output_stream {
public:
virtual ~IoStream() = default;
virtual ~io_stream() = default;
};
class AsyncInputStream {
class async_input_stream {
public:
virtual ~AsyncInputStream() = default;
virtual ~async_input_stream() = default;
virtual void read(void *buffer, size_t min_length, size_t max_length) = 0;
virtual Conveyor<size_t> readDone() = 0;
virtual Conveyor<void> onReadDisconnected() = 0;
virtual conveyor<size_t> read_done() = 0;
virtual conveyor<void> on_read_disconnected() = 0;
};
class AsyncOutputStream {
class async_output_stream {
public:
virtual ~AsyncOutputStream() = default;
virtual ~async_output_stream() = default;
virtual void write(const void *buffer, size_t length) = 0;
virtual Conveyor<size_t> writeDone() = 0;
virtual conveyor<size_t> write_done() = 0;
};
class AsyncIoStream final : public AsyncInputStream, public AsyncOutputStream {
class async_io_stream final : public async_input_stream,
public async_output_stream {
private:
Own<IoStream> stream_;
own<io_stream> stream_;
ConveyorSink read_ready_;
ConveyorSink write_ready_;
ConveyorSink read_disconnected_;
conveyor_sink read_ready_;
conveyor_sink write_ready_;
conveyor_sink read_disconnected_;
ReadTaskAndStepHelper read_stepper_;
WriteTaskAndStepHelper write_stepper_;
read_task_and_step_helper read_stepper_;
write_task_and_step_helper write_stepper_;
public:
AsyncIoStream(Own<IoStream> str);
async_io_stream(own<io_stream> str);
SAW_FORBID_COPY(AsyncIoStream);
SAW_FORBID_MOVE(AsyncIoStream);
SAW_FORBID_COPY(async_io_stream);
SAW_FORBID_MOVE(async_io_stream);
void read(void *buffer, size_t length, size_t max_length) override;
Conveyor<size_t> readDone() override;
conveyor<size_t> read_done() override;
Conveyor<void> onReadDisconnected() override;
conveyor<void> on_read_disconnected() override;
void write(const void *buffer, size_t length) override;
Conveyor<size_t> writeDone() override;
conveyor<size_t> write_done() override;
};
class Server {
class server {
public:
virtual ~Server() = default;
virtual ~server() = default;
virtual Conveyor<Own<IoStream>> accept() = 0;
virtual conveyor<own<io_stream>> accept() = 0;
};
class NetworkAddress;
class network_address;
/**
* Datagram class. Bound to a local address it is able to receive inbound
* datagram messages and send them as well as long as an address is provided as
* well
*/
class Datagram {
class datagram {
public:
virtual ~Datagram() = default;
virtual ~datagram() = default;
virtual ErrorOr<size_t> read(void *buffer, size_t length) = 0;
virtual Conveyor<void> readReady() = 0;
virtual error_or<size_t> read(void *buffer, size_t length) = 0;
virtual conveyor<void> read_ready() = 0;
virtual ErrorOr<size_t> write(const void *buffer, size_t length,
NetworkAddress &dest) = 0;
virtual Conveyor<void> writeReady() = 0;
virtual error_or<size_t> write(const void *buffer, size_t length,
network_address &dest) = 0;
virtual conveyor<void> write_ready() = 0;
};
class OsNetworkAddress;
class StringNetworkAddress;
class os_network_address;
class string_network_address;
class NetworkAddress {
class network_address {
public:
using ChildVariant =
std::variant<OsNetworkAddress *, StringNetworkAddress *>;
using child_variant =
std::variant<os_network_address *, string_network_address *>;
virtual ~NetworkAddress() = default;
virtual ~network_address() = default;
virtual NetworkAddress::ChildVariant representation() = 0;
virtual network_address::child_variant representation() = 0;
virtual const std::string &address() const = 0;
virtual uint16_t port() const = 0;
};
class OsNetworkAddress : public NetworkAddress {
class os_network_address : public network_address {
public:
virtual ~OsNetworkAddress() = default;
virtual ~os_network_address() = default;
NetworkAddress::ChildVariant representation() override { return this; }
network_address::child_variant representation() override { return this; }
};
class StringNetworkAddress final : public NetworkAddress {
class string_network_address final : public network_address {
private:
std::string address_value_;
uint16_t port_value_;
public:
StringNetworkAddress(const std::string &address, uint16_t port);
string_network_address(const std::string &address, uint16_t port);
const std::string &address() const override;
uint16_t port() const override;
NetworkAddress::ChildVariant representation() override { return this; }
network_address::child_variant representation() override { return this; }
};
class Network {
class network {
public:
virtual ~Network() = default;
virtual ~network() = default;
/**
* Resolve the provided string and uint16 to the preferred storage method
*/
virtual Conveyor<Own<NetworkAddress>>
resolveAddress(const std::string &addr, uint16_t port_hint = 0) = 0;
virtual conveyor<own<network_address>>
resolve_address(const std::string &addr, uint16_t port_hint = 0) = 0;
/**
* Parse the provided string and uint16 to the preferred storage method
@ -172,33 +173,33 @@ public:
/**
* Set up a listener on this address
*/
virtual Own<Server> listen(NetworkAddress &bind_addr) = 0;
virtual own<server> listen(network_address &bind_addr) = 0;
/**
* Connect to a remote address
*/
virtual Conveyor<Own<IoStream>> connect(NetworkAddress &address) = 0;
virtual conveyor<own<io_stream>> connect(network_address &address) = 0;
/**
* Bind a datagram socket at this address.
*/
virtual Own<Datagram> datagram(NetworkAddress &address) = 0;
virtual own<datagram> datagram(network_address &address) = 0;
};
class IoProvider {
class io_provider {
public:
virtual ~IoProvider() = default;
virtual ~io_provider() = default;
virtual Own<InputStream> wrapInputFd(int fd) = 0;
virtual own<input_stream> wrap_input_fd(int fd) = 0;
virtual Network &network() = 0;
virtual network &network() = 0;
};
struct AsyncIoContext {
Own<IoProvider> io;
EventLoop &event_loop;
EventPort &event_port;
struct async_io_context {
own<io_provider> io;
event_loop &event_loop;
event_port &event_port;
};
ErrorOr<AsyncIoContext> setupAsyncIo();
error_or<async_io_context> setup_async_io();
} // namespace saw

6
source/forstio/io_auth.cpp
View File

@ -1,8 +1,8 @@
#include "io_auth.h"
namespace saw {
Peer::Peer(const std::string &identity_) : identity_value_{identity_} {}
Peer::Peer(std::string &&identity_) : identity_value_{std::move(identity_)} {}
peer::peer(const std::string &identity_) : identity_value_{identity_} {}
peer::peer(std::string &&identity_) : identity_value_{std::move(identity_)} {}
const std::string &Peer::identity() const { return identity_value_; }
const std::string &peer::identity() const { return identity_value_; }
} // namespace saw

28
source/forstio/io_auth.h
View File

@ -3,10 +3,10 @@
#include "io.h"
namespace saw {
class Peer {
class peer {
public:
Peer(const std::string &ident);
Peer(std::string &&ident);
peer(const std::string &ident);
peer(std::string &&ident);
const std::string &identity() const;
@ -14,40 +14,40 @@ private:
std::string identity_value_;
};
class AuthenticatedIoStream {
class authenticated_io_stream {
public:
// This is the easiest way to implement Authenticated streams.
// This is a simple pair of the stream and the peer.
Own<IoStream> stream;
Maybe<Own<Peer>> peer;
own<io_stream> stream;
maybe<own<peer>> peer;
};
class AuthenticatedServer {
class authenticated_server {
public:
virtual ~AuthenticatedServer() = default;
virtual ~authenticated_server() = default;
virtual Conveyor<AuthenticatedIoStream> accept() = 0;
virtual conveyor<authenticated_io_stream> accept() = 0;
};
/**
* Authenticated Network class which provides a peer identity when connecting
*/
class AuthenticatedNetwork {
class authenticated_network {
public:
virtual ~AuthenticatedNetwork() = default;
virtual ~authenticated_network() = default;
/**
* Connects to the provided address.
* Returns as soon as it is authenticated or fails
*/
virtual Conveyor<AuthenticatedIoStream>
connect(NetworkAddress &address) = 0;
virtual conveyor<authenticated_io_stream>
connect(network_address &address) = 0;
/**
* Creates a server listening for connections
*/
virtual Own<AuthenticatedServer> listen() = 0;
virtual own<authenticated_server> listen() = 0;
};
} // namespace saw

36
source/forstio/io_helpers.cpp
View File

@ -5,22 +5,22 @@
#include <cassert>
namespace saw {
void ReadTaskAndStepHelper::readStep(InputStream &reader) {
void read_task_and_step_helper::read_step(input_stream &reader) {
while (read_task.has_value()) {
ReadIoTask &task = *read_task;
read_io_task &task = *read_task;
ErrorOr<size_t> n_err = reader.read(task.buffer, task.max_length);
if (n_err.isError()) {
const Error &error = n_err.error();
if (error.isCritical()) {
error_or<size_t> n_err = reader.read(task.buffer, task.max_length);
if (n_err.is_error()) {
const error &error = n_err.error();
if (error.is_critical()) {
if (read_done) {
read_done->fail(error.copyError());
read_done->fail(error.copy_error());
}
read_task = std::nullopt;
}
break;
} else if (n_err.isValue()) {
} else if (n_err.is_value()) {
size_t n = n_err.value();
if (static_cast<size_t>(n) >= task.min_length &&
static_cast<size_t>(n) <= task.max_length) {
@ -37,20 +37,20 @@ void ReadTaskAndStepHelper::readStep(InputStream &reader) {
} else {
if (read_done) {
read_done->fail(criticalError("Read failed"));
read_done->fail(critical_error("Read failed"));
}
read_task = std::nullopt;
}
}
}
void WriteTaskAndStepHelper::writeStep(OutputStream &writer) {
void write_task_and_step_helper::writeStep(output_stream &writer) {
while (write_task.has_value()) {
WriteIoTask &task = *write_task;
write_io_task &task = *write_task;
ErrorOr<size_t> n_err = writer.write(task.buffer, task.length);
error_or<size_t> n_err = writer.write(task.buffer, task.length);
if (n_err.isValue()) {
if (n_err.is_value()) {
size_t n = n_err.value();
assert(n <= task.length);
@ -64,18 +64,18 @@ void WriteTaskAndStepHelper::writeStep(OutputStream &writer) {
task.length -= n;
task.already_written += n;
}
} else if (n_err.isError()) {
const Error &error = n_err.error();
if (error.isCritical()) {
} else if (n_err.is_error()) {
const error &error = n_err.error();
if (error.is_critical()) {
if (write_done) {
write_done->fail(error.copyError());
write_done->fail(error.copy_error());
}
write_task = std::nullopt;
}
break;
} else {
if (write_done) {
write_done->fail(criticalError("Write failed"));
write_done->fail(critical_error("Write failed"));
}
write_task = std::nullopt;
}

26
source/forstio/io_helpers.h
View File

@ -16,38 +16,38 @@ namespace saw {
* and gnutls doesn't let me write or read into buffers I have to have this kind
* of strange abstraction. This may also be reusable for windows/macOS though.
*/
class InputStream;
class input_stream;
class ReadTaskAndStepHelper {
class read_task_and_step_helper {
public:
struct ReadIoTask {
struct read_io_task {
void *buffer;
size_t min_length;
size_t max_length;
size_t already_read = 0;
};
std::optional<ReadIoTask> read_task;
Own<ConveyorFeeder<size_t>> read_done = nullptr;
std::optional<read_io_task> read_task;
own<conveyor_feeder<size_t>> read_done = nullptr;
Own<ConveyorFeeder<void>> on_read_disconnect = nullptr;
own<conveyor_feeder<void>> on_read_disconnect = nullptr;
public:
void readStep(InputStream &reader);
void read_step(input_stream &reader);
};
class OutputStream;
class output_stream;
class WriteTaskAndStepHelper {
class write_task_and_step_helper {
public:
struct WriteIoTask {
struct write_io_task {
const void *buffer;
size_t length;
size_t already_written = 0;
};
std::optional<WriteIoTask> write_task;
Own<ConveyorFeeder<size_t>> write_done = nullptr;
std::optional<write_io_task> write_task;
own<conveyor_feeder<size_t>> write_done = nullptr;
public:
void writeStep(OutputStream &writer);
void writeStep(output_stream &writer);
};
} // namespace saw

70
source/forstio/io_peer.h
View File

@ -8,82 +8,82 @@
namespace saw {
template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer = MessageContainer<Incoming>,
typename OutContainer = MessageContainer<Outgoing>,
typename BufferT = RingBuffer>
class StreamingIoPeer {
typename InContainer = message_container<Incoming>,
typename OutContainer = message_container<Outgoing>,
typename BufferT = ring_buffer>
class streaming_io_peer {
public:
/**
*
*/
StreamingIoPeer(
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed,
Own<AsyncIoStream> stream, Codec codec, BufferT in, BufferT out);
streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
own<async_io_stream> stream, Codec codec, BufferT in, BufferT out);
/**
*
*/
StreamingIoPeer(
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed,
Own<AsyncIoStream> stream);
streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
own<async_io_stream> stream);
/**
* Deleted copy and move constructors
*/
SAW_FORBID_COPY(StreamingIoPeer);
SAW_FORBID_MOVE(StreamingIoPeer);
SAW_FORBID_COPY(streaming_io_peer);
SAW_FORBID_MOVE(streaming_io_peer);
/**
* Send a message to the remote peer
*/
Error send(HeapMessageRoot<Outgoing, OutContainer> builder);
error send(HeapMessageRoot<Outgoing, OutContainer> builder);
/**
* A phantom conveyor feeder. Meant for interfacing with other components
*/
ConveyorFeeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
Conveyor<void> onReadDisconnected();
conveyor<void> onReadDisconnected();
private:
/// @unimplemented
class PeerConveyorFeeder final
: public ConveyorFeeder<HeapMessageRoot<Outgoing, OutContainer>> {
class peer_conveyor_feeder final
: public conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> {
public:
PeerConveyorFeeder(
StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT> &peer_)
peer_conveyor_feeder(
streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT> &peer_)
: peer_{peer_} {}
void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override {
(void)data;
}
void fail(Error &&error) override { (void)error; }
void fail(error &&error) override { (void)error; }
size_t space() const override { return 0; }
size_t queued() const override { return 0; }
private:
StreamingIoPeer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT> &peer_;
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT> &peer_;
};
private:
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>>
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>>
incoming_feeder_ = nullptr;
Own<AsyncIoStream> io_stream_;
own<async_io_stream> io_stream_;
Codec codec_;
BufferT in_buffer_;
BufferT out_buffer_;
ConveyorSink sink_read_;
ConveyorSink sink_write_;
conveyor_sink sink_read_;
conveyor_sink sink_write_;
PeerConveyorFeeder conveyor_feeder_;
peer_conveyor_feeder conveyor_feeder_;
};
/**
@ -91,13 +91,13 @@ private:
* This is a convenience wrapper intended for a faster setup of this class
*/
template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer = MessageContainer<Incoming>,
typename OutContainer = MessageContainer<Outgoing>,
typename BufferT = RingBuffer>
std::pair<Own<StreamingIoPeer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>>,
Conveyor<HeapMessageRoot<Incoming, InContainer>>>
newStreamingIoPeer(Own<AsyncIoStream> stream);
typename InContainer = message_container<Incoming>,
typename OutContainer = message_container<Outgoing>,
typename BufferT = ring_buffer>
std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>>,
conveyor<HeapMessageRoot<Incoming, InContainer>>>
newStreamingIoPeer(own<async_io_stream> stream);
} // namespace saw

4
source/forstio/log.cpp
View File

@ -1,7 +1,7 @@
#include "log.h"
namespace saw {
LogIo::LogIo(EventLoop &loop) : loop_{loop} {}
log_io::log_io(event_loop &loop) : loop_{loop} {}
Log::Log(LogIo &central, EventLoop &loop) : central_{central}, loop_{loop} {}
log::log(log_io &central, event_loop &loop) : central_{central}, loop_{loop} {}
} // namespace saw

18
source/forstio/log.h
View File

@ -3,24 +3,24 @@
#include "common.h"
namespace saw {
class EventLoop;
class LogIo;
class Log {
class event_loop;
class log_io;
class log {
public:
enum class Type : uint8_t { Info, Warning, Error, Debug };
private:
LogIo &central_;
EventLoop &loop_;
log_io &central_;
event_loop &loop_;
public:
Log(LogIo &central, EventLoop &loop);
log(log_io &central, event_loop &loop);
};
class LogIo {
class log_io {
private:
EventLoop &loop_;
event_loop &loop_;
public:
LogIo(EventLoop &loop);
log_io(event_loop &loop);
};
} // namespace saw

252
source/forstio/message.h
View File

@ -15,18 +15,18 @@
#include "string_literal.h"
namespace saw {
class MessageBase {
class message_base {
protected:
bool set_explicitly_ = false;
public:
template <class T> T &as() {
static_assert(std::is_base_of<MessageBase, T>());
static_assert(std::is_base_of<message_base, T>());
return dynamic_cast<T &>(*this);
}
template <class T> const T &as() const {
static_assert(std::is_base_of<MessageBase, T>());
static_assert(std::is_base_of<message_base, T>());
return dynamic_cast<const T &>(*this);
}
};
@ -44,30 +44,30 @@ public:
/*
* Struct Message
*/
template <class... V, StringLiteral... Keys, class Container>
class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
: public MessageBase {
template <class... V, string_literal... Keys, class Container>
class message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
: public message_base {
private:
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
private:
MessageType &message_;
public:
Builder(MessageType &msg) : message_{msg} {}
builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message_}; }
reader as_reader() { return reader{message_}; }
/*
* Initialize a member by index
@ -76,9 +76,9 @@ public:
typename std::enable_if<
!SchemaIsArray<
typename MessageParameterPackType<i, V...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init() {
return typename Container::template ElementType<i>::Builder{
return typename Container::template ElementType<i>::builder{
message_.container_.template get<i>()};
}
@ -86,14 +86,14 @@ public:
* Initialize a member by their name
* This is the preferred method for schema::Struct messages
*/
template <StringLiteral Literal>
template <string_literal Literal>
typename std::enable_if<
!SchemaIsArray<typename MessageParameterPackType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
V...>::Type>::Value,
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal,
Keys...>::Value>::Builder>::type
Keys...>::Value>::builder>::type
init() {
constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@ -105,10 +105,10 @@ public:
typename std::enable_if<
SchemaIsArray<
typename MessageParameterPackType<i, V...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) {
auto array_builder =
typename Container::template ElementType<i>::Builder{
typename Container::template ElementType<i>::builder{
message_.container_.template get<i>(), size};
return array_builder;
}
@ -116,14 +116,14 @@ public:
/*
* Version for array schema type
*/
template <StringLiteral Literal>
template <string_literal Literal>
typename std::enable_if<
SchemaIsArray<typename MessageParameterPackType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
V...>::Type>::Value,
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal,
Keys...>::Value>::Builder>::type
Keys...>::Value>::builder>::type
init(size_t size) {
constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@ -132,21 +132,21 @@ public:
}
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(MessageType &msg) : message_{msg} {}
reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_}; }
builder as_builder() { return builder{message_}; }
/*
* Get member by index
*/
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
typename Container::template ElementType<i>::reader get() {
return typename Container::template ElementType<i>::reader{
message_.container_.template get<i>()};
}
@ -154,9 +154,9 @@ public:
* Get member by name
* This is the preferred method for schema::Struct messages
*/
template <StringLiteral Literal>
template <string_literal Literal>
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
get() {
// The index of the first match
constexpr size_t i =
@ -166,59 +166,59 @@ public:
}
};
Builder build() { return Builder{*this}; }
builder build() { return builder{*this}; }
Reader read() { return Reader{*this}; }
reader read() { return reader{*this}; }
};
/*
* Union message class. Wrapper object
*/
template <class... V, StringLiteral... Keys, class Container>
class Message<schema::Union<schema::NamedMember<V, Keys>...>, Container> final
: public MessageBase {
template <class... V, string_literal... Keys, class Container>
class message<schema::Union<schema::NamedMember<V, Keys>...>, Container> final
: public message_base {
private:
using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
private:
MessageType &message_;
public:
Builder(MessageType &msg) : message_{msg} {}
builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message_}; }
reader as_reader() { return reader{message_}; }
template <size_t i>
typename std::enable_if<
!SchemaIsArray<
typename MessageParameterPackType<i, V...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init() {
return typename Container::template ElementType<i>::Builder{
return typename Container::template ElementType<i>::builder{
message_.container_.template get<i>()};
}
template <StringLiteral Literal>
template <string_literal Literal>
typename std::enable_if<
!SchemaIsArray<typename MessageParameterPackType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
V...>::Type>::Value,
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal,
Keys...>::Value>::Builder>::type
Keys...>::Value>::builder>::type
init() {
constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@ -233,20 +233,20 @@ public:
typename std::enable_if<
SchemaIsArray<
typename MessageParameterPackType<i, V...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) {
return typename Container::template ElementType<i>::Builder{
return typename Container::template ElementType<i>::builder{
message_.container_.template get<i>(), size};
}
template <StringLiteral Literal>
template <string_literal Literal>
typename std::enable_if<
SchemaIsArray<typename MessageParameterPackType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
V...>::Type>::Value,
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal,
Keys...>::Value>::Builder>::type
Keys...>::Value>::builder>::type
init(size_t size) {
constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
@ -255,24 +255,24 @@ public:
}
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(MessageType &msg) : message_{msg} {}
reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_}; }
builder as_builder() { return builder{message_}; }
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
typename Container::template ElementType<i>::reader get() {
return typename Container::template ElementType<i>::reader{
message_.container_.template get<i>()};
}
template <StringLiteral Literal>
template <string_literal Literal>
typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::Reader
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
get() {
// The index of the first match
constexpr size_t i =
@ -281,14 +281,14 @@ public:
return get<i>();
}
template <StringLiteral Literal>
template <string_literal Literal>
static constexpr size_t toIndex() noexcept {
return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
}
size_t index() const noexcept { return message_.container_.index(); }
template <StringLiteral Literal> bool hasAlternative() const {
template <string_literal Literal> bool hasAlternative() const {
return index() == toIndex<Literal>();
}
};
@ -298,36 +298,36 @@ public:
* Array message class. Wrapper around an array schema element
*/
template <class T, class Container>
class Message<schema::Array<T>, Container> final : public MessageBase {
class message<schema::Array<T>, Container> final : public message_base {
private:
using SchemaType = schema::Array<T>;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same Schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
private:
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);
}
}
Reader asReader() { return Reader{message_}; }
reader as_reader() { return reader{message_}; }
typename Container::ElementType::Builder init(size_t i) {
return typename Container::ElementType::Builder{
typename Container::ElementType::builder init(size_t i) {
return typename Container::ElementType::builder{
message_.container_.get(i)};
}
@ -336,17 +336,17 @@ public:
void resize(size_t size) { message_.container_.resize(size); }
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(MessageType &msg) : message_{msg} {}
reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_, 0}; }
builder as_builder() { return builder{message_, 0}; }
typename Container::ElementType::Reader get(size_t i) {
return typename Container::ElementType::Reader{
typename Container::ElementType::reader get(size_t i) {
return typename Container::ElementType::reader{
message_.container_.get(i)};
}
@ -358,36 +358,36 @@ public:
* Tuple message class. Wrapper around a tuple schema
*/
template <class... T, class Container>
class Message<schema::Tuple<T...>, Container> final : public MessageBase {
class message<schema::Tuple<T...>, Container> final : public message_base {
private:
using SchemaType = schema::Tuple<T...>;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
MessageType &message_;
public:
Builder(MessageType &msg) : message_{msg} {}
builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message_}; }
reader as_reader() { return reader{message_}; }
template <size_t i>
typename std::enable_if<
!SchemaIsArray<
typename MessageParameterPackType<i, T...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init() {
return typename Container::template ElementType<i>::Builder{
return typename Container::template ElementType<i>::builder{
message_.container_.template get<i>()};
}
@ -395,24 +395,24 @@ public:
typename std::enable_if<
SchemaIsArray<
typename MessageParameterPackType<i, T...>::Type>::Value,
typename Container::template ElementType<i>::Builder>::type
typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) {
return typename Container::template ElementType<i>::Builder{
return typename Container::template ElementType<i>::builder{
message_.container_.template get<i>(), size};
}
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(MessageType &msg) : message_{msg} {}
reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_}; }
builder as_builder() { return builder{message_}; }
template <size_t i>
typename Container::template ElementType<i>::Reader get() {
return typename Container::template ElementType<i>::Reader{
typename Container::template ElementType<i>::reader get() {
return typename Container::template ElementType<i>::reader{
message_.container_.template get<i>()};
}
};
@ -423,43 +423,43 @@ public:
* int16_t, int32_t, int64_t) message class
*/
template <class T, size_t N, class Container>
class Message<schema::Primitive<T, N>, Container> final : public MessageBase {
class message<schema::Primitive<T, N>, Container> final : public message_base {
private:
using SchemaType = schema::Primitive<T, N>;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
private:
MessageType &message_;
public:
Builder(MessageType &msg) : message_{msg} {}
builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message_}; }
reader as_reader() { return reader{message_}; }
void set(const typename Container::ValueType &value) {
message_.container_.set(value);
}
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(Message &msg) : message_{msg} {}
reader(message &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_}; }
builder as_builder() { return builder{message_}; }
const typename Container::ValueType &get() const {
return message_.container_.get();
@ -468,64 +468,64 @@ public:
};
template <class Container>
class Message<schema::String, Container> final : public MessageBase {
class message<schema::String, Container> final : public message_base {
private:
using SchemaType = schema::String;
using MessageType = Message<SchemaType, Container>;
using MessageType = message<SchemaType, Container>;
Container container_;
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
"Container should have same the schema as Message");
friend class Builder;
friend class Reader;
friend class builder;
friend class reader;
public:
class Reader;
class Builder {
class reader;
class builder {
private:
MessageType &message_;
public:
Builder(MessageType &msg) : message_{msg} {}
builder(MessageType &msg) : message_{msg} {}
Reader asReader() { return Reader{message_}; }
reader as_reader() { 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(const char *str) { set(std::string_view{str}); }
};
class Reader {
class reader {
private:
MessageType &message_;
public:
Reader(MessageType &msg) : message_{msg} {}
reader(MessageType &msg) : message_{msg} {}
Builder asBuilder() { return Builder{message_}; }
builder as_builder() { return builder{message_}; }
const std::string_view get() const { return message_.container_.get(); }
};
};
template <class Schema, class Container = MessageContainer<Schema>>
template <class Schema, class Container = message_container<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() {
typename message<Schema, Container>::builder build() {
assert(root_);
return typename Message<Schema, Container>::Builder{*root_};
return typename message<Schema, Container>::builder{*root_};
}
typename Message<Schema, Container>::Reader read() {
typename message<Schema, Container>::reader read() {
assert(root_);
return typename Message<Schema, Container>::Reader{*root_};
return typename message<Schema, Container>::reader{*root_};
}
};
@ -535,28 +535,28 @@ 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) {
typename message<Schema, Container>::builder build(size_t size) {
assert(root_);
return typename Message<Schema, Container>::Builder{*root_, size};
return typename message<Schema, Container>::builder{*root_, size};
}
typename Message<Schema, Container>::Reader read() {
typename message<Schema, Container>::reader read() {
assert(root_);
return typename Message<Schema, Container>::Reader{*root_};
return typename message<Schema, Container>::reader{*root_};
}
};
/*
* Minor helper for creating a message root
*/
template <class Schema, class Container = MessageContainer<Schema>>
template <class Schema, class Container = message_container<Schema>>
inline HeapMessageRoot<Schema, Container> heapMessageRoot() {
Own<Message<Schema, Container>> root = heap<Message<Schema, Container>>();
own<message<Schema, Container>> root = heap<message<Schema, Container>>();
return HeapMessageRoot<Schema, Container>{std::move(root)};
}
} // namespace saw

48
source/forstio/message_container.h
View File

@ -6,9 +6,9 @@
#include <vector>
namespace saw {
template <class T> class MessageContainer;
template <class T> class message_container;
template <class T, class Container = MessageContainer<T>> class Message;
template <class T, class Container = message_container<T>> class message;
template <size_t N, class... T> struct MessageParameterPackType;
@ -39,7 +39,7 @@ struct MessageParameterPackIndex<T, TL0, TL...> {
* StringLiterals cannot be resolved as non-type primitive template values can.
* This is the workaround
*/
template <StringLiteral V, StringLiteral Key0, StringLiteral... Keys>
template <string_literal V, string_literal Key0, string_literal... Keys>
struct MessageParameterKeyPackIndexHelper {
static constexpr size_t Value =
(V == Key0)
@ -47,12 +47,12 @@ struct MessageParameterKeyPackIndexHelper {
: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value);
};
template <StringLiteral V, StringLiteral Key0>
template <string_literal V, string_literal Key0>
struct MessageParameterKeyPackIndexHelper<V, Key0> {
static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
};
template <StringLiteral V, StringLiteral... Keys>
template <string_literal V, string_literal... Keys>
struct MessageParameterKeyPackIndex {
static constexpr size_t Value =
MessageParameterKeyPackIndexHelper<V, Keys...>::Value;
@ -68,10 +68,10 @@ template <class T> struct SchemaIsArray<schema::Array<T>> {
constexpr static bool Value = true;
};
template <class... V, StringLiteral... Keys>
class MessageContainer<schema::Struct<schema::NamedMember<V, Keys>...>> {
template <class... V, string_literal... Keys>
class message_container<schema::Struct<schema::NamedMember<V, Keys>...>> {
private:
using ValueType = std::tuple<Message<V, MessageContainer<V>>...>;
using ValueType = std::tuple<message<V, message_container<V>>...>;
ValueType values_;
public:
@ -79,7 +79,7 @@ public:
template <size_t i>
using ElementType = typename MessageParameterPackType<
i, Message<V, MessageContainer<V>>...>::Type;
i, message<V, message_container<V>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
};
@ -87,10 +87,10 @@ public:
/*
* Union storage
*/
template <class... V, StringLiteral... Keys>
class MessageContainer<schema::Union<schema::NamedMember<V, Keys>...>> {
template <class... V, string_literal... Keys>
class message_container<schema::Union<schema::NamedMember<V, Keys>...>> {
private:
using ValueType = std::variant<Message<V, MessageContainer<V>>...>;
using ValueType = std::variant<message<V, message_container<V>>...>;
ValueType value_;
public:
@ -98,12 +98,12 @@ public:
template <size_t i>
using ElementType = typename MessageParameterPackType<
i, Message<V, MessageContainer<V>>...>::Type;
i, message<V, message_container<V>>...>::Type;
template <size_t i> ElementType<i> &get() {
if (i != value_.index()) {
using MessageIV = typename MessageParameterPackType<i, V...>::Type;
value_ = Message<MessageIV, MessageContainer<MessageIV>>{};
value_ = message<MessageIV, message_container<MessageIV>>{};
}
return std::get<i>(value_);
}
@ -115,17 +115,17 @@ public:
* Array storage
*/
template <class T> class MessageContainer<schema::Array<T>> {
template <class T> class message_container<schema::Array<T>> {
private:
using ValueType = std::vector<Message<T, MessageContainer<T>>>;
using ValueType = std::vector<message<T, message_container<T>>>;
ValueType values_;
public:
using SchemaType = schema::Array<T>;
using ElementType = Message<T, MessageContainer<T>>;
using ElementType = message<T, message_container<T>>;
Message<T, MessageContainer<T>> &get(size_t index) {
message<T, message_container<T>> &get(size_t index) {
return values_.at(index);
}
@ -137,9 +137,9 @@ public:
/*
* Tuple storage
*/
template <class... T> class MessageContainer<schema::Tuple<T...>> {
template <class... T> class message_container<schema::Tuple<T...>> {
private:
using ValueType = std::tuple<Message<T, MessageContainer<T>>...>;
using ValueType = std::tuple<message<T, message_container<T>>...>;
ValueType values_;
public:
@ -147,7 +147,7 @@ public:
template <size_t i>
using ElementType = typename MessageParameterPackType<
i, Message<T, MessageContainer<T>>...>::Type;
i, message<T, message_container<T>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
};
@ -208,7 +208,7 @@ struct PrimitiveTypeHelper<schema::Primitive<schema::FloatingPoint, 8>> {
using Type = double;
};
template <class T, size_t N> class MessageContainer<schema::Primitive<T, N>> {
template <class T, size_t N> class message_container<schema::Primitive<T, N>> {
public:
using SchemaType = schema::Primitive<T, N>;
using ValueType =
@ -218,14 +218,14 @@ private:
ValueType value_;
public:
MessageContainer() : value_{0} {}
message_container() : value_{0} {}
void set(const ValueType &v) { value_ = v; }
const ValueType &get() const { return value_; }
};
template <> class MessageContainer<schema::String> {
template <> class message_container<schema::String> {
public:
using SchemaType = schema::String;
using ValueType = std::string;

444
source/forstio/proto_kel.h
View File

@ -13,7 +13,7 @@ public:
private:
struct ReadContext {
Buffer &buffer;
buffer &buffer;
size_t offset = 0;
};
@ -37,194 +37,194 @@ public:
const Version version() const { return Version{0, 0, 0}; }
template <class Schema, class Container = MessageContainer<Schema>>
Error encode(typename Message<Schema, Container>::Reader reader,
Buffer &buffer);
template <class Schema, class Container = message_container<Schema>>
error encode(typename message<Schema, Container>::reader reader,
buffer &buffer);
template <class Schema, class Container = MessageContainer<Schema>>
Error decode(typename Message<Schema, Container>::Builder builder,
Buffer &buffer, const Limits &limits = Limits{});
template <class Schema, class Container = message_container<Schema>>
error decode(typename message<Schema, Container>::builder builder,
buffer &buffer, const Limits &limits = Limits{});
};
template <class T> struct ProtoKelEncodeImpl;
template <class T, size_t N, class Container>
struct ProtoKelEncodeImpl<Message<schema::Primitive<T, N>, Container>> {
static Error
encode(typename Message<schema::Primitive<T, N>, Container>::Reader data,
Buffer &buffer) {
Error error = StreamValue<typename PrimitiveTypeHelper<
struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
static error
encode(typename message<schema::Primitive<T, N>, Container>::reader data,
buffer &buffer) {
error err = stream_value<typename PrimitiveTypeHelper<
schema::Primitive<T, N>>::Type>::encode(data.get(), buffer);
return error;
return err;
}
static size_t
size(typename Message<schema::Primitive<T, N>, Container>::Reader) {
return StreamValue<typename PrimitiveTypeHelper<
size(typename message<schema::Primitive<T, N>, Container>::reader) {
return stream_value<typename PrimitiveTypeHelper<
schema::Primitive<T, N>>::Type>::size();
}
};
template <class Container>
struct ProtoKelEncodeImpl<Message<schema::String, Container>> {
static Error
encode(typename Message<schema::String, Container>::Reader data,
Buffer &buffer) {
struct ProtoKelEncodeImpl<message<schema::String, Container>> {
static error
encode(typename message<schema::String, Container>::reader data,
buffer &buffer) {
std::string_view view = data.get();
size_t size = view.size();
Error error = buffer.writeRequireLength(sizeof(size) + size);
if (error.failed()) {
return error;
error err = buffer.write_require_length(sizeof(size) + size);
if (err.failed()) {
return err;
}
error = StreamValue<size_t>::encode(size, buffer);
if (error.failed()) {
return error;
err = stream_value<size_t>::encode(size, buffer);
if (err.failed()) {
return err;
}
for (size_t i = 0; i < view.size(); ++i) {
buffer.write(i) = view[i];
}
buffer.writeAdvance(view.size());
return noError();
buffer.write_advance(view.size());
return no_error();
}
static size_t
size(typename Message<schema::String, Container>::Reader reader) {
size(typename message<schema::String, Container>::reader reader) {
return sizeof(size_t) + reader.get().size();
}
};
template <class... T, class Container>
struct ProtoKelEncodeImpl<Message<schema::Tuple<T...>, Container>> {
struct ProtoKelEncodeImpl<message<schema::Tuple<T...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), Error>::type
encodeMembers(typename Message<schema::Tuple<T...>, Container>::Reader,
Buffer &) {
return noError();
static typename std::enable_if<i == sizeof...(T), error>::type
encodeMembers(typename message<schema::Tuple<T...>, Container>::reader,
buffer &) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if<(i < sizeof...(T)), Error>::type
encodeMembers(typename Message<schema::Tuple<T...>, Container>::Reader data,
Buffer &buffer) {
Error error =
static typename std::enable_if<(i < sizeof...(T)), error>::type
encodeMembers(typename message<schema::Tuple<T...>, Container>::reader data,
buffer &buffer) {
error err =
ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
encode(data.template get<i>(), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
return encodeMembers<i + 1>(data, buffer);
}
static Error
encode(typename Message<schema::Tuple<T...>, Container>::Reader data,
Buffer &buffer) {
static error
encode(typename message<schema::Tuple<T...>, Container>::reader data,
buffer &buffer) {
return encodeMembers<0>(data, buffer);
}
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), size_t>::type
sizeMembers(typename Message<schema::Tuple<T...>, Container>::Reader) {
sizeMembers(typename message<schema::Tuple<T...>, Container>::reader) {
return 0;
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(T), size_t>::type sizeMembers(
typename Message<schema::Tuple<T...>, Container>::Reader reader) {
typename message<schema::Tuple<T...>, Container>::reader reader) {
return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
size(reader.template get<i>()) +
sizeMembers<i + 1>(reader);
}
static size_t
size(typename Message<schema::Tuple<T...>, Container>::Reader reader) {
size(typename message<schema::Tuple<T...>, Container>::reader reader) {
return sizeMembers<0>(reader);
}
};
template <typename... V, StringLiteral... K, class Container>
template <typename... V, string_literal... K, class Container>
struct ProtoKelEncodeImpl<
Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), Error>::type
encodeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader,
Buffer &) {
return noError();
static typename std::enable_if<i == sizeof...(V), error>::type
encodeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader,
buffer &) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), Error>::type encodeMembers(
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader data,
Buffer &buffer) {
i<sizeof...(V), error>::type encodeMembers(
typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader data,
buffer &buffer) {
Error error =
error err =
ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
encode(data.template get<i>(), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
return encodeMembers<i + 1>(data, buffer);
}
static Error
encode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader data,
Buffer &buffer) {
static error
encode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader data,
buffer &buffer) {
return encodeMembers<0>(data, buffer);
}
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), size_t>::type
sizeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader) {
sizeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader) {
return 0;
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), size_t>::type sizeMembers(
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader reader) {
typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader reader) {
return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
size(reader.template get<i>()) +
sizeMembers<i + 1>(reader);
}
static size_t
size(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Reader reader) {
size(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader reader) {
return sizeMembers<0>(reader);
}
};
template <typename... V, StringLiteral... K, class Container>
template <typename... V, string_literal... K, class Container>
struct ProtoKelEncodeImpl<
Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), Error>::type
encodeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader,
Buffer &) {
return noError();
static typename std::enable_if<i == sizeof...(V), error>::type
encodeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader,
buffer &) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), Error>::type encodeMembers(
typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader reader,
Buffer &buffer) {
i<sizeof...(V), error>::type encodeMembers(
typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader,
buffer &buffer) {
if (reader.index() == i) {
Error error =
StreamValue<ProtoKelCodec::UnionIdT>::encode(i, buffer);
if (error.failed()) {
return error;
error err =
stream_value<ProtoKelCodec::UnionIdT>::encode(i, buffer);
if (err.failed()) {
return err;
}
return ProtoKelEncodeImpl<typename Container::template ElementType<
i>>::encode(reader.template get<i>(), buffer);
@ -232,25 +232,25 @@ struct ProtoKelEncodeImpl<
return encodeMembers<i + 1>(reader, buffer);
}
static Error
encode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader reader,
Buffer &buffer) {
static error
encode(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader,
buffer &buffer) {
return encodeMembers<0>(reader, buffer);
}
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), size_t>::type
sizeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader) {
sizeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader) {
return 0;
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), size_t>::type sizeMembers(
typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader reader) {
typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader) {
if (reader.index() == i) {
return ProtoKelEncodeImpl<typename Container::template ElementType<
i>>::size(reader.template get<i>());
@ -262,42 +262,42 @@ struct ProtoKelEncodeImpl<
* Size of union id + member size
*/
static size_t
size(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Reader reader) {
size(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader) {
return sizeof(ProtoKelCodec::UnionIdT) + sizeMembers<0>(reader);
}
};
template <class T, class Container>
struct ProtoKelEncodeImpl<Message<schema::Array<T>, Container>> {
static Error
encode(typename Message<schema::Array<T>, Container>::Reader data,
Buffer &buffer) {
struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
static error
encode(typename message<schema::Array<T>, Container>::reader data,
buffer &buffer) {
ProtoKelCodec::ArrayLengthT array_length = data.size();
{
Error error = StreamValue<ProtoKelCodec::ArrayLengthT>::encode(
error err = stream_value<ProtoKelCodec::ArrayLengthT>::encode(
array_length, buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
for (size_t i = 0; i < array_length; ++i) {
Error error =
error err =
ProtoKelEncodeImpl<typename Container::ElementType>::encode(
data.get(i), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
return noError();
return no_error();
}
/*
*
*/
static size_t
size(typename Message<schema::Array<T>, Container>::Reader data) {
size(typename message<schema::Array<T>, Container>::reader data) {
size_t members = sizeof(ProtoKelCodec::ArrayLengthT);
for (size_t i = 0; i < data.size(); ++i) {
members +=
@ -315,159 +315,159 @@ struct ProtoKelEncodeImpl<Message<schema::Array<T>, Container>> {
template <typename T> struct ProtoKelDecodeImpl;
template <class T, size_t N, class Container>
struct ProtoKelDecodeImpl<Message<schema::Primitive<T, N>, Container>> {
static Error
decode(typename Message<schema::Primitive<T, N>, Container>::Builder data,
Buffer &buffer) {
struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> {
static error
decode(typename message<schema::Primitive<T, N>, Container>::builder data,
buffer &buffer) {
typename PrimitiveTypeHelper<schema::Primitive<T, N>>::Type val = 0;
Error error = StreamValue<typename PrimitiveTypeHelper<
error err = stream_value<typename PrimitiveTypeHelper<
schema::Primitive<T, N>>::Type>::decode(val, buffer);
data.set(val);
return error;
return err;
}
};
template <class Container>
struct ProtoKelDecodeImpl<Message<schema::String, Container>> {
static Error
decode(typename Message<schema::String, Container>::Builder data,
Buffer &buffer) {
struct ProtoKelDecodeImpl<message<schema::String, Container>> {
static error
decode(typename message<schema::String, Container>::builder data,
buffer &buffer) {
size_t size = 0;
if (sizeof(size) > buffer.readCompositeLength()) {
return recoverableError("Buffer too small");
if (sizeof(size) > buffer.read_composite_length()) {
return recoverable_error("Buffer too small");
}
Error error = StreamValue<size_t>::decode(size, buffer);
if (error.failed()) {
return error;
error err = stream_value<size_t>::decode(size, buffer);
if (err.failed()) {
return err;
}
if (size > buffer.readCompositeLength()) {
return recoverableError("Buffer too small");
if (size > buffer.read_composite_length()) {
return recoverable_error("Buffer too small");
}
std::string value;
value.resize(size);
if (size > buffer.readCompositeLength()) {
return recoverableError("Buffer too small");
if (size > buffer.read_composite_length()) {
return recoverable_error("Buffer too small");
}
for (size_t i = 0; i < value.size(); ++i) {
value[i] = buffer.read(i);
}
buffer.readAdvance(value.size());
buffer.read_advance(value.size());
data.set(std::move(value));
return noError();
return no_error();
}
};
template <class... T, class Container>
struct ProtoKelDecodeImpl<Message<schema::Tuple<T...>, Container>> {
struct ProtoKelDecodeImpl<message<schema::Tuple<T...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), Error>::type
decodeMembers(typename Message<schema::Tuple<T...>, Container>::Builder,
Buffer &) {
return noError();
static typename std::enable_if<i == sizeof...(T), error>::type
decodeMembers(typename message<schema::Tuple<T...>, Container>::builder,
buffer &) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(T), Error>::type decodeMembers(
typename Message<schema::Tuple<T...>, Container>::Builder builder,
Buffer &buffer) {
i<sizeof...(T), error>::type decodeMembers(
typename message<schema::Tuple<T...>, Container>::builder builder,
buffer &buffer) {
Error error =
error err =
ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
decode(builder.template init<i>(), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
return decodeMembers<i + 1>(builder, buffer);
}
static Error
decode(typename Message<schema::Tuple<T...>, Container>::Builder builder,
Buffer &buffer) {
static error
decode(typename message<schema::Tuple<T...>, Container>::builder builder,
buffer &buffer) {
return decodeMembers<0>(builder, buffer);
}
};
template <class... V, StringLiteral... K, class Container>
template <class... V, string_literal... K, class Container>
struct ProtoKelDecodeImpl<
Message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), Error>::type
decodeMembers(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Builder,
Buffer &) {
return noError();
static typename std::enable_if<i == sizeof...(V), error>::type
decodeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::builder,
buffer &) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), Error>::type decodeMembers(
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Builder builder,
Buffer &buffer) {
i<sizeof...(V), error>::type decodeMembers(
typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::builder builder,
buffer &buffer) {
Error error =
error err =
ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
decode(builder.template init<i>(), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
return decodeMembers<i + 1>(builder, buffer);
}
static Error
decode(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::Builder builder,
Buffer &buffer) {
static error
decode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::builder builder,
buffer &buffer) {
return decodeMembers<0>(builder, buffer);
}
};
template <class... V, StringLiteral... K, class Container>
template <class... V, string_literal... K, class Container>
struct ProtoKelDecodeImpl<
Message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), Error>::type
decodeMembers(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Builder,
Buffer &, ProtoKelCodec::UnionIdT) {
return noError();
static typename std::enable_if<i == sizeof...(V), error>::type
decodeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder,
buffer &, ProtoKelCodec::UnionIdT) {
return no_error();
}
template <size_t i = 0>
static typename std::enable_if <
i<sizeof...(V), Error>::type decodeMembers(
typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Builder builder,
Buffer &buffer, ProtoKelCodec::UnionIdT id) {
i<sizeof...(V), error>::type decodeMembers(
typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder builder,
buffer &buffer, ProtoKelCodec::UnionIdT id) {
if (id == i) {
Error error =
error err =
ProtoKelDecodeImpl<typename Container::template ElementType<
i>>::decode(builder.template init<i>(), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
return decodeMembers<i + 1>(builder, buffer, id);
}
static Error
decode(typename Message<schema::Union<schema::NamedMember<V, K>...>,
Container>::Builder builder,
Buffer &buffer) {
static error
decode(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder builder,
buffer &buffer) {
ProtoKelCodec::UnionIdT id = 0;
Error error = StreamValue<ProtoKelCodec::UnionIdT>::decode(id, buffer);
if (error.failed()) {
return error;
error err = stream_value<ProtoKelCodec::UnionIdT>::decode(id, buffer);
if (err.failed()) {
return err;
}
if (id >= sizeof...(V)) {
return criticalError("Union doesn't have this many id's");
return critical_error("Union doesn't have this many id's");
}
return decodeMembers<0>(builder, buffer, id);
@ -475,85 +475,85 @@ struct ProtoKelDecodeImpl<
};
template <class T, class Container>
struct ProtoKelDecodeImpl<Message<schema::Array<T>, Container>> {
static Error
decode(typename Message<schema::Array<T>, Container>::Builder data,
Buffer &buffer) {
struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
static error
decode(typename message<schema::Array<T>, Container>::builder data,
buffer &buffer) {
ProtoKelCodec::ArrayLengthT array_length = 0;
{
Error error = StreamValue<ProtoKelCodec::ArrayLengthT>::decode(
error err = stream_value<ProtoKelCodec::ArrayLengthT>::decode(
array_length, buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
data.resize(array_length);
for (size_t i = 0; i < array_length; ++i) {
Error error =
error err =
ProtoKelDecodeImpl<typename Container::ElementType>::decode(
data.init(i), buffer);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
return noError();
return no_error();
}
};
template <class Schema, class Container>
Error ProtoKelCodec::encode(typename Message<Schema, Container>::Reader reader,
Buffer &buffer) {
BufferView view{buffer};
error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
buffer &buffer) {
buffer_view view{buffer};
ProtoKelCodec::PacketLengthT packet_length =
ProtoKelEncodeImpl<Message<Schema, Container>>::size(reader);
ProtoKelEncodeImpl<message<Schema, Container>>::size(reader);
// Check the size of the packet for the first
// message length description
Error error = view.writeRequireLength(packet_length +
error err = view.write_require_length(packet_length +
sizeof(ProtoKelCodec::PacketLengthT));
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
{
Error error = StreamValue<ProtoKelCodec::PacketLengthT>::encode(
error err = stream_value<ProtoKelCodec::PacketLengthT>::encode(
packet_length, view);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
{
Error error = ProtoKelEncodeImpl<Message<Schema, Container>>::encode(
error err = ProtoKelEncodeImpl<message<Schema, Container>>::encode(
reader, view);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
buffer.writeAdvance(view.writeOffset());
return noError();
buffer.write_advance(view.write_offset());
return no_error();
}
template <class Schema, class Container>
Error ProtoKelCodec::decode(
typename Message<Schema, Container>::Builder builder, Buffer &buffer,
error ProtoKelCodec::decode(
typename message<Schema, Container>::builder builder, buffer &buffer,
const Limits &limits) {
BufferView view{buffer};
buffer_view view{buffer};
ProtoKelCodec::PacketLengthT packet_length = 0;
{
Error error = StreamValue<ProtoKelCodec::PacketLengthT>::decode(
error err = stream_value<ProtoKelCodec::PacketLengthT>::decode(
packet_length, view);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
if (packet_length > limits.packet_size) {
return criticalError(
return critical_error(
[packet_length]() {
return std::string{"Packet size too big: "} +
std::to_string(packet_length);
@ -562,21 +562,21 @@ Error ProtoKelCodec::decode(
}
{
Error error = ProtoKelDecodeImpl<Message<Schema, Container>>::decode(
error err = ProtoKelDecodeImpl<message<Schema, Container>>::decode(
builder, view);
if (error.failed()) {
return error;
if (err.failed()) {
return err;
}
}
{
if (ProtoKelEncodeImpl<Message<Schema, Container>>::size(
builder.asReader()) != packet_length) {
return criticalError("Bad packet format");
if (ProtoKelEncodeImpl<message<Schema, Container>>::size(
builder.as_reader()) != packet_length) {
return critical_error("Bad packet format");
}
}
buffer.readAdvance(view.readOffset());
return noError();
buffer.read_advance(view.read_offset());
return no_error();
}
} // namespace saw

10
source/forstio/schema.h
View File

@ -6,7 +6,7 @@
namespace saw {
namespace schema {
template <typename T, StringLiteral Literal> struct NamedMember {};
template <typename T, string_literal Literal> struct NamedMember {};
template <typename... T> struct Struct {
static_assert(
@ -14,7 +14,7 @@ template <typename... T> struct Struct {
"This schema template doesn't support this type of template argument");
};
template <typename... V, StringLiteral... K>
template <typename... V, string_literal... K>
struct Struct<NamedMember<V, K>...> {};
template <typename... T> struct Union {
@ -23,7 +23,7 @@ template <typename... T> struct Union {
"This schema template doesn't support this type of template argument");
};
template <typename... V, StringLiteral... K>
template <typename... V, string_literal... K>
struct Union<NamedMember<V, K>...> {};
template <typename T> struct Array {};
@ -60,7 +60,7 @@ using Float64 = Primitive<FloatingPoint, 8>;
/**
* Classes enabling Rpc calls
*/
template <class Request, class Response, StringLiteral Literal>
template <class Request, class Response, string_literal Literal>
struct Function {};
template <class... T> struct Interface {
@ -69,7 +69,7 @@ template <class... T> struct Interface {
"This schema template doesn't support this type of template argument");
};
template <class... Request, class... Response, StringLiteral... Literal>
template <class... Request, class... Response, string_literal... Literal>
struct Interface<Function<Request, Response, Literal>...> {};
} // namespace schema

70
source/forstio/stream_endian.h
View File

@ -15,16 +15,16 @@ namespace saw {
* platform independent. So it does not matter if the memory layout is
* little endian or big endian
*/
template <typename T, size_t size = sizeof(T)> class ShiftStreamValue;
template <typename T, size_t size = sizeof(T)> class shift_stream_value;
template <typename T> class ShiftStreamValue<T, 1> {
template <typename T> class shift_stream_value<T, 1> {
public:
inline static Error decode(T &val, Buffer &buffer) {
inline static error decode(T &val, buffer &buffer) {
uint8_t &raw = reinterpret_cast<uint8_t &>(val);
return buffer.pop(raw, sizeof(T));
}
inline static Error encode(const T &val, Buffer &buffer) {
inline static error encode(const T &val, buffer &buffer) {
const uint8_t &raw = reinterpret_cast<const uint8_t &>(val);
return buffer.push(raw, sizeof(T));
}
@ -32,11 +32,11 @@ public:
inline static size_t size() { return sizeof(T); }
};
template <typename T> class ShiftStreamValue<T, 2> {
template <typename T> class shift_stream_value<T, 2> {
public:
inline static Error decode(T &val, Buffer &buffer) {
if (buffer.readCompositeLength() < sizeof(T)) {
return recoverableError("Buffer too small");
inline static error decode(T &val, buffer &buffer) {
if (buffer.read_composite_length() < sizeof(T)) {
return recoverable_error("Buffer too small");
}
uint16_t raw = 0;
@ -45,13 +45,13 @@ public:
raw |= (static_cast<uint16_t>(buffer.read(i)) << (i * 8));
}
memcpy(&val, &raw, sizeof(T));
buffer.readAdvance(sizeof(T));
buffer.read_advance(sizeof(T));
return noError();
return no_error();
}
inline static Error encode(const T &val, Buffer &buffer) {
Error error = buffer.writeRequireLength(sizeof(T));
inline static error encode(const T &val, buffer &buffer) {
error error = buffer.write_require_length(sizeof(T));
if (error.failed()) {
return error;
}
@ -63,18 +63,18 @@ public:
buffer.write(i) = raw >> (i * 8);
}
buffer.writeAdvance(sizeof(T));
return noError();
buffer.write_advance(sizeof(T));
return no_error();
}
inline static size_t size() { return sizeof(T); }
};
template <typename T> class ShiftStreamValue<T, 4> {
template <typename T> class shift_stream_value<T, 4> {
public:
inline static Error decode(T &val, Buffer &buffer) {
if (buffer.readCompositeLength() < sizeof(T)) {
return recoverableError("Buffer too small");
inline static error decode(T &val, buffer &buffer) {
if (buffer.read_composite_length() < sizeof(T)) {
return recoverable_error("Buffer too small");
}
uint32_t raw = 0;
@ -83,13 +83,13 @@ public:
raw |= (static_cast<uint32_t>(buffer.read(i)) << (i * 8));
}
memcpy(&val, &raw, sizeof(T));
buffer.readAdvance(sizeof(T));
buffer.read_advance(sizeof(T));
return noError();
return no_error();
}
inline static Error encode(const T &val, Buffer &buffer) {
Error error = buffer.writeRequireLength(sizeof(T));
inline static error encode(const T &val, buffer &buffer) {
error error = buffer.write_require_length(sizeof(T));
if (error.failed()) {
return error;
}
@ -101,18 +101,18 @@ public:
buffer.write(i) = raw >> (i * 8);
}
buffer.writeAdvance(sizeof(T));
return noError();
buffer.write_advance(sizeof(T));
return no_error();
}
inline static size_t size() { return sizeof(T); }
};
template <typename T> class ShiftStreamValue<T, 8> {
template <typename T> class shift_stream_value<T, 8> {
public:
inline static Error decode(T &val, Buffer &buffer) {
if (buffer.readCompositeLength() < sizeof(T)) {
return recoverableError("Buffer too small");
inline static error decode(T &val, buffer &buffer) {
if (buffer.read_composite_length() < sizeof(T)) {
return recoverable_error("Buffer too small");
}
uint64_t raw = 0;
@ -122,13 +122,13 @@ public:
}
memcpy(&val, &raw, sizeof(T));
buffer.readAdvance(sizeof(T));
buffer.read_advance(sizeof(T));
return noError();
return no_error();
}
inline static Error encode(const T &val, Buffer &buffer) {
Error error = buffer.writeRequireLength(sizeof(T));
inline static error encode(const T &val, buffer &buffer) {
error error = buffer.write_require_length(sizeof(T));
if (error.failed()) {
return error;
}
@ -140,13 +140,13 @@ public:
buffer.write(i) = raw >> (i * 8);
}
buffer.writeAdvance(sizeof(T));
return noError();
buffer.write_advance(sizeof(T));
return no_error();
}
inline static size_t size() { return sizeof(T); }
};
template <typename T> using StreamValue = ShiftStreamValue<T>;
template <typename T> using stream_value = shift_stream_value<T>;
} // namespace saw

12
source/forstio/string_literal.h
View File

@ -9,9 +9,9 @@ namespace saw {
* literal. It guarantees compile time uniqueness and thus allows using strings
* in template parameters.
*/
template <class CharT, size_t N> class StringLiteral {
template <class CharT, size_t N> class string_literal {
public:
constexpr StringLiteral(const CharT (&input)[N]) noexcept {
constexpr string_literal(const CharT (&input)[N]) noexcept {
for (size_t i = 0; i < N; ++i) {
data[i] = input[i];
}
@ -24,17 +24,17 @@ public:
}
constexpr bool
operator==(const StringLiteral<CharT, N> &) const noexcept = default;
operator==(const string_literal<CharT, N> &) const noexcept = default;
template <class CharTR, size_t NR>
constexpr bool
operator==(const StringLiteral<CharTR, NR> &) const noexcept {
operator==(const string_literal<CharTR, NR> &) const noexcept {
return false;
}
};
template <typename T, T... Chars>
constexpr StringLiteral<T, sizeof...(Chars)> operator""_key() {
return StringLiteral<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
constexpr string_literal<T, sizeof...(Chars)> operator""_key() {
return string_literal<T, sizeof...(Chars) + 1u>{Chars..., '\0'};
}
} // namespace saw

88
source/forstio/tls/tls.cpp
View File

@ -38,60 +38,60 @@ Tls::~Tls() {}
Tls::Impl &Tls::getImpl() { return *impl; }
class TlsIoStream final : public IoStream {
class TlsIoStream final : public io_stream {
private:
Own<IoStream> internal;
own<io_stream> internal;
gnutls_session_t session_handle;
public:
TlsIoStream(Own<IoStream> internal_) : internal{std::move(internal_)} {}
TlsIoStream(own<io_stream> internal_) : internal{std::move(internal_)} {}
~TlsIoStream() { gnutls_bye(session_handle, GNUTLS_SHUT_RDWR); }
ErrorOr<size_t> read(void *buffer, size_t length) override {
error_or<size_t> read(void *buffer, size_t length) override {
ssize_t size = gnutls_record_recv(session_handle, buffer, length);
if (size < 0) {
if(gnutls_error_is_fatal(size) == 0){
return recoverableError([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
return recoverable_error([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
}else{
return criticalError([size](){return std::string{"Read critical Error "}+std::string{gnutls_strerror(size)};}, "Error read c");
return critical_error([size](){return std::string{"Read critical Error "}+std::string{gnutls_strerror(size)};}, "Error read c");
}
}else if(size == 0){
return criticalError("Disconnected");
return critical_error("Disconnected");
}
return static_cast<size_t>(length);
}
Conveyor<void> readReady() override { return internal->readReady(); }
conveyor<void> read_ready() override { return internal->read_ready(); }
Conveyor<void> onReadDisconnected() override {
return internal->onReadDisconnected();
conveyor<void> on_read_disconnected() override {
return internal->on_read_disconnected();
}
ErrorOr<size_t> write(const void *buffer, size_t length) override {
error_or<size_t> write(const void *buffer, size_t length) override {
ssize_t size = gnutls_record_send(session_handle, buffer, length);
if(size < 0){
if(gnutls_error_is_fatal(size) == 0){
return recoverableError([size](){return std::string{"Write recoverable Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write r");
return recoverable_error([size](){return std::string{"Write recoverable Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write r");
}else{
return criticalError([size](){return std::string{"Write critical Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write c");
return critical_error([size](){return std::string{"Write critical Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write c");
}
}
return static_cast<size_t>(size);
}
Conveyor<void> writeReady() override { return internal->writeReady(); }
conveyor<void> write_ready() override { return internal->write_ready(); }
gnutls_session_t &session() { return session_handle; }
};
TlsServer::TlsServer(Own<Server> srv) : internal{std::move(srv)} {}
TlsServer::TlsServer(own<server> srv) : internal{std::move(srv)} {}
Conveyor<Own<IoStream>> TlsServer::accept() {
SAW_ASSERT(internal) { return Conveyor<Own<IoStream>>{FixVoid<Own<IoStream>>{nullptr}}; }
return internal->accept().then([](Own<IoStream> stream) -> Own<IoStream> {
conveyor<own<io_stream>> TlsServer::accept() {
SAW_ASSERT(internal) { return conveyor<own<io_stream>>{fix_void<own<io_stream>>{nullptr}}; }
return internal->accept().then([](own<io_stream> stream) -> own<io_stream> {
/// @todo handshake
@ -105,14 +105,14 @@ namespace {
*/
struct TlsClientStreamHelper {
public:
Own<ConveyorFeeder<Own<IoStream>>> feeder;
ConveyorSink connection_sink;
ConveyorSink stream_reader;
ConveyorSink stream_writer;
own<conveyor_feeder<own<io_stream>>> feeder;
conveyor_sink connection_sink;
conveyor_sink stream_reader;
conveyor_sink stream_writer;
Own<TlsIoStream> stream = nullptr;
own<TlsIoStream> stream = nullptr;
public:
TlsClientStreamHelper(Own<ConveyorFeeder<Own<IoStream>>> f):
TlsClientStreamHelper(own<conveyor_feeder<own<io_stream>>> f):
feeder{std::move(f)}
{}
@ -121,11 +121,11 @@ public:
return;
}
stream_reader = stream->readReady().then([this](){
stream_reader = stream->read_ready().then([this](){
turn();
}).sink();
stream_writer = stream->writeReady().then([this](){
stream_writer = stream->write_ready().then([this](){
turn();
}).sink();
}
@ -145,7 +145,7 @@ public:
} while ( (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) && gnutls_error_is_fatal(ret) == 0);
if(gnutls_error_is_fatal(ret)){
feeder->fail(criticalError("Couldn't create Tls connection"));
feeder->fail(critical_error("Couldn't create Tls connection"));
stream = nullptr;
}else if(ret == GNUTLS_E_SUCCESS){
feeder->feed(std::move(stream));
@ -155,20 +155,20 @@ public:
};
}
Own<Server> TlsNetwork::listen(NetworkAddress& address) {
own<server> TlsNetwork::listen(network_address& address) {
return heap<TlsServer>(internal.listen(address));
}
Conveyor<Own<IoStream>> TlsNetwork::connect(NetworkAddress& address) {
conveyor<own<io_stream>> TlsNetwork::connect(network_address& address) {
// Helper setups
auto caf = newConveyorAndFeeder<Own<IoStream>>();
Own<TlsClientStreamHelper> helper = heap<TlsClientStreamHelper>(std::move(caf.feeder));
auto caf = new_conveyor_and_feeder<own<io_stream>>();
own<TlsClientStreamHelper> helper = heap<TlsClientStreamHelper>(std::move(caf.feeder));
TlsClientStreamHelper* hlp_ptr = helper.get();
// Conveyor entangled structure
auto prim_conv = internal.connect(address).then([this, hlp_ptr, addr = address.address()](
Own<IoStream> stream) -> ErrorOr<void> {
IoStream* inner_stream = stream.get();
own<io_stream> stream) -> error_or<void> {
io_stream* inner_stream = stream.get();
auto tls_stream = heap<TlsIoStream>(std::move(stream));
auto &session = tls_stream->session();
@ -201,20 +201,20 @@ Conveyor<Own<IoStream>> TlsNetwork::connect(NetworkAddress& address) {
return caf.conveyor.attach(std::move(helper));
}
Own<Datagram> TlsNetwork::datagram(NetworkAddress& address){
own<datagram> TlsNetwork::datagram(network_address& address){
///@unimplemented
return nullptr;
}
static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
size_t size) {
IoStream *stream = reinterpret_cast<IoStream *>(p);
io_stream *stream = reinterpret_cast<io_stream *>(p);
if (!stream) {
return -1;
}
ErrorOr<size_t> length = stream->write(data, size);
if (length.isError() || !length.isValue()) {
error_or<size_t> length = stream->write(data, size);
if (length.is_error() || !length.is_value()) {
return -1;
}
@ -222,29 +222,29 @@ static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
}
static ssize_t forst_tls_pull_func(gnutls_transport_ptr_t p, void *data, size_t size) {
IoStream *stream = reinterpret_cast<IoStream *>(p);
io_stream *stream = reinterpret_cast<io_stream *>(p);
if (!stream) {
return -1;
}
ErrorOr<size_t> length = stream->read(data, size);
if (length.isError() || !length.isValue()) {
error_or<size_t> length = stream->read(data, size);
if (length.is_error() || !length.is_value()) {
return -1;
}
return static_cast<ssize_t>(length.value());
}
TlsNetwork::TlsNetwork(Tls& tls_, Network &network) : tls{tls_},internal{network} {}
TlsNetwork::TlsNetwork(Tls& tls_, network &network) : tls{tls_},internal{network} {}
Conveyor<Own<NetworkAddress>> TlsNetwork::resolveAddress(const std::string &addr,
conveyor<own<network_address>> TlsNetwork::resolve_address(const std::string &addr,
uint16_t port) {
/// @todo tls server name needed. Check validity. Won't matter later on, because gnutls should fail anyway. But
/// it's better to find the error source sooner rather than later
return internal.resolveAddress(addr, port);
return internal.resolve_address(addr, port);
}
std::optional<Own<TlsNetwork>> setupTlsNetwork(Network &network) {
std::optional<own<TlsNetwork>> setupTlsNetwork(network &network) {
return std::nullopt;
}
} // namespace saw

28
source/forstio/tls/tls.h
View File

@ -9,30 +9,30 @@
namespace saw {
class Tls;
class TlsServer final : public Server {
class TlsServer final : public server {
private:
Own<Server> internal;
own<server> internal;
public:
TlsServer(Own<Server> srv);
TlsServer(own<server> srv);
Conveyor<Own<IoStream>> accept() override;
conveyor<own<io_stream>> accept() override;
};
class TlsNetwork final : public Network {
class TlsNetwork final : public network {
private:
Tls& tls;
Network &internal;
network &internal;
public:
TlsNetwork(Tls& tls_, Network &network_);
TlsNetwork(Tls& tls_, network &network_);
Conveyor<Own<NetworkAddress>> resolveAddress(const std::string &addr, uint16_t port = 0) override;
conveyor<own<network_address>> resolve_address(const std::string &addr, uint16_t port = 0) override;
Own<Server> listen(NetworkAddress& address) override;
own<server> listen(network_address& address) override;
Conveyor<Own<IoStream>> connect(NetworkAddress& address) override;
conveyor<own<io_stream>> connect(network_address& address) override;
Own<Datagram> datagram(NetworkAddress& address) override;
own<class datagram> datagram(network_address& address) override;
};
/**
@ -42,7 +42,7 @@ public:
class Tls {
private:
class Impl;
Own<Impl> impl;
own<Impl> impl;
public:
Tls();
~Tls();
@ -58,13 +58,13 @@ public:
Version version;
};
Network& tlsNetwork();
network& tlsNetwork();
Impl &getImpl();
private:
Options options;
};
std::optional<Own<TlsNetwork>> setupTlsNetwork(Network &network);
std::optional<own<TlsNetwork>> setupTlsNetwork(network &network);
} // namespace saw

136
test/async.cpp
View File

@ -6,38 +6,38 @@ namespace {
SAW_TEST("Async Immediate"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
Conveyor<size_t> number{5};
conveyor<size_t> number{5};
Conveyor<bool> is_number = number.then([](size_t val){
conveyor<bool> is_number = number.then([](size_t val){
return val == 5;
});
wait_scope.poll();
ErrorOr<bool> error_or_number = is_number.take();
error_or<bool> error_or_number = is_number.take();
SAW_EXPECT(!error_or_number.isError(), error_or_number.error().message());
SAW_EXPECT(error_or_number.isValue(), "Return is not a value");
SAW_EXPECT(!error_or_number.is_error(), error_or_number.error().message());
SAW_EXPECT(error_or_number.is_value(), "Return is not a value");
SAW_EXPECT(error_or_number.value(), "Value is not 5");
}
SAW_TEST("Async Adapt"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto feeder_conveyor = newConveyorAndFeeder<size_t>();
auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
feeder_conveyor.feeder->feed(5);
ErrorOr<size_t> foo = feeder_conveyor.conveyor.take();
error_or<size_t> foo = feeder_conveyor.conveyor.take();
SAW_EXPECT(!foo.isError(), foo.error().message());
SAW_EXPECT(foo.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), foo.error().message());
SAW_EXPECT(foo.is_value(), "Return is not a value");
SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));
}
@ -45,72 +45,72 @@ SAW_TEST("Async Adapt"){
SAW_TEST("Async Adapt Multiple"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto feeder_conveyor = newConveyorAndFeeder<size_t>();
auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
feeder_conveyor.feeder->feed(5);
ErrorOr<size_t> foo = feeder_conveyor.conveyor.take();
error_or<size_t> foo = feeder_conveyor.conveyor.take();
SAW_EXPECT(!foo.isError(), foo.error().message());
SAW_EXPECT(foo.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), foo.error().message());
SAW_EXPECT(foo.is_value(), "Return is not a value");
SAW_EXPECT(foo.value() == 5, "Values not 5, but " + std::to_string(foo.value()));
feeder_conveyor.feeder->feed(10);
ErrorOr<size_t> bar = feeder_conveyor.conveyor.take();
error_or<size_t> bar = feeder_conveyor.conveyor.take();
SAW_EXPECT(!foo.isError(), bar.error().message());
SAW_EXPECT(bar.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), bar.error().message());
SAW_EXPECT(bar.is_value(), "Return is not a value");
SAW_EXPECT(bar.value() == 10, "Values not 10, but " + std::to_string(bar.value()));
feeder_conveyor.feeder->feed(2);
feeder_conveyor.feeder->feed(4234);
ErrorOr<size_t> a = feeder_conveyor.conveyor.take();
ErrorOr<size_t> b = feeder_conveyor.conveyor.take();
error_or<size_t> a = feeder_conveyor.conveyor.take();
error_or<size_t> b = feeder_conveyor.conveyor.take();
SAW_EXPECT(!foo.isError(), a.error().message());
SAW_EXPECT(a.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), a.error().message());
SAW_EXPECT(a.is_value(), "Return is not a value");
SAW_EXPECT(a.value() == 2, "Values not 2, but " + std::to_string(a.value()));
SAW_EXPECT(!foo.isError(), b.error().message());
SAW_EXPECT(b.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), b.error().message());
SAW_EXPECT(b.is_value(), "Return is not a value");
SAW_EXPECT(b.value() == 4234, "Values not 4234, but " + std::to_string(b.value()));
}
SAW_TEST("Async Conversion"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto feeder_conveyor = newConveyorAndFeeder<size_t>();
auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
Conveyor<std::string> string_conveyor = feeder_conveyor.conveyor.then([](size_t foo){
conveyor<std::string> string_conveyor = feeder_conveyor.conveyor.then([](size_t foo){
return std::to_string(foo);
});
feeder_conveyor.feeder->feed(10);
ErrorOr<std::string> foo = string_conveyor.take();
error_or<std::string> foo = string_conveyor.take();
SAW_EXPECT(!foo.isError(), foo.error().message());
SAW_EXPECT(foo.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), foo.error().message());
SAW_EXPECT(foo.is_value(), "Return is not a value");
SAW_EXPECT(foo.value() == std::to_string(10), "Values is not 10, but " + foo.value());
}
SAW_TEST("Async Conversion Multistep"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto feeder_conveyor = newConveyorAndFeeder<size_t>();
auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
Conveyor<bool> conveyor = feeder_conveyor.conveyor.then([](size_t foo){
conveyor<bool> conveyor = feeder_conveyor.conveyor.then([](size_t foo){
return std::to_string(foo);
}).then([](const std::string& value){
return value != "10";
@ -120,29 +120,29 @@ SAW_TEST("Async Conversion Multistep"){
feeder_conveyor.feeder->feed(10);
ErrorOr<bool> foo = conveyor.take();
error_or<bool> foo = conveyor.take();
SAW_EXPECT(!foo.isError(), foo.error().message());
SAW_EXPECT(foo.isValue(), "Return is not a value");
SAW_EXPECT(!foo.is_error(), foo.error().message());
SAW_EXPECT(foo.is_value(), "Return is not a value");
SAW_EXPECT(foo.value(), "Values is not true");
}
SAW_TEST("Async Scheduling"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto feeder_conveyor = newConveyorAndFeeder<size_t>();
auto feeder_conveyor = new_conveyor_and_feeder<size_t>();
/*
* Attach node test data
*/
Own<size_t> counter = heap<size_t>();
own<size_t> counter = heap<size_t>();
size_t* ctr_ptr = counter.get();
*ctr_ptr = 0;
Conveyor<std::string> string_conveyor = feeder_conveyor.conveyor
conveyor<std::string> string_conveyor = feeder_conveyor.conveyor
.then([ctr_ptr](size_t foo){
return std::to_string(foo + ++(*ctr_ptr));
})
@ -163,34 +163,34 @@ SAW_TEST("Async Scheduling"){
wait_scope.poll();
ErrorOr<std::string> foo_10 = string_conveyor.take();
error_or<std::string> foo_10 = string_conveyor.take();
SAW_EXPECT(!foo_10.isError(), foo_10.error().message());
SAW_EXPECT(foo_10.isValue(), "Return is not a value");
SAW_EXPECT(!foo_10.is_error(), foo_10.error().message());
SAW_EXPECT(foo_10.is_value(), "Return is not a value");
SAW_EXPECT(foo_10.value() == (std::string{"pre"} + std::to_string(11) + std::string{"post"}), "Values is not pre11post, but " + foo_10.value());
ErrorOr<std::string> foo_20 = string_conveyor.take();
error_or<std::string> foo_20 = string_conveyor.take();
SAW_EXPECT(!foo_20.isError(), foo_20.error().message());
SAW_EXPECT(foo_20.isValue(), "Return is not a value");
SAW_EXPECT(!foo_20.is_error(), foo_20.error().message());
SAW_EXPECT(foo_20.is_value(), "Return is not a value");
SAW_EXPECT(foo_20.value() == (std::string{"pre"} + std::to_string(22) + std::string{"post"}), "Values is not pre22post, but " + foo_20.value());
ErrorOr<std::string> foo_30 = string_conveyor.take();
error_or<std::string> foo_30 = string_conveyor.take();
SAW_EXPECT(!foo_30.isError(), foo_30.error().message());
SAW_EXPECT(foo_30.isValue(), "Return is not a value");
SAW_EXPECT(!foo_30.is_error(), foo_30.error().message());
SAW_EXPECT(foo_30.is_value(), "Return is not a value");
SAW_EXPECT(foo_30.value() == (std::string{"pre"} + std::to_string(33) + std::string{"post"}), "Values is not pre33post, but " + foo_30.value());
}
SAW_TEST("Async Detach"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
int num = 0;
Conveyor<int>{10}.then([&num](int bar){
conveyor<int>{10}.then([&num](int bar){
num = bar;
}).detach();
@ -202,14 +202,14 @@ SAW_TEST("Async Detach"){
SAW_TEST("Async Merge"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto cam = Conveyor<int>{10}.merge();
auto cam = conveyor<int>{10}.merge();
cam.second.attach(Conveyor<int>{11});
cam.second.attach(conveyor<int>{11});
cam.second.attach(Conveyor<int>{14});
cam.second.attach(conveyor<int>{14});
size_t elements_passed = 0;
bool wrong_value = false;
@ -231,12 +231,12 @@ SAW_TEST("Async Merge"){
SAW_TEST("Async Connect"){
using namespace saw;
EventLoop event_loop;
WaitScope wait_scope{event_loop};
event_loop event_loop;
wait_scope wait_scope{event_loop};
auto caf1 = newConveyorAndFeeder<int>();
auto caf1 = new_conveyor_and_feeder<int>();
auto caf2 = newConveyorAndFeeder<float>();
auto caf2 = new_conveyor_and_feeder<float>();
bool val_passed = false;
auto conveyor1 = caf1.conveyor.then([&val_passed](int val) -> float{

4
test/message.cpp
View File

@ -88,7 +88,7 @@ SAW_TEST("Message Struct"){
using TestArray = schema::Array<schema::UInt32>;
void arrayCheck(saw::Message<TestArray>::Builder builder){
void arrayCheck(saw::message<TestArray>::builder builder){
auto one = builder.init(0);
auto two = builder.init(1);
auto three = builder.init(2);
@ -97,7 +97,7 @@ void arrayCheck(saw::Message<TestArray>::Builder builder){
two.set(45);
three.set(1230);
auto reader = builder.asReader();
auto reader = builder.as_reader();
SAW_EXPECT(reader.get(0).get() == 24 && reader.get(1).get() == 45 && reader.get(2).get(), "Wrong values");
}

78
test/proto_kel.cpp
View File

@ -32,13 +32,13 @@ SAW_TEST("Primitive Encoding"){
builder.set(value);
RingBuffer temp_buffer;
ring_buffer temp_buffer;
ProtoKelCodec codec;
Error error = codec.encode<TestSize>(root.read(), temp_buffer);
error err = codec.encode<TestSize>(root.read(), temp_buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(temp_buffer.readCompositeLength() == (sizeof(value)+sizeof(ProtoKelCodec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.readCompositeLength()));
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(temp_buffer.read_composite_length() == (sizeof(value)+sizeof(ProtoKelCodec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.read_composite_length()));
constexpr size_t pkt_shift = sizeof(ProtoKelCodec::PacketLengthT);
SAW_EXPECT(temp_buffer[pkt_shift] == 5 && temp_buffer[pkt_shift+1] == 0 && temp_buffer[pkt_shift+2] == 0 && temp_buffer[pkt_shift+3] == 0, "Wrong encoded values");
}
@ -54,14 +54,14 @@ SAW_TEST("List Encoding"){
auto second = builder.init<1>();
second.set(43871);
RingBuffer buffer;
ring_buffer buffer;
ProtoKelCodec codec;
Error error = codec.encode<TestTuple>(root.read(), buffer);
error err = codec.encode<TestTuple>(root.read(), buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(buffer.readCompositeLength() == 14, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
SAW_EXPECT("06 00 00 00\n00 00 00 00\nbf 94 20 00\n5f ab" == buffer.toHex(), "Not equal encoding\n"+buffer.toHex());
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(buffer.read_composite_length() == 14, "Bad Size: " + std::to_string(buffer.read_composite_length()));
SAW_EXPECT("06 00 00 00\n00 00 00 00\nbf 94 20 00\n5f ab" == buffer.to_hex(), "Not equal encoding\n"+buffer.to_hex());
}
SAW_TEST("Struct Encoding"){
@ -80,15 +80,15 @@ SAW_TEST("Struct Encoding"){
auto string_name = builder.init<"test_name">();
string_name.set("test_name");
RingBuffer buffer;
ring_buffer buffer;
ProtoKelCodec codec;
Error error = codec.encode<TestStruct>(builder.asReader(), buffer);
error err = codec.encode<TestStruct>(builder.as_reader(), buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(buffer.readCompositeLength() == 40, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(buffer.read_composite_length() == 40, "Bad Size: " + std::to_string(buffer.read_composite_length()));
SAW_EXPECT("20 00 00 00\n00 00 00 00\n17 00 00 00\n03 00 00 00\n00 00 00 00\n66 6f 6f 09\n00 00 00 00\n00 00 00 74\n65 73 74 5f\n6e 61 6d 65"
== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
}
SAW_TEST("Union Encoding"){
@ -100,15 +100,15 @@ SAW_TEST("Union Encoding"){
auto test_uint = builder.init<"test_uint">();
test_uint.set(23);
RingBuffer buffer;
ring_buffer buffer;
ProtoKelCodec codec;
Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(buffer.readCompositeLength() == 16, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(buffer.read_composite_length() == 16, "Bad Size: " + std::to_string(buffer.read_composite_length()));
SAW_EXPECT("08 00 00 00\n00 00 00 00\n00 00 00 00\n17 00 00 00"
== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
}
{
auto root = heapMessageRoot<TestUnion>();
@ -117,15 +117,15 @@ SAW_TEST("Union Encoding"){
auto test_string = builder.init<"test_string">();
test_string.set("foo");
RingBuffer buffer;
ring_buffer buffer;
ProtoKelCodec codec;
Error error = codec.encode<TestUnion>(builder.asReader(), buffer);
error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(buffer.readCompositeLength() == 23, "Bad Size: " + std::to_string(buffer.readCompositeLength()));
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(buffer.read_composite_length() == 23, "Bad Size: " + std::to_string(buffer.read_composite_length()));
SAW_EXPECT("0f 00 00 00\n00 00 00 00\n01 00 00 00\n03 00 00 00\n00 00 00 00\n66 6f 6f"
== buffer.toHex(), "Not equal encoding:\n"+buffer.toHex());
== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
}
}
@ -133,7 +133,7 @@ SAW_TEST("Tuple Decoding"){
using namespace saw;
const uint8_t buffer_raw[] = {0x06, 0, 0, 0, 0, 0, 0, 0, 0xbf, 0x94, 0x20, 0x00, 0x5f, 0xab};
RingBuffer buffer;
ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec;
@ -141,10 +141,10 @@ SAW_TEST("Tuple Decoding"){
auto root = heapMessageRoot<TestTuple>();
auto builder = root.build();
Error error = codec.decode<TestTuple>(builder, buffer);
SAW_EXPECT(!error.failed(), error.message());
error err = codec.decode<TestTuple>(builder, buffer);
SAW_EXPECT(!err.failed(), err.message());
auto reader = builder.asReader();
auto reader = builder.as_reader();
auto first = reader.get<0>();
auto second = reader.get<1>();
@ -156,7 +156,7 @@ SAW_TEST("Struct Decoding"){
using namespace saw;
const uint8_t buffer_raw[] = {0x20,0,0,0,0,0,0,0,0x17,0,0,0,0x03,0,0,0,0,0,0,0,0x66,0x6f,0x6f,0x09,0,0,0,0,0,0,0,0x74,0x65,0x73,0x74,0x5f,0x6e,0x61,0x6d,0x65};
RingBuffer buffer;
ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec;
@ -164,14 +164,14 @@ SAW_TEST("Struct Decoding"){
auto root = heapMessageRoot<TestStruct>();
auto builder = root.build();
Error error = codec.decode<TestStruct>(builder, buffer);
auto reader = builder.asReader();
error err = codec.decode<TestStruct>(builder, buffer);
auto reader = builder.as_reader();
auto foo_string = reader.get<"test_string">();
auto test_uint = reader.get<"test_uint">();
auto test_name = reader.get<"test_name">();
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(foo_string.get() == "foo" && test_uint.get() == 23 && test_name.get() == "test_name", "Values not correctly decoded");
}
@ -179,18 +179,18 @@ SAW_TEST("Union Decoding"){
using namespace saw;
const uint8_t buffer_raw[] = {0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x66,0x6f,0x6f};
RingBuffer buffer;
ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec;
auto root = heapMessageRoot<TestUnion>();
auto builder = root.build();
auto reader = builder.asReader();
auto reader = builder.as_reader();
Error error = codec.decode<TestUnion>(builder, buffer);
error err = codec.decode<TestUnion>(builder, buffer);
SAW_EXPECT(!error.failed(), error.message());
SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(reader.hasAlternative<"test_string">(), "Wrong union value");
auto str_rd = reader.get<"test_string">();
SAW_EXPECT(str_rd.get() == "foo", "Wrong value: " + std::string{str_rd.get()});
@ -218,10 +218,10 @@ SAW_TEST("Array Encoding"){
two.init<"test_string">().set("bar");
two.init<"test_name">().set("Bravo");
RingBuffer buffer;
ring_buffer buffer;
Error error = codec.encode<TestArrayStruct>(root.read(), buffer);
error err = codec.encode<TestArrayStruct>(root.read(), buffer);
SAW_EXPECT(!error.failed(), "Error occured");
SAW_EXPECT(!err.failed(), "Error occured");
}
}