renamed structs, methods and functions
parent
a83826552e
commit
4f10da77eb
|
|
@ -1,6 +1,9 @@
|
|||
Checks: '-*,readability-identifier-naming'
|
||||
CheckOptions:
|
||||
- { key: readability-identifier-naming.PrivateMemberSuffix, value: "_" }
|
||||
- { key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true }
|
||||
- { key: readability-identifier-naming.ProtectedMemberSuffix, value: "_" }
|
||||
- { key: readability-identifier-naming.ClassCase, value: "lower_case" }
|
||||
- { key: readability-identifier-naming.StructCase, value: "lower_case" }
|
||||
- { key: readability-identifier-naming.FunctionCase, value: "lower_case" }
|
||||
- { key: readability-identifier-naming.MethodCase, value: "lower_case" }
|
||||
|
|
|
|||
|
|
@ -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} {}
|
||||
|
||||
namespace {
|
||||
ssize_t unixReadMsg(int fd, void *buffer, size_t length) {
|
||||
ssize_t unix_read_msg(int fd, void *buffer, size_t length) {
|
||||
struct ::sockaddr_storage their_addr;
|
||||
socklen_t addr_len = sizeof(sockaddr_storage);
|
||||
return ::recvfrom(fd, buffer, length, 0,
|
||||
|
|
@ -137,15 +137,15 @@ ssize_t unixReadMsg(int fd, void *buffer, size_t length) {
|
|||
&addr_len);
|
||||
}
|
||||
|
||||
ssize_t unixWriteMsg(int fd, const void *buffer, size_t length,
|
||||
::sockaddr *dest_addr, socklen_t dest_addr_len) {
|
||||
ssize_t unix_write_msg(int fd, const void *buffer, size_t length,
|
||||
::sockaddr *dest_addr, socklen_t dest_addr_len) {
|
||||
|
||||
return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
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) {
|
||||
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);
|
||||
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);
|
||||
ssize_t write_bytes = unix_write_msg(fd(), buffer, length,
|
||||
sock_addr.get_raw(), sock_addr_length);
|
||||
if (write_bytes > 0) {
|
||||
return static_cast<size_t>(write_bytes);
|
||||
}
|
||||
|
|
@ -192,14 +192,14 @@ void unix_datagram::notify(uint32_t mask) {
|
|||
}
|
||||
|
||||
namespace {
|
||||
bool beginsWith(const std::string_view &viewed,
|
||||
const std::string_view &begins) {
|
||||
bool begins_with(const std::string_view &viewed,
|
||||
const std::string_view &begins) {
|
||||
return viewed.size() >= begins.size() &&
|
||||
viewed.compare(0, begins.size(), begins) == 0;
|
||||
}
|
||||
|
||||
std::variant<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();
|
||||
std::variant<unix_network_address, unix_network_address *> os_addr =
|
||||
std::visit(
|
||||
|
|
@ -221,7 +221,7 @@ translateNetworkAddressToUnixNetworkAddress(network_address &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) {
|
||||
return std::visit(
|
||||
[](auto &arg) -> unix_network_address & {
|
||||
|
|
@ -241,9 +241,10 @@ unix_network_address &translateToUnixAddressRef(
|
|||
} // namespace
|
||||
|
||||
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 =
|
||||
translateToUnixAddressRef(unix_addr_storage);
|
||||
translate_to_unix_address_ref(unix_addr_storage);
|
||||
|
||||
assert(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) {
|
||||
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
|
||||
auto unix_addr_storage =
|
||||
translate_network_address_to_unix_network_address(addr);
|
||||
unix_network_address &address =
|
||||
translateToUnixAddressRef(unix_addr_storage);
|
||||
translate_to_unix_address_ref(unix_addr_storage);
|
||||
|
||||
assert(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) {
|
||||
auto unix_addr_storage = translateNetworkAddressToUnixNetworkAddress(addr);
|
||||
auto unix_addr_storage =
|
||||
translate_network_address_to_unix_network_address(addr);
|
||||
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; }
|
||||
|
||||
|
|
@ -380,9 +383,9 @@ 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::string_view str_begins_with = "unix:";
|
||||
if (begins_with(addr_view, str_begins_with)) {
|
||||
addr_view.remove_prefix(str_begins_with.size());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -291,7 +291,7 @@ template <typename Func> conveyor_result<Func, void> exec_later(Func &&func);
|
|||
*/
|
||||
template <typename... Args>
|
||||
conveyor<std::tuple<Args...>>
|
||||
joinConveyors(std::tuple<conveyor<Args>...> &conveyors);
|
||||
join_conveyors(std::tuple<conveyor<Args>...> &conveyors);
|
||||
|
||||
template <typename T> class conveyor_feeder {
|
||||
public:
|
||||
|
|
@ -460,11 +460,11 @@ public:
|
|||
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
|
||||
|
||||
// Secret stuff
|
||||
|
|
|
|||
|
|
@ -106,7 +106,8 @@ template <typename T> class error_or final : public error_or_value {
|
|||
private:
|
||||
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:
|
||||
error_or() = default;
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ async_io_stream::async_io_stream(own<io_stream> str)
|
|||
.then([this]() { read_stepper_.read_step(*stream_); })
|
||||
.sink()},
|
||||
write_ready_{stream_->write_ready()
|
||||
.then([this]() { write_stepper_.writeStep(*stream_); })
|
||||
.then([this]() { write_stepper_.write_step(*stream_); })
|
||||
.sink()},
|
||||
read_disconnected_{stream_->on_read_disconnected()
|
||||
.then([this]() {
|
||||
|
|
@ -49,7 +49,7 @@ void async_io_stream::write(const void *buffer, size_t length) {
|
|||
|
||||
write_stepper_.write_task =
|
||||
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() {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
#include "io_helpers.h"
|
||||
#include "io_helpers.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()) {
|
||||
write_io_task &task = *write_task;
|
||||
|
||||
|
|
@ -82,4 +82,4 @@ void write_task_and_step_helper::writeStep(output_stream &writer) {
|
|||
}
|
||||
}
|
||||
|
||||
} // namespace saw
|
||||
} // namespace saw
|
||||
|
|
|
|||
|
|
@ -48,6 +48,6 @@ public:
|
|||
own<conveyor_feeder<size_t>> write_done = nullptr;
|
||||
|
||||
public:
|
||||
void writeStep(output_stream &writer);
|
||||
void write_step(output_stream &writer);
|
||||
};
|
||||
} // namespace saw
|
||||
|
|
|
|||
|
|
@ -17,13 +17,13 @@ public:
|
|||
*
|
||||
*/
|
||||
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);
|
||||
/**
|
||||
*
|
||||
*/
|
||||
streaming_io_peer(
|
||||
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
|
||||
own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
|
||||
own<async_io_stream> stream);
|
||||
|
||||
/**
|
||||
|
|
@ -35,26 +35,26 @@ public:
|
|||
/**
|
||||
* 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
|
||||
*/
|
||||
conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> &feeder();
|
||||
conveyor_feeder<heap_message_root<Outgoing, OutContainer>> &feeder();
|
||||
|
||||
conveyor<void> on_read_disconnected();
|
||||
|
||||
private:
|
||||
/// @unimplemented
|
||||
class peer_conveyor_feeder final
|
||||
: public conveyor_feeder<HeapMessageRoot<Outgoing, OutContainer>> {
|
||||
: public conveyor_feeder<heap_message_root<Outgoing, OutContainer>> {
|
||||
public:
|
||||
peer_conveyor_feeder(
|
||||
streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
|
||||
OutContainer, BufferT> &peer_)
|
||||
: peer_{peer_} {}
|
||||
|
||||
void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override {
|
||||
void feed(heap_message_root<Outgoing, OutContainer> &&data) override {
|
||||
(void)data;
|
||||
}
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ private:
|
|||
};
|
||||
|
||||
private:
|
||||
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>>
|
||||
own<conveyor_feeder<heap_message_root<Incoming, InContainer>>>
|
||||
incoming_feeder_ = nullptr;
|
||||
|
||||
own<async_io_stream> io_stream_;
|
||||
|
|
@ -96,8 +96,8 @@ template <typename Codec, typename Incoming, typename 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);
|
||||
conveyor<heap_message_root<Incoming, InContainer>>>
|
||||
new_streaming_io_peer(own<async_io_stream> stream);
|
||||
|
||||
} // namespace saw
|
||||
|
||||
|
|
|
|||
|
|
@ -2,58 +2,59 @@ namespace saw {
|
|||
|
||||
template <typename Codec, typename Incoming, typename Outgoing,
|
||||
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(
|
||||
own<conveyor_feeder<HeapMessageRoot<Incoming, InContainer>>> feed,
|
||||
own<conveyor_feeder<heap_message_root<Incoming, InContainer>>> feed,
|
||||
own<async_io_stream> str)
|
||||
: streaming_io_peer{std::move(feed), std::move(str), {}, {}, {}} {}
|
||||
|
||||
template <typename Codec, typename Incoming, typename Outgoing,
|
||||
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(
|
||||
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)
|
||||
: incoming_feeder_{std::move(feed)},
|
||||
io_stream_{std::move(stream)}, codec_{std::move(codec)},
|
||||
in_buffer_{std::move(in)}, out_buffer_{std::move(out)},
|
||||
sink_read_{io_stream_->read_done()
|
||||
.then([this](size_t bytes) -> error_or<void> {
|
||||
in_buffer_.write_advance(bytes);
|
||||
sink_read_{
|
||||
io_stream_->read_done()
|
||||
.then([this](size_t bytes) -> error_or<void> {
|
||||
in_buffer_.write_advance(bytes);
|
||||
|
||||
if (in_buffer_.write_segment_length() == 0) {
|
||||
return critical_error("Message too long");
|
||||
}
|
||||
if (in_buffer_.write_segment_length() == 0) {
|
||||
return critical_error("Message too long");
|
||||
}
|
||||
|
||||
io_stream_->read(&in_buffer_.write(), 1,
|
||||
in_buffer_.write_segment_length());
|
||||
io_stream_->read(&in_buffer_.write(), 1,
|
||||
in_buffer_.write_segment_length());
|
||||
|
||||
while (true) {
|
||||
auto root =
|
||||
heapMessageRoot<Incoming, InContainer>();
|
||||
auto builder = root.build();
|
||||
while (true) {
|
||||
auto root = heap_message_root<Incoming, InContainer>();
|
||||
auto builder = root.build();
|
||||
|
||||
error err =
|
||||
codec_.template decode<Incoming, InContainer>(
|
||||
builder, in_buffer_);
|
||||
if (err.is_critical()) {
|
||||
return err;
|
||||
}
|
||||
error err = codec_.template decode<Incoming, InContainer>(
|
||||
builder, in_buffer_);
|
||||
if (err.is_critical()) {
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!err.failed()) {
|
||||
incoming_feeder_->feed(std::move(root));
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!err.failed()) {
|
||||
incoming_feeder_->feed(std::move(root));
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return void_t{};
|
||||
})
|
||||
.sink([this](error err) {
|
||||
incoming_feeder_->fail(err.copy_error());
|
||||
return void_t{};
|
||||
})
|
||||
.sink([this](error err) {
|
||||
incoming_feeder_->fail(err.copy_error());
|
||||
|
||||
return err;
|
||||
})},
|
||||
return err;
|
||||
})},
|
||||
sink_write_{io_stream_->write_done()
|
||||
.then([this](size_t bytes) -> error_or<void> {
|
||||
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,
|
||||
typename InContainer, typename OutContainer, typename BufferT>
|
||||
error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
||||
BufferT>::send(HeapMessageRoot<Outgoing, OutContainer>
|
||||
msg) {
|
||||
BufferT>::send(heap_message_root<Outgoing, OutContainer>
|
||||
msg) {
|
||||
bool restart_write = out_buffer_.read_segment_length() == 0;
|
||||
|
||||
error err =
|
||||
|
|
@ -83,7 +84,8 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
|||
}
|
||||
|
||||
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();
|
||||
|
|
@ -91,22 +93,24 @@ error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
|||
|
||||
template <typename Codec, typename Incoming, typename Outgoing,
|
||||
typename InContainer, typename OutContainer, typename BufferT>
|
||||
conveyor<void> streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
|
||||
OutContainer, BufferT>::on_read_disconnected() {
|
||||
conveyor<void>
|
||||
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
||||
BufferT>::on_read_disconnected() {
|
||||
return io_stream_->on_read_disconnected();
|
||||
}
|
||||
|
||||
template <typename Codec, typename Incoming, typename Outgoing,
|
||||
typename InContainer, typename OutContainer, typename BufferT>
|
||||
std::pair<own<streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
|
||||
OutContainer, BufferT>>,
|
||||
conveyor<HeapMessageRoot<Incoming, InContainer>>>
|
||||
OutContainer, BufferT>>,
|
||||
conveyor<heap_message_root<Incoming, InContainer>>>
|
||||
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,
|
||||
OutContainer, BufferT>>(std::move(caf.feeder),
|
||||
std::move(stream)),
|
||||
OutContainer, BufferT>>(
|
||||
std::move(caf.feeder), std::move(stream)),
|
||||
std::move(caf.conveyor)};
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -74,8 +74,8 @@ public:
|
|||
*/
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
!schema_is_array<
|
||||
typename message_parameter_pack_type<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
init() {
|
||||
return typename Container::template ElementType<i>::builder{
|
||||
|
|
@ -88,23 +88,23 @@ public:
|
|||
*/
|
||||
template <string_literal Literal>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<typename MessageParameterPackType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
|
||||
!schema_is_array<typename message_parameter_pack_type<
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value,
|
||||
V...>::Type>::Value,
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal,
|
||||
Keys...>::Value>::builder>::type
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::
|
||||
builder>::type
|
||||
init() {
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return init<i>();
|
||||
}
|
||||
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
schema_is_array<
|
||||
typename message_parameter_pack_type<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
init(size_t size = 0) {
|
||||
auto array_builder =
|
||||
|
|
@ -118,15 +118,15 @@ public:
|
|||
*/
|
||||
template <string_literal Literal>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<typename MessageParameterPackType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
|
||||
schema_is_array<typename message_parameter_pack_type<
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value,
|
||||
V...>::Type>::Value,
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal,
|
||||
Keys...>::Value>::builder>::type
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::
|
||||
builder>::type
|
||||
init(size_t size) {
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return init<i>(size);
|
||||
}
|
||||
|
|
@ -156,11 +156,11 @@ public:
|
|||
*/
|
||||
template <string_literal Literal>
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
|
||||
get() {
|
||||
// The index of the first match
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return get<i>();
|
||||
}
|
||||
|
|
@ -202,8 +202,8 @@ public:
|
|||
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
!schema_is_array<
|
||||
typename message_parameter_pack_type<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
|
||||
init() {
|
||||
|
|
@ -213,15 +213,15 @@ public:
|
|||
|
||||
template <string_literal Literal>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<typename MessageParameterPackType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
|
||||
!schema_is_array<typename message_parameter_pack_type<
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value,
|
||||
V...>::Type>::Value,
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal,
|
||||
Keys...>::Value>::builder>::type
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::
|
||||
builder>::type
|
||||
init() {
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return init<i>();
|
||||
}
|
||||
|
|
@ -231,8 +231,8 @@ public:
|
|||
*/
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
schema_is_array<
|
||||
typename message_parameter_pack_type<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
init(size_t size = 0) {
|
||||
return typename Container::template ElementType<i>::builder{
|
||||
|
|
@ -241,15 +241,15 @@ public:
|
|||
|
||||
template <string_literal Literal>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<typename MessageParameterPackType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value,
|
||||
schema_is_array<typename message_parameter_pack_type<
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value,
|
||||
V...>::Type>::Value,
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal,
|
||||
Keys...>::Value>::builder>::type
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::
|
||||
builder>::type
|
||||
init(size_t size) {
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return init<i>(size);
|
||||
}
|
||||
|
|
@ -272,24 +272,24 @@ public:
|
|||
|
||||
template <string_literal Literal>
|
||||
typename Container::template ElementType<
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value>::reader
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value>::reader
|
||||
get() {
|
||||
// The index of the first match
|
||||
constexpr size_t i =
|
||||
MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
|
||||
return get<i>();
|
||||
}
|
||||
|
||||
template <string_literal Literal>
|
||||
static constexpr size_t toIndex() noexcept {
|
||||
return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
static constexpr size_t to_index() noexcept {
|
||||
return message_parameter_key_pack_index<Literal, Keys...>::Value;
|
||||
}
|
||||
|
||||
size_t index() const noexcept { return message_.container_.index(); }
|
||||
|
||||
template <string_literal Literal> bool hasAlternative() const {
|
||||
return index() == toIndex<Literal>();
|
||||
template <string_literal Literal> bool has_alternative() const {
|
||||
return index() == to_index<Literal>();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
|
@ -383,8 +383,8 @@ public:
|
|||
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, T...>::Type>::Value,
|
||||
!schema_is_array<
|
||||
typename message_parameter_pack_type<i, T...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
init() {
|
||||
return typename Container::template ElementType<i>::builder{
|
||||
|
|
@ -393,8 +393,8 @@ public:
|
|||
|
||||
template <size_t i>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, T...>::Type>::Value,
|
||||
schema_is_array<
|
||||
typename message_parameter_pack_type<i, T...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::builder>::type
|
||||
init(size_t size = 0) {
|
||||
return typename Container::template ElementType<i>::builder{
|
||||
|
|
@ -511,12 +511,13 @@ public:
|
|||
};
|
||||
|
||||
template <class Schema, class Container = message_container<Schema>>
|
||||
class HeapMessageRoot {
|
||||
class heap_message_root {
|
||||
private:
|
||||
own<message<Schema, Container>> root_;
|
||||
|
||||
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() {
|
||||
assert(root_);
|
||||
|
|
@ -530,7 +531,7 @@ public:
|
|||
};
|
||||
|
||||
template <class T, class Container>
|
||||
class HeapMessageRoot<schema::Array<T>, Container> {
|
||||
class heap_message_root<schema::Array<T>, Container> {
|
||||
public:
|
||||
using Schema = schema::Array<T>;
|
||||
|
||||
|
|
@ -538,7 +539,8 @@ private:
|
|||
own<message<Schema, Container>> root_;
|
||||
|
||||
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) {
|
||||
assert(root_);
|
||||
|
|
@ -555,8 +557,8 @@ public:
|
|||
* Minor helper for creating a message root
|
||||
*/
|
||||
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>>();
|
||||
return HeapMessageRoot<Schema, Container>{std::move(root)};
|
||||
return heap_message_root<Schema, Container>{std::move(root)};
|
||||
}
|
||||
} // namespace saw
|
||||
|
|
|
|||
|
|
@ -10,16 +10,17 @@ template <class T> class message_container;
|
|||
|
||||
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;
|
||||
};
|
||||
|
||||
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");
|
||||
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;
|
||||
|
|
@ -40,31 +41,31 @@ struct MessageParameterPackIndex<T, TL0, TL...> {
|
|||
* This is the workaround
|
||||
*/
|
||||
template <string_literal V, string_literal Key0, string_literal... Keys>
|
||||
struct MessageParameterKeyPackIndexHelper {
|
||||
struct message_parameter_key_pack_index_helper {
|
||||
static constexpr size_t Value =
|
||||
(V == Key0)
|
||||
? (0u)
|
||||
: (1u + MessageParameterKeyPackIndexHelper<V, Keys...>::Value);
|
||||
: (1u + message_parameter_key_pack_index_helper<V, Keys...>::Value);
|
||||
};
|
||||
|
||||
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);
|
||||
};
|
||||
|
||||
template <string_literal V, string_literal... Keys>
|
||||
struct MessageParameterKeyPackIndex {
|
||||
struct message_parameter_key_pack_index {
|
||||
static constexpr size_t Value =
|
||||
MessageParameterKeyPackIndexHelper<V, Keys...>::Value;
|
||||
message_parameter_key_pack_index_helper<V, Keys...>::Value;
|
||||
static_assert(Value < sizeof...(Keys),
|
||||
"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;
|
||||
};
|
||||
|
||||
template <class T> struct SchemaIsArray<schema::Array<T>> {
|
||||
template <class T> struct schema_is_array<schema::Array<T>> {
|
||||
constexpr static bool Value = true;
|
||||
};
|
||||
|
||||
|
|
@ -78,7 +79,7 @@ public:
|
|||
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
|
||||
|
||||
template <size_t i>
|
||||
using ElementType = typename MessageParameterPackType<
|
||||
using ElementType = typename message_parameter_pack_type<
|
||||
i, message<V, message_container<V>>...>::Type;
|
||||
|
||||
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>...>;
|
||||
|
||||
template <size_t i>
|
||||
using ElementType = typename MessageParameterPackType<
|
||||
using ElementType = typename message_parameter_pack_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;
|
||||
using MessageIV =
|
||||
typename message_parameter_pack_type<i, V...>::Type;
|
||||
value_ = message<MessageIV, message_container<MessageIV>>{};
|
||||
}
|
||||
return std::get<i>(value_);
|
||||
|
|
@ -146,7 +148,7 @@ public:
|
|||
using SchemaType = schema::Tuple<T...>;
|
||||
|
||||
template <size_t i>
|
||||
using ElementType = typename MessageParameterPackType<
|
||||
using ElementType = typename message_parameter_pack_type<
|
||||
i, message<T, message_container<T>>...>::Type;
|
||||
|
||||
template <size_t i> ElementType<i> &get() { return std::get<i>(values_); }
|
||||
|
|
|
|||
|
|
@ -5,37 +5,37 @@
|
|||
#include "stream_endian.h"
|
||||
|
||||
namespace saw {
|
||||
class ProtoKelCodec {
|
||||
class proto_kel_codec {
|
||||
public:
|
||||
using UnionIdT = uint32_t;
|
||||
using ArrayLengthT = uint64_t;
|
||||
using PacketLengthT = uint64_t;
|
||||
|
||||
private:
|
||||
struct ReadContext {
|
||||
struct read_context {
|
||||
buffer &buffer;
|
||||
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:
|
||||
struct Limits {
|
||||
ProtoKelCodec::PacketLengthT packet_size;
|
||||
struct limits {
|
||||
proto_kel_codec::PacketLengthT packet_size;
|
||||
|
||||
Limits() : packet_size{4096} {}
|
||||
Limits(ProtoKelCodec::PacketLengthT ps) : packet_size{ps} {}
|
||||
limits() : packet_size{4096} {}
|
||||
limits(proto_kel_codec::PacketLengthT ps) : packet_size{ps} {}
|
||||
};
|
||||
|
||||
struct Version {
|
||||
struct version {
|
||||
size_t major;
|
||||
size_t minor;
|
||||
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>>
|
||||
error encode(typename message<Schema, Container>::reader reader,
|
||||
|
|
@ -43,13 +43,13 @@ public:
|
|||
|
||||
template <class Schema, class Container = message_container<Schema>>
|
||||
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>
|
||||
struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
|
||||
struct proto_kel_encode_impl<message<schema::Primitive<T, N>, Container>> {
|
||||
static error
|
||||
encode(typename message<schema::Primitive<T, N>, Container>::reader data,
|
||||
buffer &buffer) {
|
||||
|
|
@ -66,7 +66,7 @@ struct ProtoKelEncodeImpl<message<schema::Primitive<T, N>, Container>> {
|
|||
};
|
||||
|
||||
template <class Container>
|
||||
struct ProtoKelEncodeImpl<message<schema::String, Container>> {
|
||||
struct proto_kel_encode_impl<message<schema::String, Container>> {
|
||||
static error
|
||||
encode(typename message<schema::String, Container>::reader data,
|
||||
buffer &buffer) {
|
||||
|
|
@ -96,166 +96,170 @@ struct ProtoKelEncodeImpl<message<schema::String, 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>
|
||||
static typename std::enable_if<i == sizeof...(T), error>::type
|
||||
encodeMembers(typename message<schema::Tuple<T...>, Container>::reader,
|
||||
buffer &) {
|
||||
encode_members(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) {
|
||||
encode_members(
|
||||
typename message<schema::Tuple<T...>, Container>::reader data,
|
||||
buffer &buffer) {
|
||||
error err =
|
||||
ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
|
||||
proto_kel_encode_impl<typename Container::template ElementType<i>>::
|
||||
encode(data.template get<i>(), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
|
||||
return encodeMembers<i + 1>(data, buffer);
|
||||
return encode_members<i + 1>(data, buffer);
|
||||
}
|
||||
|
||||
static error
|
||||
encode(typename message<schema::Tuple<T...>, Container>::reader data,
|
||||
buffer &buffer) {
|
||||
return encodeMembers<0>(data, buffer);
|
||||
return encode_members<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) {
|
||||
size_members(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(
|
||||
i<sizeof...(T), size_t>::type size_members(
|
||||
typename message<schema::Tuple<T...>, Container>::reader reader) {
|
||||
return ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
|
||||
size(reader.template get<i>()) +
|
||||
sizeMembers<i + 1>(reader);
|
||||
return proto_kel_encode_impl<typename Container::template ElementType<
|
||||
i>>::size(reader.template get<i>()) +
|
||||
size_members<i + 1>(reader);
|
||||
}
|
||||
|
||||
static size_t
|
||||
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>
|
||||
struct ProtoKelEncodeImpl<
|
||||
struct proto_kel_encode_impl<
|
||||
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 &) {
|
||||
encode_members(
|
||||
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(
|
||||
i<sizeof...(V), error>::type encode_members(
|
||||
typename message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::reader data,
|
||||
buffer &buffer) {
|
||||
|
||||
error err =
|
||||
ProtoKelEncodeImpl<typename Container::template ElementType<i>>::
|
||||
proto_kel_encode_impl<typename Container::template ElementType<i>>::
|
||||
encode(data.template get<i>(), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
return encodeMembers<i + 1>(data, buffer);
|
||||
return encode_members<i + 1>(data, buffer);
|
||||
}
|
||||
|
||||
static error
|
||||
encode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::reader data,
|
||||
buffer &buffer) {
|
||||
return encodeMembers<0>(data, buffer);
|
||||
return encode_members<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) {
|
||||
size_members(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(
|
||||
i<sizeof...(V), size_t>::type size_members(
|
||||
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);
|
||||
return proto_kel_encode_impl<typename Container::template ElementType<
|
||||
i>>::size(reader.template get<i>()) +
|
||||
size_members<i + 1>(reader);
|
||||
}
|
||||
|
||||
static size_t
|
||||
size(typename message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::reader reader) {
|
||||
return sizeMembers<0>(reader);
|
||||
return size_members<0>(reader);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename... V, string_literal... K, class Container>
|
||||
struct ProtoKelEncodeImpl<
|
||||
struct proto_kel_encode_impl<
|
||||
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 &) {
|
||||
encode_members(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(
|
||||
i<sizeof...(V), error>::type encode_members(
|
||||
typename message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::reader reader,
|
||||
buffer &buffer) {
|
||||
if (reader.index() == i) {
|
||||
error err =
|
||||
stream_value<ProtoKelCodec::UnionIdT>::encode(i, buffer);
|
||||
stream_value<proto_kel_codec::UnionIdT>::encode(i, buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
return ProtoKelEncodeImpl<typename Container::template ElementType<
|
||||
i>>::encode(reader.template get<i>(), buffer);
|
||||
return proto_kel_encode_impl<
|
||||
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
|
||||
encode(typename message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::reader reader,
|
||||
buffer &buffer) {
|
||||
return encodeMembers<0>(reader, buffer);
|
||||
return encode_members<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) {
|
||||
size_members(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(
|
||||
i<sizeof...(V), size_t>::type size_members(
|
||||
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>());
|
||||
return proto_kel_encode_impl<
|
||||
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
|
||||
size(typename message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
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>
|
||||
struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
|
||||
struct proto_kel_encode_impl<message<schema::Array<T>, Container>> {
|
||||
static error
|
||||
encode(typename message<schema::Array<T>, Container>::reader data,
|
||||
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);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
|
|
@ -284,7 +288,7 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
|
|||
|
||||
for (size_t i = 0; i < array_length; ++i) {
|
||||
error err =
|
||||
ProtoKelEncodeImpl<typename Container::ElementType>::encode(
|
||||
proto_kel_encode_impl<typename Container::ElementType>::encode(
|
||||
data.get(i), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
|
|
@ -298,10 +302,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
|
|||
*/
|
||||
static size_t
|
||||
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) {
|
||||
members +=
|
||||
ProtoKelEncodeImpl<typename Container::ElementType>::size(
|
||||
proto_kel_encode_impl<typename Container::ElementType>::size(
|
||||
data.get(i));
|
||||
}
|
||||
|
||||
|
|
@ -312,10 +316,10 @@ struct ProtoKelEncodeImpl<message<schema::Array<T>, Container>> {
|
|||
/*
|
||||
* Decode Implementations
|
||||
*/
|
||||
template <typename T> struct ProtoKelDecodeImpl;
|
||||
template <typename T> struct proto_kel_decode_impl;
|
||||
|
||||
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
|
||||
decode(typename message<schema::Primitive<T, N>, Container>::builder data,
|
||||
buffer &buffer) {
|
||||
|
|
@ -328,7 +332,7 @@ struct ProtoKelDecodeImpl<message<schema::Primitive<T, N>, Container>> {
|
|||
};
|
||||
|
||||
template <class Container>
|
||||
struct ProtoKelDecodeImpl<message<schema::String, Container>> {
|
||||
struct proto_kel_decode_impl<message<schema::String, Container>> {
|
||||
static error
|
||||
decode(typename message<schema::String, Container>::builder data,
|
||||
buffer &buffer) {
|
||||
|
|
@ -362,107 +366,108 @@ struct ProtoKelDecodeImpl<message<schema::String, 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>
|
||||
static typename std::enable_if<i == sizeof...(T), error>::type
|
||||
decodeMembers(typename message<schema::Tuple<T...>, Container>::builder,
|
||||
buffer &) {
|
||||
decode_members(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(
|
||||
i<sizeof...(T), error>::type decode_members(
|
||||
typename message<schema::Tuple<T...>, Container>::builder builder,
|
||||
buffer &buffer) {
|
||||
|
||||
error err =
|
||||
ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
|
||||
proto_kel_decode_impl<typename Container::template ElementType<i>>::
|
||||
decode(builder.template init<i>(), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
return decodeMembers<i + 1>(builder, buffer);
|
||||
return decode_members<i + 1>(builder, buffer);
|
||||
}
|
||||
|
||||
static error
|
||||
decode(typename message<schema::Tuple<T...>, Container>::builder builder,
|
||||
buffer &buffer) {
|
||||
return decodeMembers<0>(builder, buffer);
|
||||
return decode_members<0>(builder, buffer);
|
||||
}
|
||||
};
|
||||
|
||||
template <class... V, string_literal... K, class Container>
|
||||
struct ProtoKelDecodeImpl<
|
||||
struct proto_kel_decode_impl<
|
||||
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 &) {
|
||||
decode_members(
|
||||
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(
|
||||
i<sizeof...(V), error>::type decode_members(
|
||||
typename message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::builder builder,
|
||||
buffer &buffer) {
|
||||
|
||||
error err =
|
||||
ProtoKelDecodeImpl<typename Container::template ElementType<i>>::
|
||||
proto_kel_decode_impl<typename Container::template ElementType<i>>::
|
||||
decode(builder.template init<i>(), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
return decodeMembers<i + 1>(builder, buffer);
|
||||
return decode_members<i + 1>(builder, buffer);
|
||||
}
|
||||
|
||||
static error
|
||||
decode(typename message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::builder builder,
|
||||
buffer &buffer) {
|
||||
return decodeMembers<0>(builder, buffer);
|
||||
return decode_members<0>(builder, buffer);
|
||||
}
|
||||
};
|
||||
|
||||
template <class... V, string_literal... K, class Container>
|
||||
struct ProtoKelDecodeImpl<
|
||||
struct proto_kel_decode_impl<
|
||||
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) {
|
||||
decode_members(typename message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::builder,
|
||||
buffer &, proto_kel_codec::UnionIdT) {
|
||||
return no_error();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
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>...>,
|
||||
Container>::builder builder,
|
||||
buffer &buffer, ProtoKelCodec::UnionIdT id) {
|
||||
buffer &buffer, proto_kel_codec::UnionIdT id) {
|
||||
|
||||
if (id == i) {
|
||||
error err =
|
||||
ProtoKelDecodeImpl<typename Container::template ElementType<
|
||||
proto_kel_decode_impl<typename Container::template ElementType<
|
||||
i>>::decode(builder.template init<i>(), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
return decodeMembers<i + 1>(builder, buffer, id);
|
||||
return decode_members<i + 1>(builder, buffer, id);
|
||||
}
|
||||
|
||||
static error
|
||||
decode(typename message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::builder builder,
|
||||
buffer &buffer) {
|
||||
ProtoKelCodec::UnionIdT id = 0;
|
||||
error err = stream_value<ProtoKelCodec::UnionIdT>::decode(id, buffer);
|
||||
proto_kel_codec::UnionIdT id = 0;
|
||||
error err = stream_value<proto_kel_codec::UnionIdT>::decode(id, buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
|
|
@ -470,18 +475,18 @@ struct ProtoKelDecodeImpl<
|
|||
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>
|
||||
struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
|
||||
struct proto_kel_decode_impl<message<schema::Array<T>, Container>> {
|
||||
static error
|
||||
decode(typename message<schema::Array<T>, Container>::builder data,
|
||||
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);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
|
|
@ -492,7 +497,7 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
|
|||
|
||||
for (size_t i = 0; i < array_length; ++i) {
|
||||
error err =
|
||||
ProtoKelDecodeImpl<typename Container::ElementType>::decode(
|
||||
proto_kel_decode_impl<typename Container::ElementType>::decode(
|
||||
data.init(i), buffer);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
|
|
@ -503,30 +508,30 @@ struct ProtoKelDecodeImpl<message<schema::Array<T>, Container>> {
|
|||
};
|
||||
|
||||
template <class Schema, class Container>
|
||||
error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
|
||||
buffer &buffer) {
|
||||
error proto_kel_codec::encode(
|
||||
typename message<Schema, Container>::reader reader, buffer &buffer) {
|
||||
buffer_view view{buffer};
|
||||
|
||||
ProtoKelCodec::PacketLengthT packet_length =
|
||||
ProtoKelEncodeImpl<message<Schema, Container>>::size(reader);
|
||||
proto_kel_codec::PacketLengthT packet_length =
|
||||
proto_kel_encode_impl<message<Schema, Container>>::size(reader);
|
||||
// Check the size of the packet for the first
|
||||
// message length description
|
||||
|
||||
error err = view.write_require_length(packet_length +
|
||||
sizeof(ProtoKelCodec::PacketLengthT));
|
||||
error err = view.write_require_length(
|
||||
packet_length + sizeof(proto_kel_codec::PacketLengthT));
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
|
||||
{
|
||||
error err = stream_value<ProtoKelCodec::PacketLengthT>::encode(
|
||||
error err = stream_value<proto_kel_codec::PacketLengthT>::encode(
|
||||
packet_length, view);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
{
|
||||
error err = ProtoKelEncodeImpl<message<Schema, Container>>::encode(
|
||||
error err = proto_kel_encode_impl<message<Schema, Container>>::encode(
|
||||
reader, view);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
|
|
@ -538,14 +543,14 @@ error ProtoKelCodec::encode(typename message<Schema, Container>::reader reader,
|
|||
}
|
||||
|
||||
template <class Schema, class Container>
|
||||
error ProtoKelCodec::decode(
|
||||
error proto_kel_codec::decode(
|
||||
typename message<Schema, Container>::builder builder, buffer &buffer,
|
||||
const Limits &limits) {
|
||||
const limits &limits) {
|
||||
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);
|
||||
if (err.failed()) {
|
||||
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);
|
||||
if (err.failed()) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
{
|
||||
if (ProtoKelEncodeImpl<message<Schema, Container>>::size(
|
||||
if (proto_kel_encode_impl<message<Schema, Container>>::size(
|
||||
builder.as_reader()) != packet_length) {
|
||||
return critical_error("Bad packet format");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
namespace saw {
|
||||
namespace schema {
|
||||
|
||||
// NOLINTBEGIN
|
||||
template <typename T, string_literal Literal> struct NamedMember {};
|
||||
|
||||
template <typename... T> struct Struct {
|
||||
|
|
@ -72,5 +72,6 @@ template <class... T> struct Interface {
|
|||
template <class... Request, class... Response, string_literal... Literal>
|
||||
struct Interface<Function<Request, Response, Literal>...> {};
|
||||
|
||||
// NOLINTEND
|
||||
} // namespace schema
|
||||
} // namespace saw
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ using TestTuple = schema::Tuple<schema::UInt32, schema::String>;
|
|||
SAW_TEST("Message Tuple"){
|
||||
std::string test_string_1 = "banana";
|
||||
|
||||
auto root = saw::heapMessageRoot<TestTuple>();
|
||||
auto root = saw::new_heap_message_root<TestTuple>();
|
||||
auto builder = root.build();
|
||||
auto uint = builder.init<0>();
|
||||
uint.set(10);
|
||||
|
|
@ -36,7 +36,7 @@ SAW_TEST("Message Tuple nested"){
|
|||
std::string test_string_1 = "banana";
|
||||
std::string test_string_2 = "bat";
|
||||
|
||||
auto root = saw::heapMessageRoot<NestedTestTuple>();
|
||||
auto root = saw::new_heap_message_root<NestedTestTuple>();
|
||||
auto builder = root.build();
|
||||
auto inner_list = builder.init<0>();
|
||||
auto uint = inner_list.init<0>();
|
||||
|
|
@ -64,7 +64,7 @@ using TestStruct = schema::Struct<
|
|||
|
||||
SAW_TEST("Message Struct"){
|
||||
std::string test_string = "foo";
|
||||
auto root = saw::heapMessageRoot<TestStruct>();
|
||||
auto root = saw::new_heap_message_root<TestStruct>();
|
||||
auto builder = root.build();
|
||||
auto uint = builder.init<"test_uint">();
|
||||
uint.set(23);
|
||||
|
|
@ -103,7 +103,7 @@ void arrayCheck(saw::message<TestArray>::builder builder){
|
|||
}
|
||||
|
||||
SAW_TEST("Message Array"){
|
||||
auto root = saw::heapMessageRoot<TestArray>();
|
||||
auto root = saw::new_heap_message_root<TestArray>();
|
||||
|
||||
auto builder = root.build(3);
|
||||
|
||||
|
|
@ -115,7 +115,7 @@ using TestArrayStruct = schema::Struct<
|
|||
>;
|
||||
|
||||
SAW_TEST("Message Array in Struct"){
|
||||
auto root = saw::heapMessageRoot<TestArrayStruct>();
|
||||
auto root = saw::new_heap_message_root<TestArrayStruct>();
|
||||
|
||||
auto builder = root.build();
|
||||
|
||||
|
|
|
|||
|
|
@ -27,26 +27,26 @@ SAW_TEST("Primitive Encoding"){
|
|||
using namespace saw;
|
||||
uint32_t value = 5;
|
||||
|
||||
auto root = heapMessageRoot<TestSize>();
|
||||
auto root = new_heap_message_root<TestSize>();
|
||||
auto builder = root.build();
|
||||
|
||||
builder.set(value);
|
||||
|
||||
ring_buffer temp_buffer;
|
||||
ProtoKelCodec codec;
|
||||
proto_kel_codec codec;
|
||||
|
||||
error err = codec.encode<TestSize>(root.read(), temp_buffer);
|
||||
|
||||
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.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(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_TEST("List Encoding"){
|
||||
using namespace saw;
|
||||
|
||||
auto root = heapMessageRoot<TestTuple>();
|
||||
auto root = new_heap_message_root<TestTuple>();
|
||||
auto builder = root.build();
|
||||
|
||||
auto first = builder.init<0>();
|
||||
|
|
@ -55,7 +55,7 @@ SAW_TEST("List Encoding"){
|
|||
second.set(43871);
|
||||
|
||||
ring_buffer buffer;
|
||||
ProtoKelCodec codec;
|
||||
proto_kel_codec codec;
|
||||
|
||||
error err = codec.encode<TestTuple>(root.read(), buffer);
|
||||
|
||||
|
|
@ -67,7 +67,7 @@ SAW_TEST("List Encoding"){
|
|||
SAW_TEST("Struct Encoding"){
|
||||
using namespace saw;
|
||||
|
||||
auto root = heapMessageRoot<TestStruct>();
|
||||
auto root = new_heap_message_root<TestStruct>();
|
||||
auto builder = root.build();
|
||||
|
||||
auto test_uint = builder.init<"test_uint">();
|
||||
|
|
@ -81,7 +81,7 @@ SAW_TEST("Struct Encoding"){
|
|||
string_name.set("test_name");
|
||||
|
||||
ring_buffer buffer;
|
||||
ProtoKelCodec codec;
|
||||
proto_kel_codec codec;
|
||||
|
||||
error err = codec.encode<TestStruct>(builder.as_reader(), buffer);
|
||||
|
||||
|
|
@ -94,14 +94,14 @@ SAW_TEST("Struct Encoding"){
|
|||
SAW_TEST("Union Encoding"){
|
||||
using namespace saw;
|
||||
{
|
||||
auto root = heapMessageRoot<TestUnion>();
|
||||
auto root = new_heap_message_root<TestUnion>();
|
||||
auto builder = root.build();
|
||||
|
||||
auto test_uint = builder.init<"test_uint">();
|
||||
test_uint.set(23);
|
||||
|
||||
ring_buffer buffer;
|
||||
ProtoKelCodec codec;
|
||||
proto_kel_codec codec;
|
||||
|
||||
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());
|
||||
}
|
||||
{
|
||||
auto root = heapMessageRoot<TestUnion>();
|
||||
auto root = new_heap_message_root<TestUnion>();
|
||||
auto builder = root.build();
|
||||
|
||||
auto test_string = builder.init<"test_string">();
|
||||
test_string.set("foo");
|
||||
|
||||
ring_buffer buffer;
|
||||
ProtoKelCodec codec;
|
||||
proto_kel_codec codec;
|
||||
|
||||
error err = codec.encode<TestUnion>(builder.as_reader(), buffer);
|
||||
|
||||
|
|
@ -136,9 +136,9 @@ SAW_TEST("Tuple Decoding"){
|
|||
ring_buffer buffer;
|
||||
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();
|
||||
|
||||
error err = codec.decode<TestTuple>(builder, buffer);
|
||||
|
|
@ -159,9 +159,9 @@ SAW_TEST("Struct Decoding"){
|
|||
ring_buffer buffer;
|
||||
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();
|
||||
|
||||
error err = codec.decode<TestStruct>(builder, buffer);
|
||||
|
|
@ -182,16 +182,16 @@ SAW_TEST("Union Decoding"){
|
|||
ring_buffer buffer;
|
||||
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 reader = builder.as_reader();
|
||||
|
||||
error err = codec.decode<TestUnion>(builder, buffer);
|
||||
|
||||
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">();
|
||||
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"){
|
||||
using namespace saw;
|
||||
|
||||
ProtoKelCodec codec;
|
||||
auto root = heapMessageRoot<TestArrayStruct>();
|
||||
proto_kel_codec codec;
|
||||
auto root = new_heap_message_root<TestArrayStruct>();
|
||||
auto builder = root.build(2);
|
||||
|
||||
auto one = builder.init(0);
|
||||
|
|
|
|||
Loading…
Reference in New Issue