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

renamed structs, methods and functions

fb-mini-snake
Claudius Holeksa 2023-01-07 23:52:07 +01:00
parent a83826552e
commit 4f10da77eb
15 changed files with 305 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-tidy
View File

@ -1,6 +1,9 @@
Checks: '-*,readability-identifier-naming' Checks: '-*,readability-identifier-naming'
CheckOptions: CheckOptions:
- { key: readability-identifier-naming.PrivateMemberSuffix, value: "_" } - { key: readability-identifier-naming.PrivateMemberSuffix, value: "_" }
- { key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true }
- { key: readability-identifier-naming.ProtectedMemberSuffix, value: "_" } - { key: readability-identifier-naming.ProtectedMemberSuffix, value: "_" }
- { key: readability-identifier-naming.ClassCase, value: "lower_case" } - { key: readability-identifier-naming.ClassCase, value: "lower_case" }
- { key: readability-identifier-naming.StructCase, value: "lower_case" } - { key: readability-identifier-naming.StructCase, value: "lower_case" }
- { key: readability-identifier-naming.FunctionCase, value: "lower_case" }
- { key: readability-identifier-naming.MethodCase, value: "lower_case" }

41
driver/io_unix.cpp
View File

@ -129,7 +129,7 @@ unix_datagram::unix_datagram(unix_event_port &event_port, int file_descriptor,
: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {} : i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
namespace { namespace {
ssize_t unixReadMsg(int fd, void *buffer, size_t length) { ssize_t unix_read_msg(int fd, void *buffer, size_t length) {
struct ::sockaddr_storage their_addr; struct ::sockaddr_storage their_addr;
socklen_t addr_len = sizeof(sockaddr_storage); socklen_t addr_len = sizeof(sockaddr_storage);
return ::recvfrom(fd, buffer, length, 0, return ::recvfrom(fd, buffer, length, 0,
@ -137,15 +137,15 @@ ssize_t unixReadMsg(int fd, void *buffer, size_t length) {
&addr_len); &addr_len);
} }
ssize_t unixWriteMsg(int fd, const void *buffer, size_t length, ssize_t unix_write_msg(int fd, const void *buffer, size_t length,
::sockaddr *dest_addr, socklen_t dest_addr_len) { ::sockaddr *dest_addr, socklen_t dest_addr_len) {
return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len); return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len);
} }
} // namespace } // namespace
error_or<size_t> unix_datagram::read(void *buffer, size_t length) { error_or<size_t> unix_datagram::read(void *buffer, size_t length) {
ssize_t read_bytes = unixReadMsg(fd(), buffer, length); ssize_t read_bytes = unix_read_msg(fd(), buffer, length);
if (read_bytes > 0) { if (read_bytes > 0) {
return static_cast<size_t>(read_bytes); return static_cast<size_t>(read_bytes);
} }
@ -163,8 +163,8 @@ error_or<size_t> unix_datagram::write(const void *buffer, size_t length,
unix_network_address &unix_dest = static_cast<unix_network_address &>(dest); unix_network_address &unix_dest = static_cast<unix_network_address &>(dest);
socket_address &sock_addr = unix_dest.unix_address(); socket_address &sock_addr = unix_dest.unix_address();
socklen_t sock_addr_length = sock_addr.get_raw_length(); socklen_t sock_addr_length = sock_addr.get_raw_length();
ssize_t write_bytes = unixWriteMsg(fd(), buffer, length, ssize_t write_bytes = unix_write_msg(fd(), buffer, length,
sock_addr.get_raw(), sock_addr_length); sock_addr.get_raw(), sock_addr_length);
if (write_bytes > 0) { if (write_bytes > 0) {
return static_cast<size_t>(write_bytes); return static_cast<size_t>(write_bytes);
} }
@ -192,14 +192,14 @@ void unix_datagram::notify(uint32_t mask) {
} }
namespace { namespace {
bool beginsWith(const std::string_view &viewed, bool begins_with(const std::string_view &viewed,
const std::string_view &begins) { const std::string_view &begins) {
return viewed.size() >= begins.size() && return viewed.size() >= begins.size() &&
viewed.compare(0, begins.size(), begins) == 0; viewed.compare(0, begins.size(), begins) == 0;
} }
std::variant<unix_network_address, unix_network_address *> std::variant<unix_network_address, unix_network_address *>
translateNetworkAddressToUnixNetworkAddress(network_address &addr) { translate_network_address_to_unix_network_address(network_address &addr) {
auto addr_variant = addr.representation(); auto addr_variant = addr.representation();
std::variant<unix_network_address, unix_network_address *> os_addr = std::variant<unix_network_address, unix_network_address *> os_addr =
std::visit( std::visit(
@ -221,7 +221,7 @@ translateNetworkAddressToUnixNetworkAddress(network_address &addr) {
return os_addr; return os_addr;
} }
unix_network_address &translateToUnixAddressRef( unix_network_address &translate_to_unix_address_ref(
std::variant<unix_network_address, unix_network_address *> &addr_variant) { std::variant<unix_network_address, unix_network_address *> &addr_variant) {
return std::visit( return std::visit(
[](auto &arg) -> unix_network_address & { [](auto &arg) -> unix_network_address & {
@ -241,9 +241,10 @@ unix_network_address &translateToUnixAddressRef(
} // namespace } // namespace
own<server> unix_network::listen(network_address &addr) { own<server> unix_network::listen(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); auto unix_addr_storage =
translate_network_address_to_unix_network_address(addr);
unix_network_address &address = unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage); translate_to_unix_address_ref(unix_addr_storage);
assert(address.unix_address_size() > 0); assert(address.unix_address_size() > 0);
if (address.unix_address_size() == 0) { if (address.unix_address_size() == 0) {
@ -274,9 +275,10 @@ own<server> unix_network::listen(network_address &addr) {
} }
conveyor<own<io_stream>> unix_network::connect(network_address &addr) { conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); auto unix_addr_storage =
translate_network_address_to_unix_network_address(addr);
unix_network_address &address = unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage); translate_to_unix_address_ref(unix_addr_storage);
assert(address.unix_address_size() > 0); assert(address.unix_address_size() > 0);
if (address.unix_address_size() == 0) { if (address.unix_address_size() == 0) {
@ -335,9 +337,10 @@ conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
} }
own<datagram> unix_network::datagram(network_address &addr) { own<datagram> unix_network::datagram(network_address &addr) {
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr); auto unix_addr_storage =
translate_network_address_to_unix_network_address(addr);
unix_network_address &address = unix_network_address &address =
translateToUnixAddressRef(unix_addr_storage); translate_to_unix_address_ref(unix_addr_storage);
SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; } SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; }
@ -380,9 +383,9 @@ conveyor<own<network_address>>
unix_network::resolve_address(const std::string &path, uint16_t port_hint) { unix_network::resolve_address(const std::string &path, uint16_t port_hint) {
std::string_view addr_view{path}; std::string_view addr_view{path};
{ {
std::string_view begins_with = "unix:"; std::string_view str_begins_with = "unix:";
if (beginsWith(addr_view, begins_with)) { if (begins_with(addr_view, str_begins_with)) {
addr_view.remove_prefix(begins_with.size()); addr_view.remove_prefix(str_begins_with.size());
} }
} }

8
source/forstio/async.h
View File

@ -291,7 +291,7 @@ template <typename Func> conveyor_result<Func, void> exec_later(Func &&func);
*/ */
template <typename... Args> template <typename... Args>
conveyor<std::tuple<Args...>> conveyor<std::tuple<Args...>>
joinConveyors(std::tuple<conveyor<Args>...> &conveyors); join_conveyors(std::tuple<conveyor<Args>...> &conveyors);
template <typename T> class conveyor_feeder { template <typename T> class conveyor_feeder {
public: public:
@ -460,11 +460,11 @@ public:
void poll(); void poll();
}; };
template <typename Func> conveyor_result<Func, void> yieldNext(Func &&func); template <typename Func> conveyor_result<Func, void> yield_next(Func &&func);
template <typename Func> conveyor_result<Func, void> yieldLater(Func &&func); template <typename Func> conveyor_result<Func, void> yield_later(Func &&func);
template <typename Func> conveyor_result<Func, void> yieldLast(Func &&func); template <typename Func> conveyor_result<Func, void> yield_last(Func &&func);
} // namespace saw } // namespace saw
// Secret stuff // Secret stuff

3
source/forstio/error.h
View File

@ -106,7 +106,8 @@ template <typename T> class error_or final : public error_or_value {
private: private:
std::variant<error, fix_void<T>> value_or_error_; std::variant<error, fix_void<T>> value_or_error_;
static_assert(!std::is_same_v<T, void_t>, "Don't use internal private types"); static_assert(!std::is_same_v<T, void_t>,
"Don't use internal private types");
public: public:
error_or() = default; error_or() = default;

4
source/forstio/io.cpp
View File

@ -10,7 +10,7 @@ async_io_stream::async_io_stream(own<io_stream> str)
.then([this]() { read_stepper_.read_step(*stream_); }) .then([this]() { read_stepper_.read_step(*stream_); })
.sink()}, .sink()},
write_ready_{stream_->write_ready() write_ready_{stream_->write_ready()
.then([this]() { write_stepper_.writeStep(*stream_); }) .then([this]() { write_stepper_.write_step(*stream_); })
.sink()}, .sink()},
read_disconnected_{stream_->on_read_disconnected() read_disconnected_{stream_->on_read_disconnected()
.then([this]() { .then([this]() {
@ -49,7 +49,7 @@ void async_io_stream::write(const void *buffer, size_t length) {
write_stepper_.write_task = write_stepper_.write_task =
write_task_and_step_helper::write_io_task{buffer, length, 0}; write_task_and_step_helper::write_io_task{buffer, length, 0};
write_stepper_.writeStep(*stream_); write_stepper_.write_step(*stream_);
} }
conveyor<size_t> async_io_stream::write_done() { conveyor<size_t> async_io_stream::write_done() {

6
source/forstio/io_helpers.cpp
View File

@ -1,4 +1,4 @@
#include "io_helpers.h" #include "io_helpers.h"
#include "io.h" #include "io.h"
@ -44,7 +44,7 @@ void read_task_and_step_helper::read_step(input_stream &reader) {
} }
} }
void write_task_and_step_helper::writeStep(output_stream &writer) { void write_task_and_step_helper::write_step(output_stream &writer) {
while (write_task.has_value()) { while (write_task.has_value()) {
write_io_task &task = *write_task; write_io_task &task = *write_task;
@ -82,4 +82,4 @@ void write_task_and_step_helper::writeStep(output_stream &writer) {
} }
} }
} // namespace saw } // namespace saw

2
source/forstio/io_helpers.h
View File

@ -48,6 +48,6 @@ public:
own<conveyor_feeder<size_t>> write_done = nullptr; own<conveyor_feeder<size_t>> write_done = nullptr;
public: public:
void writeStep(output_stream &writer); void write_step(output_stream &writer);
}; };
} // namespace saw } // namespace saw

18
source/forstio/io_peer.h
View File

@ -17,13 +17,13 @@ public:
* *
*/ */
streaming_io_peer( streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed, own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
own<async_io_stream> stream, Codec codec, BufferT in, BufferT out); own<async_io_stream> stream, Codec codec, BufferT in, BufferT out);
/** /**
* *
*/ */
streaming_io_peer( streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed, own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
own<async_io_stream> stream); own<async_io_stream> stream);
/** /**
@ -35,26 +35,26 @@ public:
/** /**
* Send a message to the remote peer * Send a message to the remote peer
*/ */
error send(HeapMessageRoot<Outgoing, OutContainer> builder); error send(heap_message_root<Outgoing, OutContainer> builder);
/** /**
* A phantom conveyor feeder. Meant for interfacing with other components * A phantom conveyor feeder. Meant for interfacing with other components
*/ */
conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder(); conveyor_feeder<heap_message_root<Outgoing, OutContainer>> &feeder();
conveyor<void> on_read_disconnected(); conveyor<void> on_read_disconnected();
private: private:
/// @unimplemented /// @unimplemented
class peer_conveyor_feeder final class peer_conveyor_feeder final
: public conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> { : public conveyor_feeder<heap_message_root<Outgoing, OutContainer>> {
public: public:
peer_conveyor_feeder( peer_conveyor_feeder(
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT> &peer_) OutContainer, BufferT> &peer_)
: peer_{peer_} {} : peer_{peer_} {}
void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override { void feed(heap_message_root<Outgoing, OutContainer> &&data) override {
(void)data; (void)data;
} }
@ -70,7 +70,7 @@ private:
}; };
private: private:
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> own<conveyor_feeder<heap_message_root<Incoming, InContainer>>>
incoming_feeder_ = nullptr; incoming_feeder_ = nullptr;
own<async_io_stream> io_stream_; own<async_io_stream> io_stream_;
@ -96,8 +96,8 @@ template <typename Codec, typename Incoming, typename Outgoing,
typename BufferT = ring_buffer> typename BufferT = ring_buffer>
std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer, std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>>, OutContainer, BufferT>>,
conveyor<HeapMessageRoot<Incoming, InContainer>>> conveyor<heap_message_root<Incoming, InContainer>>>
newStreamingIoPeer(own<async_io_stream> stream); new_streaming_io_peer(own<async_io_stream> stream);
} // namespace saw } // namespace saw

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

@ -2,58 +2,59 @@ namespace saw {
template <typename Codec, typename Incoming, typename Outgoing, template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT> typename InContainer, typename OutContainer, typename BufferT>
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>:: streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT>::
streaming_io_peer( streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed, own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
own<async_io_stream> str) own<async_io_stream> str)
: streaming_io_peer{std::move(feed), std::move(str), {}, {}, {}} {} : streaming_io_peer{std::move(feed), std::move(str), {}, {}, {}} {}
template <typename Codec, typename Incoming, typename Outgoing, template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT> typename InContainer, typename OutContainer, typename BufferT>
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>:: streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT>::
streaming_io_peer( streaming_io_peer(
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed, own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
own<async_io_stream> stream, Codec codec, BufferT in, BufferT out) own<async_io_stream> stream, Codec codec, BufferT in, BufferT out)
: incoming_feeder_{std::move(feed)}, : incoming_feeder_{std::move(feed)},
io_stream_{std::move(stream)}, codec_{std::move(codec)}, io_stream_{std::move(stream)}, codec_{std::move(codec)},
in_buffer_{std::move(in)}, out_buffer_{std::move(out)}, in_buffer_{std::move(in)}, out_buffer_{std::move(out)},
sink_read_{io_stream_->read_done() sink_read_{
.then([this](size_t bytes) -> error_or<void> { io_stream_->read_done()
in_buffer_.write_advance(bytes); .then([this](size_t bytes) -> error_or<void> {
in_buffer_.write_advance(bytes);
if (in_buffer_.write_segment_length() == 0) { if (in_buffer_.write_segment_length() == 0) {
return critical_error("Message too long"); return critical_error("Message too long");
} }
io_stream_->read(&in_buffer_.write(), 1, io_stream_->read(&in_buffer_.write(), 1,
in_buffer_.write_segment_length()); in_buffer_.write_segment_length());
while (true) { while (true) {
auto root = auto root = heap_message_root<Incoming, InContainer>();
heapMessageRoot<Incoming, InContainer>(); auto builder = root.build();
auto builder = root.build();
error err = error err = codec_.template decode<Incoming, InContainer>(
codec_.template decode<Incoming, InContainer>( builder, in_buffer_);
builder, in_buffer_); if (err.is_critical()) {
if (err.is_critical()) { return err;
return err; }
}
if (!err.failed()) { if (!err.failed()) {
incoming_feeder_->feed(std::move(root)); incoming_feeder_->feed(std::move(root));
} else { } else {
break; break;
} }
} }
return void_t{}; return void_t{};
}) })
.sink([this](error err) { .sink([this](error err) {
incoming_feeder_->fail(err.copy_error()); incoming_feeder_->fail(err.copy_error());
return err; return err;
})}, })},
sink_write_{io_stream_->write_done() sink_write_{io_stream_->write_done()
.then([this](size_t bytes) -> error_or<void> { .then([this](size_t bytes) -> error_or<void> {
out_buffer_.read_advance(bytes); out_buffer_.read_advance(bytes);
@ -72,8 +73,8 @@ streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, BufferT>
template <typename Codec, typename Incoming, typename Outgoing, template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT> typename InContainer, typename OutContainer, typename BufferT>
error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer, error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT>::send(HeapMessageRoot<Outgoing, OutContainer> BufferT>::send(heap_message_root<Outgoing, OutContainer>
msg) { msg) {
bool restart_write = out_buffer_.read_segment_length() == 0; bool restart_write = out_buffer_.read_segment_length() == 0;
error err = error err =
@ -83,7 +84,8 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
} }
if (restart_write) { if (restart_write) {
io_stream_->write(&out_buffer_.read(), out_buffer_.read_segment_length()); io_stream_->write(&out_buffer_.read(),
out_buffer_.read_segment_length());
} }
return no_error(); return no_error();
@ -91,22 +93,24 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
template <typename Codec, typename Incoming, typename Outgoing, template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT> typename InContainer, typename OutContainer, typename BufferT>
conveyor<void> streaming_io_peer<Codec, Incoming, Outgoing, InContainer, conveyor<void>
OutContainer, BufferT>::on_read_disconnected() { streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
BufferT>::on_read_disconnected() {
return io_stream_->on_read_disconnected(); return io_stream_->on_read_disconnected();
} }
template <typename Codec, typename Incoming, typename Outgoing, template <typename Codec, typename Incoming, typename Outgoing,
typename InContainer, typename OutContainer, typename BufferT> typename InContainer, typename OutContainer, typename BufferT>
std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer, std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>>, OutContainer, BufferT>>,
conveyor<HeapMessageRoot<Incoming, InContainer>>> conveyor<heap_message_root<Incoming, InContainer>>>
newstreaming_io_peer(own<async_io_stream> stream) { newstreaming_io_peer(own<async_io_stream> stream) {
auto caf = newconveyorAndFeeder<HeapMessageRoot<Incoming, InContainer>>(); auto caf =
new_conveyor_and_feeder<heap_message_root<Incoming, InContainer>>();
return {heap<streaming_io_peer<Codec, Incoming, Outgoing, InContainer, return {heap<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
OutContainer, BufferT>>(std::move(caf.feeder), OutContainer, BufferT>>(
std::move(stream)), std::move(caf.feeder), std::move(stream)),
std::move(caf.conveyor)}; std::move(caf.conveyor)};
} }

94
source/forstio/message.h
View File

@ -74,8 +74,8 @@ public:
*/ */
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
!SchemaIsArray< !schema_is_array<
typename MessageParameterPackType<i, V...>::Type>::Value, typename message_parameter_pack_type<i, V...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init() { init() {
return typename Container::template ElementType<i>::builder{ return typename Container::template ElementType<i>::builder{
@ -88,23 +88,23 @@ public:
*/ */
template <string_literal Literal> template <string_literal Literal>
typename std::enable_if< typename std::enable_if<
!SchemaIsArray<typename MessageParameterPackType< !schema_is_array<typename message_parameter_pack_type<
MessageParameterKeyPackIndex<Literal, Keys...>::Value, message_parameter_key_pack_index<Literal, Keys...>::Value,
V...>::Type>::Value, V...>::Type>::Value,
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, message_parameter_key_pack_index<Literal, Keys...>::Value>::
Keys...>::Value>::builder>::type builder>::type
init() { init() {
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return init<i>(); return init<i>();
} }
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
SchemaIsArray< schema_is_array<
typename MessageParameterPackType<i, V...>::Type>::Value, typename message_parameter_pack_type<i, V...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) { init(size_t size = 0) {
auto array_builder = auto array_builder =
@ -118,15 +118,15 @@ public:
*/ */
template <string_literal Literal> template <string_literal Literal>
typename std::enable_if< typename std::enable_if<
SchemaIsArray<typename MessageParameterPackType< schema_is_array<typename message_parameter_pack_type<
MessageParameterKeyPackIndex<Literal, Keys...>::Value, message_parameter_key_pack_index<Literal, Keys...>::Value,
V...>::Type>::Value, V...>::Type>::Value,
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, message_parameter_key_pack_index<Literal, Keys...>::Value>::
Keys...>::Value>::builder>::type builder>::type
init(size_t size) { init(size_t size) {
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return init<i>(size); return init<i>(size);
} }
@ -156,11 +156,11 @@ public:
*/ */
template <string_literal Literal> template <string_literal Literal>
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
get() { get() {
// The index of the first match // The index of the first match
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return get<i>(); return get<i>();
} }
@ -202,8 +202,8 @@ public:
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
!SchemaIsArray< !schema_is_array<
typename MessageParameterPackType<i, V...>::Type>::Value, typename message_parameter_pack_type<i, V...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init() { init() {
@ -213,15 +213,15 @@ public:
template <string_literal Literal> template <string_literal Literal>
typename std::enable_if< typename std::enable_if<
!SchemaIsArray<typename MessageParameterPackType< !schema_is_array<typename message_parameter_pack_type<
MessageParameterKeyPackIndex<Literal, Keys...>::Value, message_parameter_key_pack_index<Literal, Keys...>::Value,
V...>::Type>::Value, V...>::Type>::Value,
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, message_parameter_key_pack_index<Literal, Keys...>::Value>::
Keys...>::Value>::builder>::type builder>::type
init() { init() {
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return init<i>(); return init<i>();
} }
@ -231,8 +231,8 @@ public:
*/ */
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
SchemaIsArray< schema_is_array<
typename MessageParameterPackType<i, V...>::Type>::Value, typename message_parameter_pack_type<i, V...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) { init(size_t size = 0) {
return typename Container::template ElementType<i>::builder{ return typename Container::template ElementType<i>::builder{
@ -241,15 +241,15 @@ public:
template <string_literal Literal> template <string_literal Literal>
typename std::enable_if< typename std::enable_if<
SchemaIsArray<typename MessageParameterPackType< schema_is_array<typename message_parameter_pack_type<
MessageParameterKeyPackIndex<Literal, Keys...>::Value, message_parameter_key_pack_index<Literal, Keys...>::Value,
V...>::Type>::Value, V...>::Type>::Value,
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, message_parameter_key_pack_index<Literal, Keys...>::Value>::
Keys...>::Value>::builder>::type builder>::type
init(size_t size) { init(size_t size) {
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return init<i>(size); return init<i>(size);
} }
@ -272,24 +272,24 @@ public:
template <string_literal Literal> template <string_literal Literal>
typename Container::template ElementType< typename Container::template ElementType<
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
get() { get() {
// The index of the first match // The index of the first match
constexpr size_t i = constexpr size_t i =
MessageParameterKeyPackIndex<Literal, Keys...>::Value; message_parameter_key_pack_index<Literal, Keys...>::Value;
return get<i>(); return get<i>();
} }
template <string_literal Literal> template <string_literal Literal>
static constexpr size_t toIndex() noexcept { static constexpr size_t to_index() noexcept {
return MessageParameterKeyPackIndex<Literal, Keys...>::Value; return message_parameter_key_pack_index<Literal, Keys...>::Value;
} }
size_t index() const noexcept { return message_.container_.index(); } size_t index() const noexcept { return message_.container_.index(); }
template <string_literal Literal> bool hasAlternative() const { template <string_literal Literal> bool has_alternative() const {
return index() == toIndex<Literal>(); return index() == to_index<Literal>();
} }
}; };
}; };
@ -383,8 +383,8 @@ public:
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
!SchemaIsArray< !schema_is_array<
typename MessageParameterPackType<i, T...>::Type>::Value, typename message_parameter_pack_type<i, T...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init() { init() {
return typename Container::template ElementType<i>::builder{ return typename Container::template ElementType<i>::builder{
@ -393,8 +393,8 @@ public:
template <size_t i> template <size_t i>
typename std::enable_if< typename std::enable_if<
SchemaIsArray< schema_is_array<
typename MessageParameterPackType<i, T...>::Type>::Value, typename message_parameter_pack_type<i, T...>::Type>::Value,
typename Container::template ElementType<i>::builder>::type typename Container::template ElementType<i>::builder>::type
init(size_t size = 0) { init(size_t size = 0) {
return typename Container::template ElementType<i>::builder{ return typename Container::template ElementType<i>::builder{
@ -511,12 +511,13 @@ public:
}; };
template <class Schema, class Container = message_container<Schema>> template <class Schema, class Container = message_container<Schema>>
class HeapMessageRoot { class heap_message_root {
private: private:
own<message<Schema, Container>> root_; own<message<Schema, Container>> root_;
public: public:
HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {} heap_message_root(own<message<Schema, Container>> r)
: root_{std::move(r)} {}
typename message<Schema, Container>::builder build() { typename message<Schema, Container>::builder build() {
assert(root_); assert(root_);
@ -530,7 +531,7 @@ public:
}; };
template <class T, class Container> template <class T, class Container>
class HeapMessageRoot<schema::Array<T>, Container> { class heap_message_root<schema::Array<T>, Container> {
public: public:
using Schema = schema::Array<T>; using Schema = schema::Array<T>;
@ -538,7 +539,8 @@ private:
own<message<Schema, Container>> root_; own<message<Schema, Container>> root_;
public: public:
HeapMessageRoot(own<message<Schema, Container>> r) : root_{std::move(r)} {} heap_message_root(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_); assert(root_);
@ -555,8 +557,8 @@ public:
* Minor helper for creating a message root * Minor helper for creating a message root
*/ */
template <class Schema, class Container = message_container<Schema>> template <class Schema, class Container = message_container<Schema>>
inline HeapMessageRoot<Schema, Container> heapMessageRoot() { inline heap_message_root<Schema, Container> new_heap_message_root() {
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)}; return heap_message_root<Schema, Container>{std::move(root)};
} }
} // namespace saw } // namespace saw

32
source/forstio/message_container.h
View File

@ -10,16 +10,17 @@ template <class T> class message_container;
template <class T, class Container = message_container<T>> class message; template <class T, class Container = message_container<T>> class message;
template <size_t N, class... T> struct MessageParameterPackType; template <size_t N, class... T> struct message_parameter_pack_type;
template <class TN, class... T> struct MessageParameterPackType<0, TN, T...> { template <class TN, class... T>
struct message_parameter_pack_type<0, TN, T...> {
using Type = TN; using Type = TN;
}; };
template <size_t N, class TN, class... T> template <size_t N, class TN, class... T>
struct MessageParameterPackType<N, TN, T...> { struct message_parameter_pack_type<N, TN, T...> {
static_assert(sizeof...(T) > 0, "Exhausted parameters"); static_assert(sizeof...(T) > 0, "Exhausted parameters");
using Type = typename MessageParameterPackType<N - 1, T...>::Type; using Type = typename message_parameter_pack_type<N - 1, T...>::Type;
}; };
template <class T, class... TL> struct MessageParameterPackIndex; template <class T, class... TL> struct MessageParameterPackIndex;
@ -40,31 +41,31 @@ struct MessageParameterPackIndex<T, TL0, TL...> {
* This is the workaround * This is the workaround
*/ */
template <string_literal V, string_literal Key0, string_literal... Keys> template <string_literal V, string_literal Key0, string_literal... Keys>
struct MessageParameterKeyPackIndexHelper { struct message_parameter_key_pack_index_helper {
static constexpr size_t Value = static constexpr size_t Value =
(V == Key0) (V == Key0)
? (0u) ? (0u)
: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value); : (1u + message_parameter_key_pack_index_helper<V, Keys...>::Value);
}; };
template <string_literal V, string_literal Key0> template <string_literal V, string_literal Key0>
struct MessageParameterKeyPackIndexHelper<V, Key0> { struct message_parameter_key_pack_index_helper<V, Key0> {
static constexpr size_t Value = (V == Key0) ? (0u) : (1u); static constexpr size_t Value = (V == Key0) ? (0u) : (1u);
}; };
template <string_literal V, string_literal... Keys> template <string_literal V, string_literal... Keys>
struct MessageParameterKeyPackIndex { struct message_parameter_key_pack_index {
static constexpr size_t Value = static constexpr size_t Value =
MessageParameterKeyPackIndexHelper<V, Keys...>::Value; message_parameter_key_pack_index_helper<V, Keys...>::Value;
static_assert(Value < sizeof...(Keys), static_assert(Value < sizeof...(Keys),
"Provided StringLiteral doesn't exist in searched list"); "Provided StringLiteral doesn't exist in searched list");
}; };
template <class T> struct SchemaIsArray { template <class T> struct schema_is_array {
constexpr static bool Value = false; constexpr static bool Value = false;
}; };
template <class T> struct SchemaIsArray<schema::Array<T>> { template <class T> struct schema_is_array<schema::Array<T>> {
constexpr static bool Value = true; constexpr static bool Value = true;
}; };
@ -78,7 +79,7 @@ public:
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>; using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
template <size_t i> template <size_t i>
using ElementType = typename MessageParameterPackType< using ElementType = typename message_parameter_pack_type<
i, message<V, message_container<V>>...>::Type; i, message<V, message_container<V>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); } template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
@ -97,12 +98,13 @@ public:
using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>; using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
template <size_t i> template <size_t i>
using ElementType = typename MessageParameterPackType< using ElementType = typename message_parameter_pack_type<
i, message<V, message_container<V>>...>::Type; i, message<V, message_container<V>>...>::Type;
template <size_t i> ElementType<i> &get() { template <size_t i> ElementType<i> &get() {
if (i != value_.index()) { if (i != value_.index()) {
using MessageIV = typename MessageParameterPackType<i, V...>::Type; using MessageIV =
typename message_parameter_pack_type<i, V...>::Type;
value_ = message<MessageIV, message_container<MessageIV>>{}; value_ = message<MessageIV, message_container<MessageIV>>{};
} }
return std::get<i>(value_); return std::get<i>(value_);
@ -146,7 +148,7 @@ public:
using SchemaType = schema::Tuple<T...>; using SchemaType = schema::Tuple<T...>;
template <size_t i> template <size_t i>
using ElementType = typename MessageParameterPackType< using ElementType = typename message_parameter_pack_type<
i, message<T, message_container<T>>...>::Type; i, message<T, message_container<T>>...>::Type;
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); } template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }

231
source/forstio/proto_kel.h
View File

@ -5,37 +5,37 @@
#include "stream_endian.h" #include "stream_endian.h"
namespace saw { namespace saw {
class ProtoKelCodec { class proto_kel_codec {
public: public:
using UnionIdT = uint32_t; using UnionIdT = uint32_t;
using ArrayLengthT = uint64_t; using ArrayLengthT = uint64_t;
using PacketLengthT = uint64_t; using PacketLengthT = uint64_t;
private: private:
struct ReadContext { struct read_context {
buffer &buffer; buffer &buffer;
size_t offset = 0; size_t offset = 0;
}; };
template <typename T> friend struct ProtoKelEncodeImpl; template <typename T> friend struct proto_kel_encode_impl;
template <typename T> friend struct ProtoKelDecodeImpl; template <typename T> friend struct proto_kel_decode_impl;
public: public:
struct Limits { struct limits {
ProtoKelCodec::PacketLengthT packet_size; proto_kel_codec::PacketLengthT packet_size;
Limits() : packet_size{4096} {} limits() : packet_size{4096} {}
Limits(ProtoKelCodec::PacketLengthT ps) : packet_size{ps} {} limits(proto_kel_codec::PacketLengthT ps) : packet_size{ps} {}
}; };
struct Version { struct version {
size_t major; size_t major;
size_t minor; size_t minor;
size_t security; size_t security;
}; };
const Version version() const { return Version{0, 0, 0}; } const version get_version() const { return version{0, 0, 0}; }
template <class Schema, class Container = message_container<Schema>> template <class Schema, class Container = message_container<Schema>>
error encode(typename message<Schema, Container>::reader reader, error encode(typename message<Schema, Container>::reader reader,
@ -43,13 +43,13 @@ public:
template <class Schema, class Container = message_container<Schema>> template <class Schema, class Container = message_container<Schema>>
error decode(typename message<Schema, Container>::builder builder, error decode(typename message<Schema, Container>::builder builder,
buffer &buffer, const Limits &limits = Limits{}); buffer &buffer, const limits &lim = limits{});
}; };
template <class T> struct ProtoKelEncodeImpl; template <class T> struct proto_kel_encode_impl;
template <class T, size_t N, class Container> template <class T, size_t N, class Container>
struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> { struct proto_kel_encode_impl<message<schema::Primitive<T, N>, Container>> {
static error static error
encode(typename message<schema::Primitive<T, N>, Container>::reader data, encode(typename message<schema::Primitive<T, N>, Container>::reader data,
buffer &buffer) { buffer &buffer) {
@ -66,7 +66,7 @@ struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
}; };
template <class Container> template <class Container>
struct ProtoKelEncodeImpl<message<schema::String, Container>> { struct proto_kel_encode_impl<message<schema::String, Container>> {
static error static error
encode(typename message<schema::String, Container>::reader data, encode(typename message<schema::String, Container>::reader data,
buffer &buffer) { buffer &buffer) {
@ -96,166 +96,170 @@ struct ProtoKelEncodeImpl<message<schema::String, Container>> {
}; };
template <class... T, class Container> template <class... T, class Container>
struct ProtoKelEncodeImpl<message<schema::Tuple<T...>, Container>> { struct proto_kel_encode_impl<message<schema::Tuple<T...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), error>::type static typename std::enable_if<i == sizeof...(T), error>::type
encodeMembers(typename message<schema::Tuple<T...>, Container>::reader, encode_members(typename message<schema::Tuple<T...>, Container>::reader,
buffer &) { buffer &) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<(i < sizeof...(T)), error>::type static typename std::enable_if<(i < sizeof...(T)), error>::type
encodeMembers(typename message<schema::Tuple<T...>, Container>::reader data, encode_members(
buffer &buffer) { typename message<schema::Tuple<T...>, Container>::reader data,
buffer &buffer) {
error err = error err =
ProtoKelEncodeImpl<typename Container::template ElementType<i>>:: proto_kel_encode_impl<typename Container::template ElementType<i>>::
encode(data.template get<i>(), buffer); encode(data.template get<i>(), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
return encodeMembers<i + 1>(data, buffer); return encode_members<i + 1>(data, buffer);
} }
static error static error
encode(typename message<schema::Tuple<T...>, Container>::reader data, encode(typename message<schema::Tuple<T...>, Container>::reader data,
buffer &buffer) { buffer &buffer) {
return encodeMembers<0>(data, buffer); return encode_members<0>(data, buffer);
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), size_t>::type static typename std::enable_if<i == sizeof...(T), size_t>::type
sizeMembers(typename message<schema::Tuple<T...>, Container>::reader) { size_members(typename message<schema::Tuple<T...>, Container>::reader) {
return 0; return 0;
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(T), size_t>::type sizeMembers( i<sizeof...(T), size_t>::type size_members(
typename message<schema::Tuple<T...>, Container>::reader reader) { typename message<schema::Tuple<T...>, Container>::reader reader) {
return ProtoKelEncodeImpl<typename Container::template ElementType<i>>:: return proto_kel_encode_impl<typename Container::template ElementType<
size(reader.template get<i>()) + i>>::size(reader.template get<i>()) +
sizeMembers<i + 1>(reader); size_members<i + 1>(reader);
} }
static size_t 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); return size_members<0>(reader);
} }
}; };
template <typename... V, string_literal... K, class Container> template <typename... V, string_literal... K, class Container>
struct ProtoKelEncodeImpl< struct proto_kel_encode_impl<
message<schema::Struct<schema::NamedMember<V, K>...>, Container>> { message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), error>::type static typename std::enable_if<i == sizeof...(V), error>::type
encodeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>, encode_members(
Container>::reader, typename message<schema::Struct<schema::NamedMember<V, K>...>,
buffer &) { Container>::reader,
buffer &) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), error>::type encodeMembers( i<sizeof...(V), error>::type encode_members(
typename message<schema::Struct<schema::NamedMember<V, K>...>, typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader data, Container>::reader data,
buffer &buffer) { buffer &buffer) {
error err = error err =
ProtoKelEncodeImpl<typename Container::template ElementType<i>>:: proto_kel_encode_impl<typename Container::template ElementType<i>>::
encode(data.template get<i>(), buffer); encode(data.template get<i>(), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
return encodeMembers<i + 1>(data, buffer); return encode_members<i + 1>(data, buffer);
} }
static error static error
encode(typename message<schema::Struct<schema::NamedMember<V, K>...>, encode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader data, Container>::reader data,
buffer &buffer) { buffer &buffer) {
return encodeMembers<0>(data, buffer); return encode_members<0>(data, buffer);
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), size_t>::type static typename std::enable_if<i == sizeof...(V), size_t>::type
sizeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>, size_members(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader) { Container>::reader) {
return 0; return 0;
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), size_t>::type sizeMembers( i<sizeof...(V), size_t>::type size_members(
typename message<schema::Struct<schema::NamedMember<V, K>...>, typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader reader) { Container>::reader reader) {
return ProtoKelEncodeImpl<typename Container::template ElementType<i>>:: return proto_kel_encode_impl<typename Container::template ElementType<
size(reader.template get<i>()) + i>>::size(reader.template get<i>()) +
sizeMembers<i + 1>(reader); size_members<i + 1>(reader);
} }
static size_t static size_t
size(typename message<schema::Struct<schema::NamedMember<V, K>...>, size(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::reader reader) { Container>::reader reader) {
return sizeMembers<0>(reader); return size_members<0>(reader);
} }
}; };
template <typename... V, string_literal... K, class Container> template <typename... V, string_literal... K, class Container>
struct ProtoKelEncodeImpl< struct proto_kel_encode_impl<
message<schema::Union<schema::NamedMember<V, K>...>, Container>> { message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), error>::type static typename std::enable_if<i == sizeof...(V), error>::type
encodeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>, encode_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader, Container>::reader,
buffer &) { buffer &) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), error>::type encodeMembers( i<sizeof...(V), error>::type encode_members(
typename message<schema::Union<schema::NamedMember<V, K>...>, typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader, Container>::reader reader,
buffer &buffer) { buffer &buffer) {
if (reader.index() == i) { if (reader.index() == i) {
error err = error err =
stream_value<ProtoKelCodec::UnionIdT>::encode(i, buffer); stream_value<proto_kel_codec::UnionIdT>::encode(i, buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
return ProtoKelEncodeImpl<typename Container::template ElementType< return proto_kel_encode_impl<
i>>::encode(reader.template get<i>(), buffer); typename Container::template ElementType<i>>::
encode(reader.template get<i>(), buffer);
} }
return encodeMembers<i + 1>(reader, buffer); return encode_members<i + 1>(reader, buffer);
} }
static error static error
encode(typename message<schema::Union<schema::NamedMember<V, K>...>, encode(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader, Container>::reader reader,
buffer &buffer) { buffer &buffer) {
return encodeMembers<0>(reader, buffer); return encode_members<0>(reader, buffer);
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), size_t>::type static typename std::enable_if<i == sizeof...(V), size_t>::type
sizeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>, size_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader) { Container>::reader) {
return 0; return 0;
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), size_t>::type sizeMembers( i<sizeof...(V), size_t>::type size_members(
typename message<schema::Union<schema::NamedMember<V, K>...>, typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader) { Container>::reader reader) {
if (reader.index() == i) { if (reader.index() == i) {
return ProtoKelEncodeImpl<typename Container::template ElementType< return proto_kel_encode_impl<
i>>::size(reader.template get<i>()); typename Container::template ElementType<i>>::
size(reader.template get<i>());
} }
return sizeMembers<i + 1>(reader); return size_members<i + 1>(reader);
} }
/* /*
@ -264,18 +268,18 @@ struct ProtoKelEncodeImpl<
static size_t static size_t
size(typename message<schema::Union<schema::NamedMember<V, K>...>, size(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::reader reader) { Container>::reader reader) {
return sizeof(ProtoKelCodec::UnionIdT) + sizeMembers<0>(reader); return sizeof(proto_kel_codec::UnionIdT) + size_members<0>(reader);
} }
}; };
template <class T, class Container> template <class T, class Container>
struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> { struct proto_kel_encode_impl<message<schema::Array<T>, Container>> {
static error static error
encode(typename message<schema::Array<T>, Container>::reader data, encode(typename message<schema::Array<T>, Container>::reader data,
buffer &buffer) { buffer &buffer) {
ProtoKelCodec::ArrayLengthT array_length = data.size(); proto_kel_codec::ArrayLengthT array_length = data.size();
{ {
error err = stream_value<ProtoKelCodec::ArrayLengthT>::encode( error err = stream_value<proto_kel_codec::ArrayLengthT>::encode(
array_length, buffer); array_length, buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -284,7 +288,7 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
for (size_t i = 0; i < array_length; ++i) { for (size_t i = 0; i < array_length; ++i) {
error err = error err =
ProtoKelEncodeImpl<typename Container::ElementType>::encode( proto_kel_encode_impl<typename Container::ElementType>::encode(
data.get(i), buffer); data.get(i), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -298,10 +302,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
*/ */
static size_t 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); size_t members = sizeof(proto_kel_codec::ArrayLengthT);
for (size_t i = 0; i < data.size(); ++i) { for (size_t i = 0; i < data.size(); ++i) {
members += members +=
ProtoKelEncodeImpl<typename Container::ElementType>::size( proto_kel_encode_impl<typename Container::ElementType>::size(
data.get(i)); data.get(i));
} }
@ -312,10 +316,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
/* /*
* Decode Implementations * Decode Implementations
*/ */
template <typename T> struct ProtoKelDecodeImpl; template <typename T> struct proto_kel_decode_impl;
template <class T, size_t N, class Container> template <class T, size_t N, class Container>
struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> { struct proto_kel_decode_impl<message<schema::Primitive<T, N>, Container>> {
static error static error
decode(typename message<schema::Primitive<T, N>, Container>::builder data, decode(typename message<schema::Primitive<T, N>, Container>::builder data,
buffer &buffer) { buffer &buffer) {
@ -328,7 +332,7 @@ struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> {
}; };
template <class Container> template <class Container>
struct ProtoKelDecodeImpl<message<schema::String, Container>> { struct proto_kel_decode_impl<message<schema::String, Container>> {
static error static error
decode(typename message<schema::String, Container>::builder data, decode(typename message<schema::String, Container>::builder data,
buffer &buffer) { buffer &buffer) {
@ -362,107 +366,108 @@ struct ProtoKelDecodeImpl<message<schema::String, Container>> {
}; };
template <class... T, class Container> template <class... T, class Container>
struct ProtoKelDecodeImpl<message<schema::Tuple<T...>, Container>> { struct proto_kel_decode_impl<message<schema::Tuple<T...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(T), error>::type static typename std::enable_if<i == sizeof...(T), error>::type
decodeMembers(typename message<schema::Tuple<T...>, Container>::builder, decode_members(typename message<schema::Tuple<T...>, Container>::builder,
buffer &) { buffer &) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(T), error>::type decodeMembers( i<sizeof...(T), error>::type decode_members(
typename message<schema::Tuple<T...>, Container>::builder builder, typename message<schema::Tuple<T...>, Container>::builder builder,
buffer &buffer) { buffer &buffer) {
error err = error err =
ProtoKelDecodeImpl<typename Container::template ElementType<i>>:: proto_kel_decode_impl<typename Container::template ElementType<i>>::
decode(builder.template init<i>(), buffer); decode(builder.template init<i>(), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
return decodeMembers<i + 1>(builder, buffer); return decode_members<i + 1>(builder, buffer);
} }
static error static error
decode(typename message<schema::Tuple<T...>, Container>::builder builder, decode(typename message<schema::Tuple<T...>, Container>::builder builder,
buffer &buffer) { buffer &buffer) {
return decodeMembers<0>(builder, buffer); return decode_members<0>(builder, buffer);
} }
}; };
template <class... V, string_literal... K, class Container> template <class... V, string_literal... K, class Container>
struct ProtoKelDecodeImpl< struct proto_kel_decode_impl<
message<schema::Struct<schema::NamedMember<V, K>...>, Container>> { message<schema::Struct<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), error>::type static typename std::enable_if<i == sizeof...(V), error>::type
decodeMembers(typename message<schema::Struct<schema::NamedMember<V, K>...>, decode_members(
Container>::builder, typename message<schema::Struct<schema::NamedMember<V, K>...>,
buffer &) { Container>::builder,
buffer &) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), error>::type decodeMembers( i<sizeof...(V), error>::type decode_members(
typename message<schema::Struct<schema::NamedMember<V, K>...>, typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::builder builder, Container>::builder builder,
buffer &buffer) { buffer &buffer) {
error err = error err =
ProtoKelDecodeImpl<typename Container::template ElementType<i>>:: proto_kel_decode_impl<typename Container::template ElementType<i>>::
decode(builder.template init<i>(), buffer); decode(builder.template init<i>(), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
return decodeMembers<i + 1>(builder, buffer); return decode_members<i + 1>(builder, buffer);
} }
static error static error
decode(typename message<schema::Struct<schema::NamedMember<V, K>...>, decode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
Container>::builder builder, Container>::builder builder,
buffer &buffer) { buffer &buffer) {
return decodeMembers<0>(builder, buffer); return decode_members<0>(builder, buffer);
} }
}; };
template <class... V, string_literal... K, class Container> template <class... V, string_literal... K, class Container>
struct ProtoKelDecodeImpl< struct proto_kel_decode_impl<
message<schema::Union<schema::NamedMember<V, K>...>, Container>> { message<schema::Union<schema::NamedMember<V, K>...>, Container>> {
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if<i == sizeof...(V), error>::type static typename std::enable_if<i == sizeof...(V), error>::type
decodeMembers(typename message<schema::Union<schema::NamedMember<V, K>...>, decode_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder, Container>::builder,
buffer &, ProtoKelCodec::UnionIdT) { buffer &, proto_kel_codec::UnionIdT) {
return no_error(); return no_error();
} }
template <size_t i = 0> template <size_t i = 0>
static typename std::enable_if < static typename std::enable_if <
i<sizeof...(V), error>::type decodeMembers( i<sizeof...(V), error>::type decode_members(
typename message<schema::Union<schema::NamedMember<V, K>...>, typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder builder, Container>::builder builder,
buffer &buffer, ProtoKelCodec::UnionIdT id) { buffer &buffer, proto_kel_codec::UnionIdT id) {
if (id == i) { if (id == i) {
error err = error err =
ProtoKelDecodeImpl<typename Container::template ElementType< proto_kel_decode_impl<typename Container::template ElementType<
i>>::decode(builder.template init<i>(), buffer); i>>::decode(builder.template init<i>(), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
} }
return decodeMembers<i + 1>(builder, buffer, id); return decode_members<i + 1>(builder, buffer, id);
} }
static error static error
decode(typename message<schema::Union<schema::NamedMember<V, K>...>, decode(typename message<schema::Union<schema::NamedMember<V, K>...>,
Container>::builder builder, Container>::builder builder,
buffer &buffer) { buffer &buffer) {
ProtoKelCodec::UnionIdT id = 0; proto_kel_codec::UnionIdT id = 0;
error err = stream_value<ProtoKelCodec::UnionIdT>::decode(id, buffer); error err = stream_value<proto_kel_codec::UnionIdT>::decode(id, buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
@ -470,18 +475,18 @@ struct ProtoKelDecodeImpl<
return critical_error("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); return decode_members<0>(builder, buffer, id);
} }
}; };
template <class T, class Container> template <class T, class Container>
struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> { struct proto_kel_decode_impl<message<schema::Array<T>, Container>> {
static error static error
decode(typename message<schema::Array<T>, Container>::builder data, decode(typename message<schema::Array<T>, Container>::builder data,
buffer &buffer) { buffer &buffer) {
ProtoKelCodec::ArrayLengthT array_length = 0; proto_kel_codec::ArrayLengthT array_length = 0;
{ {
error err = stream_value<ProtoKelCodec::ArrayLengthT>::decode( error err = stream_value<proto_kel_codec::ArrayLengthT>::decode(
array_length, buffer); array_length, buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -492,7 +497,7 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
for (size_t i = 0; i < array_length; ++i) { for (size_t i = 0; i < array_length; ++i) {
error err = error err =
ProtoKelDecodeImpl<typename Container::ElementType>::decode( proto_kel_decode_impl<typename Container::ElementType>::decode(
data.init(i), buffer); data.init(i), buffer);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -503,30 +508,30 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
}; };
template <class Schema, class Container> template <class Schema, class Container>
error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader, error proto_kel_codec::encode(
buffer &buffer) { typename message<Schema, Container>::reader reader, buffer &buffer) {
buffer_view view{buffer}; buffer_view view{buffer};
ProtoKelCodec::PacketLengthT packet_length = proto_kel_codec::PacketLengthT packet_length =
ProtoKelEncodeImpl<message<Schema, Container>>::size(reader); proto_kel_encode_impl<message<Schema, Container>>::size(reader);
// Check the size of the packet for the first // Check the size of the packet for the first
// message length description // message length description
error err = view.write_require_length(packet_length + error err = view.write_require_length(
sizeof(ProtoKelCodec::PacketLengthT)); packet_length + sizeof(proto_kel_codec::PacketLengthT));
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
{ {
error err = stream_value<ProtoKelCodec::PacketLengthT>::encode( error err = stream_value<proto_kel_codec::PacketLengthT>::encode(
packet_length, view); packet_length, view);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
} }
{ {
error err = ProtoKelEncodeImpl<message<Schema, Container>>::encode( error err = proto_kel_encode_impl<message<Schema, Container>>::encode(
reader, view); reader, view);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -538,14 +543,14 @@ error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
} }
template <class Schema, class Container> template <class Schema, class Container>
error ProtoKelCodec::decode( error proto_kel_codec::decode(
typename message<Schema, Container>::builder builder, buffer &buffer, typename message<Schema, Container>::builder builder, buffer &buffer,
const Limits &limits) { const limits &limits) {
buffer_view view{buffer}; buffer_view view{buffer};
ProtoKelCodec::PacketLengthT packet_length = 0; proto_kel_codec::PacketLengthT packet_length = 0;
{ {
error err = stream_value<ProtoKelCodec::PacketLengthT>::decode( error err = stream_value<proto_kel_codec::PacketLengthT>::decode(
packet_length, view); packet_length, view);
if (err.failed()) { if (err.failed()) {
return err; return err;
@ -562,14 +567,14 @@ error ProtoKelCodec::decode(
} }
{ {
error err = ProtoKelDecodeImpl<message<Schema, Container>>::decode( error err = proto_kel_decode_impl<message<Schema, Container>>::decode(
builder, view); builder, view);
if (err.failed()) { if (err.failed()) {
return err; return err;
} }
} }
{ {
if (ProtoKelEncodeImpl<message<Schema, Container>>::size( if (proto_kel_encode_impl<message<Schema, Container>>::size(
builder.as_reader()) != packet_length) { builder.as_reader()) != packet_length) {
return critical_error("Bad packet format"); return critical_error("Bad packet format");
} }

3
source/forstio/schema.h
View File

@ -5,7 +5,7 @@
namespace saw { namespace saw {
namespace schema { namespace schema {
// NOLINTBEGIN
template <typename T, string_literal Literal> struct NamedMember {}; template <typename T, string_literal Literal> struct NamedMember {};
template <typename... T> struct Struct { template <typename... T> struct Struct {
@ -72,5 +72,6 @@ template <class... T> struct Interface {
template <class... Request, class... Response, string_literal... Literal> template <class... Request, class... Response, string_literal... Literal>
struct Interface<Function<Request, Response, Literal>...> {}; struct Interface<Function<Request, Response, Literal>...> {};
// NOLINTEND
} // namespace schema } // namespace schema
} // namespace saw } // namespace saw

10
test/message.cpp
View File

@ -16,7 +16,7 @@ using TestTuple = schema::Tuple<schema::UInt32, schema::String>;
SAW_TEST("Message Tuple"){ SAW_TEST("Message Tuple"){
std::string test_string_1 = "banana"; std::string test_string_1 = "banana";
auto root = saw::heapMessageRoot<TestTuple>(); auto root = saw::new_heap_message_root<TestTuple>();
auto builder = root.build(); auto builder = root.build();
auto uint = builder.init<0>(); auto uint = builder.init<0>();
uint.set(10); uint.set(10);
@ -36,7 +36,7 @@ SAW_TEST("Message Tuple nested"){
std::string test_string_1 = "banana"; std::string test_string_1 = "banana";
std::string test_string_2 = "bat"; std::string test_string_2 = "bat";
auto root = saw::heapMessageRoot<NestedTestTuple>(); auto root = saw::new_heap_message_root<NestedTestTuple>();
auto builder = root.build(); auto builder = root.build();
auto inner_list = builder.init<0>(); auto inner_list = builder.init<0>();
auto uint = inner_list.init<0>(); auto uint = inner_list.init<0>();
@ -64,7 +64,7 @@ using TestStruct = schema::Struct<
SAW_TEST("Message Struct"){ SAW_TEST("Message Struct"){
std::string test_string = "foo"; std::string test_string = "foo";
auto root = saw::heapMessageRoot<TestStruct>(); auto root = saw::new_heap_message_root<TestStruct>();
auto builder = root.build(); auto builder = root.build();
auto uint = builder.init<"test_uint">(); auto uint = builder.init<"test_uint">();
uint.set(23); uint.set(23);
@ -103,7 +103,7 @@ void arrayCheck(saw::message<TestArray>::builder builder){
} }
SAW_TEST("Message Array"){ SAW_TEST("Message Array"){
auto root = saw::heapMessageRoot<TestArray>(); auto root = saw::new_heap_message_root<TestArray>();
auto builder = root.build(3); auto builder = root.build(3);
@ -115,7 +115,7 @@ using TestArrayStruct = schema::Struct<
>; >;
SAW_TEST("Message Array in Struct"){ SAW_TEST("Message Array in Struct"){
auto root = saw::heapMessageRoot<TestArrayStruct>(); auto root = saw::new_heap_message_root<TestArrayStruct>();
auto builder = root.build(); auto builder = root.build();

42
test/proto_kel.cpp
View File

@ -27,26 +27,26 @@ SAW_TEST("Primitive Encoding"){
using namespace saw; using namespace saw;
uint32_t value = 5; uint32_t value = 5;
auto root = heapMessageRoot<TestSize>(); auto root = new_heap_message_root<TestSize>();
auto builder = root.build(); auto builder = root.build();
builder.set(value); builder.set(value);
ring_buffer temp_buffer; ring_buffer temp_buffer;
ProtoKelCodec codec; proto_kel_codec codec;
error err = codec.encode<TestSize>(root.read(), temp_buffer); error err = codec.encode<TestSize>(root.read(), temp_buffer);
SAW_EXPECT(!err.failed(), err.message()); 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())); SAW_EXPECT(temp_buffer.read_composite_length() == (sizeof(value)+sizeof(proto_kel_codec::PacketLengthT)), "Bad Size: " + std::to_string(temp_buffer.read_composite_length()));
constexpr size_t pkt_shift = sizeof(ProtoKelCodec::PacketLengthT); constexpr size_t pkt_shift = sizeof(proto_kel_codec::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"); 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");
} }
SAW_TEST("List Encoding"){ SAW_TEST("List Encoding"){
using namespace saw; using namespace saw;
auto root = heapMessageRoot<TestTuple>(); auto root = new_heap_message_root<TestTuple>();
auto builder = root.build(); auto builder = root.build();
auto first = builder.init<0>(); auto first = builder.init<0>();
@ -55,7 +55,7 @@ SAW_TEST("List Encoding"){
second.set(43871); second.set(43871);
ring_buffer buffer; ring_buffer buffer;
ProtoKelCodec codec; proto_kel_codec codec;
error err = codec.encode<TestTuple>(root.read(), buffer); error err = codec.encode<TestTuple>(root.read(), buffer);
@ -67,7 +67,7 @@ SAW_TEST("List Encoding"){
SAW_TEST("Struct Encoding"){ SAW_TEST("Struct Encoding"){
using namespace saw; using namespace saw;
auto root = heapMessageRoot<TestStruct>(); auto root = new_heap_message_root<TestStruct>();
auto builder = root.build(); auto builder = root.build();
auto test_uint = builder.init<"test_uint">(); auto test_uint = builder.init<"test_uint">();
@ -81,7 +81,7 @@ SAW_TEST("Struct Encoding"){
string_name.set("test_name"); string_name.set("test_name");
ring_buffer buffer; ring_buffer buffer;
ProtoKelCodec codec; proto_kel_codec codec;
error err = codec.encode<TestStruct>(builder.as_reader(), buffer); error err = codec.encode<TestStruct>(builder.as_reader(), buffer);
@ -94,14 +94,14 @@ SAW_TEST("Struct Encoding"){
SAW_TEST("Union Encoding"){ SAW_TEST("Union Encoding"){
using namespace saw; using namespace saw;
{ {
auto root = heapMessageRoot<TestUnion>(); auto root = new_heap_message_root<TestUnion>();
auto builder = root.build(); auto builder = root.build();
auto test_uint = builder.init<"test_uint">(); auto test_uint = builder.init<"test_uint">();
test_uint.set(23); test_uint.set(23);
ring_buffer buffer; ring_buffer buffer;
ProtoKelCodec codec; proto_kel_codec codec;
error err = codec.encode<TestUnion>(builder.as_reader(), buffer); error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
@ -111,14 +111,14 @@ SAW_TEST("Union Encoding"){
== buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex()); == buffer.to_hex(), "Not equal encoding:\n"+buffer.to_hex());
} }
{ {
auto root = heapMessageRoot<TestUnion>(); auto root = new_heap_message_root<TestUnion>();
auto builder = root.build(); auto builder = root.build();
auto test_string = builder.init<"test_string">(); auto test_string = builder.init<"test_string">();
test_string.set("foo"); test_string.set("foo");
ring_buffer buffer; ring_buffer buffer;
ProtoKelCodec codec; proto_kel_codec codec;
error err = codec.encode<TestUnion>(builder.as_reader(), buffer); error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
@ -136,9 +136,9 @@ SAW_TEST("Tuple Decoding"){
ring_buffer buffer; ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw)); buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec; proto_kel_codec codec;
auto root = heapMessageRoot<TestTuple>(); auto root = new_heap_message_root<TestTuple>();
auto builder = root.build(); auto builder = root.build();
error err = codec.decode<TestTuple>(builder, buffer); error err = codec.decode<TestTuple>(builder, buffer);
@ -159,9 +159,9 @@ SAW_TEST("Struct Decoding"){
ring_buffer buffer; ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw)); buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec; proto_kel_codec codec;
auto root = heapMessageRoot<TestStruct>(); auto root = new_heap_message_root<TestStruct>();
auto builder = root.build(); auto builder = root.build();
error err = codec.decode<TestStruct>(builder, buffer); error err = codec.decode<TestStruct>(builder, buffer);
@ -182,16 +182,16 @@ SAW_TEST("Union Decoding"){
ring_buffer buffer; ring_buffer buffer;
buffer.push(*buffer_raw, sizeof(buffer_raw)); buffer.push(*buffer_raw, sizeof(buffer_raw));
ProtoKelCodec codec; proto_kel_codec codec;
auto root = heapMessageRoot<TestUnion>(); auto root = new_heap_message_root<TestUnion>();
auto builder = root.build(); auto builder = root.build();
auto reader = builder.as_reader(); auto reader = builder.as_reader();
error err = codec.decode<TestUnion>(builder, buffer); error err = codec.decode<TestUnion>(builder, buffer);
SAW_EXPECT(!err.failed(), err.message()); SAW_EXPECT(!err.failed(), err.message());
SAW_EXPECT(reader.hasAlternative<"test_string">(), "Wrong union value"); SAW_EXPECT(reader.has_alternative<"test_string">(), "Wrong union value");
auto str_rd = reader.get<"test_string">(); auto str_rd = reader.get<"test_string">();
SAW_EXPECT(str_rd.get() == "foo", "Wrong value: " + std::string{str_rd.get()}); SAW_EXPECT(str_rd.get() == "foo", "Wrong value: " + std::string{str_rd.get()});
} }
@ -203,8 +203,8 @@ using TestArrayStruct = schema::Array<
SAW_TEST("Array Encoding"){ SAW_TEST("Array Encoding"){
using namespace saw; using namespace saw;
ProtoKelCodec codec; proto_kel_codec codec;
auto root = heapMessageRoot<TestArrayStruct>(); auto root = new_heap_message_root<TestArrayStruct>();
auto builder = root.build(2); auto builder = root.build(2);
auto one = builder.init(0); auto one = builder.init(0);