more tidy fixes
parent
76121c563d
commit
b1f8ac8334
|
|
@ -1,7 +1,9 @@
|
|||
Checks: '-*,readability-identifier-naming'
|
||||
CheckOptions:
|
||||
- { key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true }
|
||||
- { key: readability-identifier-naming.NamespaceCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.ClassCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.TemplateParameterCase, value: CamelCase }
|
||||
- { key: readability-identifier-naming.StructCase, value: CamelCase }
|
||||
- { key: readability-identifier-naming.FunctionCase, value: lower_case }
|
||||
- { key: readability-identifier-naming.ParameterCase, value: lower_case }
|
||||
|
|
|
|||
124
driver/io-unix.h
124
driver/io-unix.h
|
|
@ -38,9 +38,9 @@ protected:
|
|||
UnixEventPort &event_port;
|
||||
|
||||
private:
|
||||
int file_descriptor;
|
||||
int fd_flags;
|
||||
uint32_t event_mask;
|
||||
int m_file_descriptor;
|
||||
int m_fd_flags;
|
||||
uint32_t m_event_mask;
|
||||
|
||||
public:
|
||||
i_fd_owner(UnixEventPort &event_port, int file_descriptor, int fd_flags,
|
||||
|
|
@ -50,19 +50,19 @@ public:
|
|||
|
||||
virtual void notify(uint32_t mask) = 0;
|
||||
|
||||
int fd() const { return file_descriptor; }
|
||||
int fd() const { return m_file_descriptor; }
|
||||
};
|
||||
|
||||
class UnixEventPort final : public EventPort {
|
||||
private:
|
||||
int epoll_fd;
|
||||
int signal_fd;
|
||||
int m_epoll_fd;
|
||||
int m_signal_fd;
|
||||
|
||||
sigset_t signal_fd_set;
|
||||
sigset_t m_signal_fd_set;
|
||||
|
||||
std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>> signal_conveyors;
|
||||
std::unordered_multimap<Signal, Own<ConveyorFeeder<void>>> m_signal_conveyors;
|
||||
|
||||
int pipefds[2];
|
||||
int m_pipefds[2];
|
||||
|
||||
std::vector<int> to_unix_signal(Signal signal) const {
|
||||
switch (signal) {
|
||||
|
|
@ -105,7 +105,7 @@ private:
|
|||
epoll_event events[max_epoll_events];
|
||||
int nfds = 0;
|
||||
do {
|
||||
nfds = epoll_wait(epoll_fd, events, max_epoll_events, time);
|
||||
nfds = epoll_wait(m_epoll_fd, events, max_epoll_events, time);
|
||||
|
||||
if (nfds < 0) {
|
||||
/// @todo error_handling
|
||||
|
|
@ -117,7 +117,7 @@ private:
|
|||
while (1) {
|
||||
struct ::signalfd_siginfo siginfo;
|
||||
ssize_t n =
|
||||
::read(signal_fd, &siginfo, sizeof(siginfo));
|
||||
::read(m_signal_fd, &siginfo, sizeof(siginfo));
|
||||
if (n < 0) {
|
||||
break;
|
||||
}
|
||||
|
|
@ -127,11 +127,11 @@ private:
|
|||
}
|
||||
} else if (events[i].data.u64 == 1) {
|
||||
uint8_t i;
|
||||
if (pipefds[0] < 0) {
|
||||
if (m_pipefds[0] < 0) {
|
||||
continue;
|
||||
}
|
||||
while (1) {
|
||||
ssize_t n = ::recv(pipefds[0], &i, sizeof(i), 0);
|
||||
ssize_t n = ::recv(m_pipefds[0], &i, sizeof(i), 0);
|
||||
if (n < 0) {
|
||||
break;
|
||||
}
|
||||
|
|
@ -150,17 +150,17 @@ private:
|
|||
}
|
||||
|
||||
public:
|
||||
UnixEventPort() : epoll_fd{-1}, signal_fd{-1} {
|
||||
UnixEventPort() : m_epoll_fd{-1}, m_signal_fd{-1} {
|
||||
::signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
epoll_fd = ::epoll_create1(EPOLL_CLOEXEC);
|
||||
if (epoll_fd < 0) {
|
||||
m_epoll_fd = ::epoll_create1(EPOLL_CLOEXEC);
|
||||
if (m_epoll_fd < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
::sigemptyset(&signal_fd_set);
|
||||
signal_fd = ::signalfd(-1, &signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
|
||||
if (signal_fd < 0) {
|
||||
::sigemptyset(&m_signal_fd_set);
|
||||
m_signal_fd = ::signalfd(-1, &m_signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
|
||||
if (m_signal_fd < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -168,23 +168,23 @@ public:
|
|||
memset(&event, 0, sizeof(event));
|
||||
event.events = EPOLLIN;
|
||||
event.data.u64 = 0;
|
||||
::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, signal_fd, &event);
|
||||
::epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, m_signal_fd, &event);
|
||||
|
||||
int rc = ::pipe2(pipefds, O_NONBLOCK | O_CLOEXEC);
|
||||
int rc = ::pipe2(m_pipefds, O_NONBLOCK | O_CLOEXEC);
|
||||
if (rc < 0) {
|
||||
return;
|
||||
}
|
||||
memset(&event, 0, sizeof(event));
|
||||
event.events = EPOLLIN;
|
||||
event.data.u64 = 1;
|
||||
::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipefds[0], &event);
|
||||
::epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, m_pipefds[0], &event);
|
||||
}
|
||||
|
||||
~UnixEventPort() {
|
||||
::close(epoll_fd);
|
||||
::close(signal_fd);
|
||||
::close(pipefds[0]);
|
||||
::close(pipefds[1]);
|
||||
::close(m_epoll_fd);
|
||||
::close(m_signal_fd);
|
||||
::close(m_pipefds[0]);
|
||||
::close(m_pipefds[1]);
|
||||
}
|
||||
|
||||
Conveyor<void> on_signal(Signal signal) override {
|
||||
|
|
@ -197,8 +197,8 @@ public:
|
|||
for (auto iter = sig.begin(); iter != sig.end(); ++iter) {
|
||||
::sigaddset(&signal_fd_set, *iter);
|
||||
}
|
||||
::sigprocmask(SIG_BLOCK, &signal_fd_set, nullptr);
|
||||
::signalfd(signal_fd, &signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
|
||||
::sigprocmask(SIG_BLOCK, &m_signal_fd_set, nullptr);
|
||||
::signalfd(m_signal_fd, &m_signal_fd_set, SFD_NONBLOCK | SFD_CLOEXEC);
|
||||
|
||||
auto node = Conveyor<void>::fromConveyor(std::move(caf.conveyor));
|
||||
return Conveyor<void>::toConveyor(std::move(node));
|
||||
|
|
@ -228,15 +228,15 @@ public:
|
|||
void wake() override {
|
||||
/// @todo pipe() in the beginning and write something minor into it like
|
||||
/// uint8_t or sth the value itself doesn't matter
|
||||
if (pipefds[1] < 0) {
|
||||
if (m_pipefds[1] < 0) {
|
||||
return;
|
||||
}
|
||||
uint8_t i = 0;
|
||||
::send(pipefds[1], &i, sizeof(i), MSG_DONTWAIT);
|
||||
::send(m_pipefds[1], &i, sizeof(i), MSG_DONTWAIT);
|
||||
}
|
||||
|
||||
void subscribe(i_fd_owner &owner, int fd, uint32_t event_mask) {
|
||||
if (epoll_fd < 0 || fd < 0) {
|
||||
if (m_epoll_fd < 0 || fd < 0) {
|
||||
return;
|
||||
}
|
||||
::epoll_event event;
|
||||
|
|
@ -244,17 +244,17 @@ public:
|
|||
event.events = event_mask | EPOLLET;
|
||||
event.data.ptr = &owner;
|
||||
|
||||
if (::epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event) < 0) {
|
||||
if (::epoll_ctl(m_epoll_fd, EPOLL_CTL_ADD, fd, &event) < 0) {
|
||||
/// @todo error_handling
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
void unsubscribe(int fd) {
|
||||
if (epoll_fd < 0 || fd < 0) {
|
||||
if (m_epoll_fd < 0 || fd < 0) {
|
||||
return;
|
||||
}
|
||||
if (::epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, nullptr) < 0) {
|
||||
if (::epoll_ctl(m_epoll_fd, EPOLL_CTL_DEL, fd, nullptr) < 0) {
|
||||
/// @todo error_handling
|
||||
return;
|
||||
}
|
||||
|
|
@ -266,9 +266,9 @@ ssize_t unix_write(int fd, const void *buffer, size_t length);
|
|||
|
||||
class unix_io_stream final : public IoStream, public i_fd_owner {
|
||||
private:
|
||||
Own<ConveyorFeeder<void>> read_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> on_read_disconnect = nullptr;
|
||||
Own<ConveyorFeeder<void>> write_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> m_read_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> m_on_read_disconnect = nullptr;
|
||||
Own<ConveyorFeeder<void>> m_write_ready = nullptr;
|
||||
|
||||
public:
|
||||
unix_io_stream(UnixEventPort &event_port, int file_descriptor, int fd_flags,
|
||||
|
|
@ -301,7 +301,7 @@ public:
|
|||
|
||||
class unix_server final : public Server, public i_fd_owner {
|
||||
private:
|
||||
Own<ConveyorFeeder<Own<IoStream>>> accept_feeder = nullptr;
|
||||
Own<ConveyorFeeder<Own<IoStream>>> m_accept_feeder = nullptr;
|
||||
|
||||
public:
|
||||
unix_server(UnixEventPort &event_port, int file_descriptor, int fd_flags);
|
||||
|
|
@ -313,8 +313,8 @@ public:
|
|||
|
||||
class unix_datagram final : public Datagram, public i_fd_owner {
|
||||
private:
|
||||
Own<ConveyorFeeder<void>> read_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> write_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> m_read_ready = nullptr;
|
||||
Own<ConveyorFeeder<void>> m_write_ready = nullptr;
|
||||
|
||||
public:
|
||||
unix_datagram(UnixEventPort &event_port, int file_descriptor, int fd_flags);
|
||||
|
|
@ -340,43 +340,43 @@ private:
|
|||
struct sockaddr_in inet;
|
||||
struct sockaddr_in6 inet6;
|
||||
struct sockaddr_storage storage;
|
||||
} address;
|
||||
} m_address;
|
||||
|
||||
socklen_t address_length;
|
||||
bool wildcard;
|
||||
socklen_t m_address_length;
|
||||
bool m_wildcard;
|
||||
|
||||
socket_address() : wildcard{false} {}
|
||||
socket_address() : m_wildcard{false} {}
|
||||
|
||||
public:
|
||||
socket_address(const void *sockaddr, socklen_t len, bool wildcard)
|
||||
: address_length{len}, wildcard{wildcard} {
|
||||
assert(len <= sizeof(address));
|
||||
memcpy(&address.generic, sockaddr, len);
|
||||
: m_address_length{len}, m_wildcard{wildcard} {
|
||||
assert(len <= sizeof(m_address));
|
||||
memcpy(&m_address.generic, sockaddr, len);
|
||||
}
|
||||
|
||||
int socket(int type) const {
|
||||
type |= SOCK_NONBLOCK | SOCK_CLOEXEC;
|
||||
|
||||
int result = ::socket(address.generic.sa_family, type, 0);
|
||||
int result = ::socket(m_address.generic.sa_family, type, 0);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool bind(int fd) const {
|
||||
if (wildcard) {
|
||||
if (m_wildcard) {
|
||||
int value = 0;
|
||||
::setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &value, sizeof(value));
|
||||
}
|
||||
int error = ::bind(fd, &address.generic, address_length);
|
||||
int error = ::bind(fd, &m_address.generic, m_address_length);
|
||||
return error < 0;
|
||||
}
|
||||
|
||||
struct ::sockaddr *get_raw() {
|
||||
return &address.generic;
|
||||
return &m_address.generic;
|
||||
}
|
||||
|
||||
const struct ::sockaddr *get_raw() const { return &address.generic; }
|
||||
const struct ::sockaddr *get_raw() const { return &m_address.generic; }
|
||||
|
||||
socklen_t get_raw_length() const { return address_length; }
|
||||
socklen_t get_raw_length() const { return m_address_length; }
|
||||
|
||||
static std::vector<socket_address> resolve(std::string_view str,
|
||||
uint16_t port_hint) {
|
||||
|
|
@ -399,7 +399,7 @@ public:
|
|||
}
|
||||
|
||||
for (struct ::addrinfo *it = head; it != nullptr; it = it->ai_next) {
|
||||
if (it->ai_addrlen > sizeof(socket_address::address)) {
|
||||
if (it->ai_addrlen > sizeof(socket_address::m_address)) {
|
||||
continue;
|
||||
}
|
||||
results.push_back({it->ai_addr, it->ai_addrlen, wildcard});
|
||||
|
|
@ -411,14 +411,14 @@ public:
|
|||
|
||||
class unix_network_address final : public OsNetworkAddress {
|
||||
private:
|
||||
const std::string path;
|
||||
uint16_t port_hint;
|
||||
std::vector<socket_address> addresses;
|
||||
const std::string m_path;
|
||||
uint16_t m_port_hint;
|
||||
std::vector<socket_address> m_addresses;
|
||||
|
||||
public:
|
||||
unix_network_address(const std::string &path, uint16_t port_hint,
|
||||
std::vector<socket_address> &&addr)
|
||||
: path{path}, port_hint{port_hint}, addresses{std::move(addr)} {}
|
||||
: m_path{path}, m_port_hint{port_hint}, addresses{std::move(addr)} {}
|
||||
|
||||
const std::string &address() const override;
|
||||
|
||||
|
|
@ -431,7 +431,7 @@ public:
|
|||
|
||||
class unix_network final : public Network {
|
||||
private:
|
||||
UnixEventPort &event_port;
|
||||
UnixEventPort &m_event_port;
|
||||
|
||||
public:
|
||||
unix_network(UnixEventPort &event_port);
|
||||
|
|
@ -449,10 +449,10 @@ public:
|
|||
|
||||
class unix_io_provider final : public IoProvider {
|
||||
private:
|
||||
UnixEventPort &event_port;
|
||||
EventLoop event_loop;
|
||||
UnixEventPort &m_event_port;
|
||||
EventLoop m_event_loop;
|
||||
|
||||
unix_network unix_network;
|
||||
unix_network m_unix_network;
|
||||
|
||||
public:
|
||||
unix_io_provider(UnixEventPort &port_ref, Own<EventPort> port);
|
||||
|
|
|
|||
|
|
@ -80,9 +80,9 @@ class WaitScope;
|
|||
*/
|
||||
class event {
|
||||
private:
|
||||
EventLoop &loop;
|
||||
event **prev = nullptr;
|
||||
event *next = nullptr;
|
||||
EventLoop &m_loop;
|
||||
event **m_prev = nullptr;
|
||||
event *m_next = nullptr;
|
||||
|
||||
friend class EventLoop;
|
||||
|
||||
|
|
@ -167,7 +167,7 @@ public:
|
|||
|
||||
class conveyor_sink {
|
||||
private:
|
||||
Own<conveyor_node> node;
|
||||
Own<conveyor_node> m_node;
|
||||
|
||||
public:
|
||||
conveyor_sink();
|
||||
|
|
@ -181,7 +181,7 @@ template <typename T> class MergeConveyorNodeData;
|
|||
|
||||
template <typename T> class merge_conveyor {
|
||||
private:
|
||||
Lent<MergeConveyorNodeData<T>> data;
|
||||
Lent<MergeConveyorNodeData<T>> m_data;
|
||||
|
||||
public:
|
||||
merge_conveyor() = default;
|
||||
|
|
@ -276,10 +276,10 @@ public:
|
|||
void poll(WaitScope &wait_scope);
|
||||
|
||||
// helper
|
||||
static Conveyor<T> to_conveyor(own<conveyor_node> node);
|
||||
static Conveyor<T> to_conveyor(Own<conveyor_node> node);
|
||||
|
||||
// helper
|
||||
static own<conveyor_node> from_conveyor(Conveyor<T> conveyor);
|
||||
static Own<conveyor_node> from_conveyor(Conveyor<T> conveyor);
|
||||
};
|
||||
|
||||
template <typename Func> ConveyorResult<Func, void> exec_later(Func &&func);
|
||||
|
|
@ -318,7 +318,7 @@ public:
|
|||
};
|
||||
|
||||
template <typename T> struct ConveyorAndFeeder {
|
||||
own<conveyor_feeder<T>> feeder;
|
||||
Own<conveyor_feeder<T>> feeder;
|
||||
Conveyor<T> conveyor;
|
||||
};
|
||||
|
||||
|
|
@ -377,11 +377,11 @@ private:
|
|||
void destroy_sink_conveyor_node(conveyor_node &sink_node);
|
||||
void fail(error &&err);
|
||||
|
||||
std::list<own<conveyor_node>> sink_nodes;
|
||||
std::list<own<conveyor_node>> m_sink_nodes;
|
||||
|
||||
std::queue<conveyor_node *> delete_nodes;
|
||||
std::queue<conveyor_node *> m_delete_nodes;
|
||||
|
||||
std::function<void(Error &&error)> error_handler;
|
||||
std::function<void(Error &&error)> m_error_handler;
|
||||
|
||||
public:
|
||||
// ConveyorSinks();
|
||||
|
|
@ -401,16 +401,16 @@ public:
|
|||
class EventLoop {
|
||||
private:
|
||||
friend class event;
|
||||
event *head = nullptr;
|
||||
event **tail = &head;
|
||||
event **next_insert_point = &head;
|
||||
event **later_insert_point = &head;
|
||||
event *m_head = nullptr;
|
||||
event **m_tail = &m_head;
|
||||
event **m_next_insert_point = &m_head;
|
||||
event **m_later_insert_point = &m_head;
|
||||
|
||||
bool is_runnable = false;
|
||||
bool m_is_runnable = false;
|
||||
|
||||
own<event_port> event_port = nullptr;
|
||||
Own<event_port> m_event_port = nullptr;
|
||||
|
||||
own<conveyor_sink_set> daemon_sink = nullptr;
|
||||
Own<conveyor_sink_set> m_daemon_sink = nullptr;
|
||||
|
||||
// functions
|
||||
void set_runnable(bool runnable);
|
||||
|
|
@ -446,7 +446,7 @@ public:
|
|||
*/
|
||||
class WaitScope {
|
||||
private:
|
||||
EventLoop &loop;
|
||||
EventLoop &m_loop;
|
||||
|
||||
public:
|
||||
WaitScope(EventLoop &loop);
|
||||
|
|
@ -502,7 +502,7 @@ template <typename T> class AdaptConveyorNode;
|
|||
template <typename T>
|
||||
class adapt_conveyor_feeder final : public conveyor_feeder<UnfixVoid<T>> {
|
||||
private:
|
||||
AdaptConveyorNode<T> *feedee = nullptr;
|
||||
AdaptConveyorNode<T> *m_feedee = nullptr;
|
||||
|
||||
public:
|
||||
~adapt_conveyor_feeder();
|
||||
|
|
@ -522,11 +522,11 @@ template <typename T>
|
|||
class AdaptConveyorNode final : public conveyor_node,
|
||||
public conveyor_event_storage {
|
||||
private:
|
||||
adapt_conveyor_feeder<T> *feeder = nullptr;
|
||||
adapt_conveyor_feeder<T> *m_feeder = nullptr;
|
||||
|
||||
std::queue<ErrorOr<UnfixVoid<T>>> storage;
|
||||
std::queue<ErrorOr<UnfixVoid<T>>> m_storage;
|
||||
|
||||
conveyor_node_with_parent_mixin parent_node;
|
||||
conveyor_node_with_parent_mixin m_parent_node;
|
||||
|
||||
public:
|
||||
AdaptConveyorNode();
|
||||
|
|
@ -562,7 +562,7 @@ template <typename T> class OneTimeConveyorNode;
|
|||
template <typename T>
|
||||
class one_time_conveyor_feeder final : public conveyor_feeder<UnfixVoid<T>> {
|
||||
private:
|
||||
OneTimeConveyorNode<T> *feedee = nullptr;
|
||||
OneTimeConveyorNode<T> *m_feedee = nullptr;
|
||||
|
||||
public:
|
||||
~one_time_conveyor_feeder();
|
||||
|
|
@ -581,10 +581,10 @@ class OneTimeConveyorNode final : public conveyor_node,
|
|||
public ConveyorStorage,
|
||||
public event {
|
||||
private:
|
||||
one_time_conveyor_feeder<T> *feeder = nullptr;
|
||||
one_time_conveyor_feeder<T> *m_feeder = nullptr;
|
||||
|
||||
bool passed = false;
|
||||
Maybe<ErrorOr<T>> storage = std::nullopt;
|
||||
bool m_passed = false;
|
||||
Maybe<ErrorOr<T>> m_storage = std::nullopt;
|
||||
|
||||
public:
|
||||
~OneTimeConveyorNode();
|
||||
|
|
@ -640,8 +640,8 @@ template <typename T>
|
|||
class queue_buffer_conveyor_node final
|
||||
: public queue_buffer_conveyor_node_base {
|
||||
private:
|
||||
std::queue<ErrorOr<T>> storage;
|
||||
size_t max_store;
|
||||
std::queue<ErrorOr<T>> m_storage;
|
||||
size_t m_max_store;
|
||||
|
||||
public:
|
||||
queue_buffer_conveyor_node(own<conveyor_node> dep, size_t max_size)
|
||||
|
|
@ -713,8 +713,8 @@ protected:
|
|||
template <typename T, typename DepT, typename Func, typename ErrorFunc>
|
||||
class convert_conveyor_node final : public convert_conveyor_node_base {
|
||||
private:
|
||||
Func func;
|
||||
ErrorFunc error_func;
|
||||
Func m_func;
|
||||
ErrorFunc m_error_func;
|
||||
|
||||
static_assert(std::is_same<DepT, RemoveErrorOr<DepT>>::value,
|
||||
"Should never be of type ErrorOr");
|
||||
|
|
@ -759,8 +759,8 @@ public:
|
|||
class SinkConveyorNode final : public conveyor_node,
|
||||
public conveyor_event_storage {
|
||||
private:
|
||||
conveyor_node_with_child_mixin child_mixin;
|
||||
conveyor_sink_set *conveyor_sink;
|
||||
conveyor_node_with_child_mixin m_child_mixin;
|
||||
conveyor_sink_set *m_conveyor_sink;
|
||||
|
||||
public:
|
||||
SinkConveyorNode(own<conveyor_node> node, conveyor_sink_set &conv_sink)
|
||||
|
|
@ -851,8 +851,8 @@ public:
|
|||
template <typename T>
|
||||
class immediate_conveyor_node final : public immediate_conveyor_node_base {
|
||||
private:
|
||||
ErrorOr<FixVoid<T>> value;
|
||||
uint8_t retrieved;
|
||||
ErrorOr<FixVoid<T>> m_value;
|
||||
uint8_t m_retrieved;
|
||||
|
||||
public:
|
||||
immediate_conveyor_node(FixVoid<T> &&val);
|
||||
|
|
@ -867,14 +867,14 @@ public:
|
|||
|
||||
// ConveyorNode
|
||||
void get_result(ErrorOrValue &err_or_val) noexcept override {
|
||||
if (retrieved > 0) {
|
||||
if (m_retrieved > 0) {
|
||||
err_or_val.as<FixVoid<T>>() =
|
||||
makeError("Already taken value", Error::Code::Exhausted);
|
||||
} else {
|
||||
err_or_val.as<FixVoid<T>>() = std::move(value);
|
||||
}
|
||||
if (queued() > 0) {
|
||||
++retrieved;
|
||||
++m_retrieved;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -954,8 +954,8 @@ private:
|
|||
friend class MergeConveyorNodeData<T>;
|
||||
friend class appendage;
|
||||
|
||||
Our<MergeConveyorNodeData<T>> data;
|
||||
size_t next_appendage = 0;
|
||||
Our<MergeConveyorNodeData<T>> m_data;
|
||||
size_t m_next_appendage = 0;
|
||||
|
||||
public:
|
||||
merge_conveyor_node(Our<MergeConveyorNodeData<T>> data);
|
||||
|
|
|
|||
|
|
@ -97,7 +97,7 @@ size_t buffer_view::read_composite_length() const {
|
|||
}
|
||||
|
||||
size_t buffer_view::read_segment_length(size_t offset) const {
|
||||
size_t off = offset + read_offset;
|
||||
size_t off = offset + read_offset();
|
||||
assert(off <= buffer.read_composite_length());
|
||||
if (off > buffer.read_composite_length()) {
|
||||
return 0;
|
||||
|
|
@ -107,18 +107,18 @@ size_t buffer_view::read_segment_length(size_t offset) const {
|
|||
}
|
||||
|
||||
void buffer_view::read_advance(size_t bytes) {
|
||||
size_t offset = bytes + read_offset;
|
||||
size_t offset = bytes + read_offset();
|
||||
assert(offset <= buffer.read_composite_length());
|
||||
if (offset > buffer.read_composite_length()) {
|
||||
read_offset += buffer.read_composite_length();
|
||||
return;
|
||||
}
|
||||
|
||||
read_offset += bytes;
|
||||
read_offset() += bytes;
|
||||
}
|
||||
|
||||
uint8_t &buffer_view::read(size_t i) {
|
||||
size_t pos = i + read_offset;
|
||||
size_t pos = i + read_offset();
|
||||
|
||||
assert(pos < buffer.read_composite_length());
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ uint8_t &buffer_view::read(size_t i) {
|
|||
}
|
||||
|
||||
const uint8_t &buffer_view::read(size_t i) const {
|
||||
size_t pos = i + read_offset;
|
||||
size_t pos = i + read_offset();
|
||||
|
||||
assert(pos < buffer.read_composite_length());
|
||||
|
||||
|
|
|
|||
|
|
@ -57,9 +57,9 @@ public:
|
|||
*/
|
||||
class buffer_view : public buffer {
|
||||
private:
|
||||
buffer &buffer;
|
||||
size_t read_offset;
|
||||
size_t write_offset;
|
||||
buffer &m_buffer;
|
||||
size_t m_read_offset;
|
||||
size_t m_write_offset;
|
||||
|
||||
public:
|
||||
buffer_view(class buffer &);
|
||||
|
|
@ -96,19 +96,19 @@ constexpr size_t ring_buffer_max_size = 4096;
|
|||
*/
|
||||
class ring_buffer final : public buffer {
|
||||
private:
|
||||
std::vector<uint8_t> buffer;
|
||||
std::vector<uint8_t> m_buffer;
|
||||
size_t m_read_position;
|
||||
size_t m_write_position;
|
||||
bool write_reached_read = false;
|
||||
bool m_write_reached_read = false;
|
||||
|
||||
public:
|
||||
ring_buffer();
|
||||
ring_buffer(size_t size);
|
||||
|
||||
inline size_t size() const { return buffer.size(); }
|
||||
inline size_t size() const { return m_buffer.size(); }
|
||||
|
||||
inline uint8_t &operator[](size_t i) { return buffer[i]; }
|
||||
inline const uint8_t &operator[](size_t i) const { return buffer[i]; }
|
||||
inline uint8_t &operator[](size_t i) { return m_buffer[i]; }
|
||||
inline const uint8_t &operator[](size_t i) const { return m_buffer[i]; }
|
||||
|
||||
size_t read_position() const override;
|
||||
size_t read_composite_length() const override;
|
||||
|
|
@ -134,7 +134,7 @@ public:
|
|||
*/
|
||||
class array_buffer : public buffer {
|
||||
private:
|
||||
std::vector<uint8_t> buffer;
|
||||
std::vector<uint8_t> m_buffer;
|
||||
|
||||
size_t m_read_position;
|
||||
size_t m_write_position;
|
||||
|
|
@ -163,7 +163,7 @@ public:
|
|||
|
||||
class chain_array_buffer : public buffer {
|
||||
private:
|
||||
std::deque<array_buffer> buffer;
|
||||
std::deque<array_buffer> m_buffer;
|
||||
|
||||
size_t m_read_position;
|
||||
size_t m_write_position;
|
||||
|
|
|
|||
|
|
@ -4,14 +4,14 @@ namespace saw {
|
|||
error::error() : error_{static_cast<error::Code>(0)} {}
|
||||
|
||||
error::error(const std::string_view &msg, error::Code code)
|
||||
: error_message{msg}, error_{static_cast<error::Code>(code)} {}
|
||||
: m_error_message{msg}, error_{static_cast<error::Code>(code)} {}
|
||||
|
||||
error::error(std::string &&msg, error::Code code)
|
||||
: error_message{std::move(msg)}, error_{static_cast<error::Code>(code)} {}
|
||||
: m_error_message{std::move(msg)}, error_{static_cast<error::Code>(code)} {}
|
||||
|
||||
error::error(error &&error)
|
||||
: error_message{std::move(error.error_message)}, error_{std::move(
|
||||
error.error_)} {}
|
||||
: m_error_message{std::move(error.m_error_message)}, error_{std::move(
|
||||
error.error_)} {}
|
||||
|
||||
const std::string_view error::message() const {
|
||||
|
||||
|
|
@ -27,7 +27,7 @@ const std::string_view error::message() const {
|
|||
return "Error in class Error. Good luck :)";
|
||||
}
|
||||
},
|
||||
error_message);
|
||||
m_error_message);
|
||||
}
|
||||
|
||||
bool error::failed() const {
|
||||
|
|
@ -46,9 +46,9 @@ error error::copy_error() const {
|
|||
error error;
|
||||
error.error_ = error_;
|
||||
try {
|
||||
error.error_message = error_message;
|
||||
error.m_error_message = m_error_message;
|
||||
} catch (const std::bad_alloc &) {
|
||||
error.error_message =
|
||||
error.m_error_message =
|
||||
std::string_view{"Error while copying Error string. Out of memory"};
|
||||
}
|
||||
return error;
|
||||
|
|
|
|||
|
|
@ -24,8 +24,8 @@ public:
|
|||
};
|
||||
|
||||
private:
|
||||
std::variant<std::string_view, std::string> error_message;
|
||||
Code error_;
|
||||
std::variant<std::string_view, std::string> m_error_message;
|
||||
Code m_error;
|
||||
|
||||
public:
|
||||
error();
|
||||
|
|
@ -104,37 +104,37 @@ public:
|
|||
|
||||
template <typename T> class ErrorOr final : public error_or_value {
|
||||
private:
|
||||
std::variant<error, FixVoid<T>> value_or_error_data;
|
||||
std::variant<error, FixVoid<T>> m_value_or_error_data;
|
||||
|
||||
static_assert(!std::is_same_v<T, Void>, "Don't use internal private types");
|
||||
|
||||
public:
|
||||
ErrorOr() = default;
|
||||
ErrorOr(const FixVoid<T> &value) : value_or_error_data{value} {}
|
||||
ErrorOr(const FixVoid<T> &value) : m_value_or_error_data{value} {}
|
||||
|
||||
ErrorOr(FixVoid<T> &&value) : value_or_error_data{std::move(value)} {}
|
||||
ErrorOr(FixVoid<T> &&value) : m_value_or_error_data{std::move(value)} {}
|
||||
|
||||
ErrorOr(const error &error) : value_or_error_data{error} {}
|
||||
ErrorOr(error &&error) : value_or_error_data{std::move(error)} {}
|
||||
ErrorOr(const error &error) : m_value_or_error_data{error} {}
|
||||
ErrorOr(error &&error) : m_value_or_error_data{std::move(error)} {}
|
||||
|
||||
bool is_value() const {
|
||||
return std::holds_alternative<FixVoid<T>>(value_or_error);
|
||||
return std::holds_alternative<FixVoid<T>>(m_value_or_error_data);
|
||||
}
|
||||
|
||||
bool is_error() const {
|
||||
return std::holds_alternative<error>(value_or_error);
|
||||
return std::holds_alternative<error>(m_value_or_error_data);
|
||||
}
|
||||
|
||||
class error &error() {
|
||||
return std::get<error>(value_or_error);
|
||||
return std::get<error>(m_value_or_error_data);
|
||||
}
|
||||
|
||||
const class error &error() const { return std::get<error>(value_or_error); }
|
||||
const class error &error() const { return std::get<error>(m_value_or_error_data); }
|
||||
|
||||
FixVoid<T> &value() { return std::get<FixVoid<T>>(value_or_error); }
|
||||
FixVoid<T> &value() { return std::get<FixVoid<T>>(m_value_or_error_data); }
|
||||
|
||||
const FixVoid<T> &value() const {
|
||||
return std::get<FixVoid<T>>(value_or_error);
|
||||
return std::get<FixVoid<T>>(m_value_or_error_data);
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -64,14 +64,14 @@ public:
|
|||
class async_io_stream final : public async_input_stream,
|
||||
public async_output_stream {
|
||||
private:
|
||||
Own<io_stream> stream;
|
||||
Own<io_stream> m_stream;
|
||||
|
||||
ConveyorSink read_ready;
|
||||
ConveyorSink write_ready;
|
||||
ConveyorSink read_disconnected;
|
||||
ConveyorSink m_read_ready;
|
||||
ConveyorSink m_write_ready;
|
||||
ConveyorSink m_read_disconnected;
|
||||
|
||||
ReadTaskAndStepHelper read_stepper;
|
||||
WriteTaskAndStepHelper write_stepper;
|
||||
ReadTaskAndStepHelper m_read_stepper;
|
||||
WriteTaskAndStepHelper m_write_stepper;
|
||||
|
||||
public:
|
||||
async_io_stream(Own<io_stream> str);
|
||||
|
|
@ -140,8 +140,8 @@ public:
|
|||
|
||||
class StringNetworkAddress final : public NetworkAddress {
|
||||
private:
|
||||
std::string address_value;
|
||||
uint16_t port_value;
|
||||
std::string m_address_value;
|
||||
uint16_t m_port_value;
|
||||
|
||||
public:
|
||||
StringNetworkAddress(const std::string &address, uint16_t port);
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ public:
|
|||
const std::string &identity() const;
|
||||
|
||||
private:
|
||||
std::string identity_value;
|
||||
std::string m_identity_value;
|
||||
};
|
||||
|
||||
class authenticated_io_stream {
|
||||
|
|
|
|||
|
|
@ -51,8 +51,8 @@ private:
|
|||
public:
|
||||
peer_conveyor_feeder(
|
||||
streaming_io_peer<Codec, Incoming, Outgoing, InContainer,
|
||||
OutContainer, BufferT> &peer_)
|
||||
: peer{peer_} {}
|
||||
OutContainer, BufferT> &peer)
|
||||
: m_peer{peer} {}
|
||||
|
||||
void feed(HeapMessageRoot<Outgoing, OutContainer> &&data) override {
|
||||
(void)data;
|
||||
|
|
@ -66,24 +66,24 @@ private:
|
|||
|
||||
private:
|
||||
streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
||||
BufferT> &peer;
|
||||
BufferT> &m_peer;
|
||||
};
|
||||
|
||||
private:
|
||||
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>>
|
||||
incoming_feeder = nullptr;
|
||||
m_incoming_feeder = nullptr;
|
||||
|
||||
Own<AsyncIoStream> io_stream;
|
||||
Own<AsyncIoStream> m_io_stream;
|
||||
|
||||
Codec codec;
|
||||
Codec m_codec;
|
||||
|
||||
BufferT in_buffer;
|
||||
BufferT out_buffer;
|
||||
BufferT m_in_buffer;
|
||||
BufferT m_out_buffer;
|
||||
|
||||
ConveyorSink sink_read;
|
||||
ConveyorSink sink_write;
|
||||
ConveyorSink m_sink_read;
|
||||
ConveyorSink m_sink_write;
|
||||
|
||||
peer_conveyor_feeder conveyor_feeder;
|
||||
peer_conveyor_feeder m_conveyor_feeder;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
|||
Own<ConveyorFeeder<HeapMessageRoot<Incoming, InContainer>>> feed_,
|
||||
Own<AsyncIoStream> stream_, Codec codec_, BufferT in_, BufferT out_)
|
||||
: incoming_feeder{std::move(feed_)}, io_stream{std::move(stream_)},
|
||||
codec{std::move(codec_)}, in_buffer{std::move(in_)}, out_buffer{std::move(
|
||||
m_codec{std::move(codec_)}, m_in_buffer{std::move(in_)}, m_out_buffer{std::move(
|
||||
out_)},
|
||||
sink_read{io_stream->readDone()
|
||||
.then([streaming_io_peer](size_t bytes) -> ErrorOr<void> {
|
||||
|
|
@ -75,7 +75,7 @@ template <typename Codec, typename Incoming, typename Outgoing,
|
|||
Error streaming_io_peer<Codec, Incoming, Outgoing, InContainer, OutContainer,
|
||||
BufferT>::send(HeapMessageRoot<Outgoing, OutContainer>
|
||||
msg) {
|
||||
bool restart_write = out_buffer.readSegmentLength() == 0;
|
||||
bool restart_write = m_out_buffer.readSegmentLength() == 0;
|
||||
|
||||
Error error =
|
||||
codec.template encode<Outgoing, OutContainer>(msg.read(), out_buffer);
|
||||
|
|
|
|||
|
|
@ -10,15 +10,15 @@ public:
|
|||
enum class Type : uint8_t { Info, Warning, Error, Debug };
|
||||
|
||||
private:
|
||||
LogIo ¢ral;
|
||||
EventLoop &loop;
|
||||
LogIo &m_central;
|
||||
EventLoop &m_loop;
|
||||
|
||||
public:
|
||||
log(LogIo ¢ral, EventLoop &loop);
|
||||
};
|
||||
class LogIo {
|
||||
private:
|
||||
EventLoop &loop;
|
||||
EventLoop &m_loop;
|
||||
|
||||
public:
|
||||
LogIo(EventLoop &loop);
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ class Message<schema::Struct<schema::NamedMember<V, Keys>...>, Container> final
|
|||
private:
|
||||
using SchemaType = schema::Struct<schema::NamedMember<V, Keys>...>;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same the schema as Message");
|
||||
|
|
@ -62,24 +62,24 @@ public:
|
|||
class Reader;
|
||||
class builder {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg) : message{msg} {}
|
||||
builder(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
/*
|
||||
* Initialize a member by index
|
||||
*/
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, V...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
init() {
|
||||
return typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>()};
|
||||
return typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -101,15 +101,15 @@ public:
|
|||
return init<i>();
|
||||
}
|
||||
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, V...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
init(size_t size = 0) {
|
||||
auto array_builder =
|
||||
typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>(), size};
|
||||
typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>(), size};
|
||||
return array_builder;
|
||||
}
|
||||
|
||||
|
|
@ -134,20 +134,20 @@ public:
|
|||
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(MessageType &msg) : message{msg} {}
|
||||
Reader(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message}; }
|
||||
builder as_builder() { return builder{m_message}; }
|
||||
|
||||
/*
|
||||
* Get member by index
|
||||
*/
|
||||
template <size_t i>
|
||||
typename Container::template ElementType<i>::Reader get() {
|
||||
return typename Container::template ElementType<i>::Reader{
|
||||
message.container.template get<i>()};
|
||||
template <size_t I>
|
||||
typename Container::template ElementType<I>::Reader get() {
|
||||
return typename Container::template ElementType<I>::Reader{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -181,7 +181,7 @@ private:
|
|||
using SchemaType = schema::Union<schema::NamedMember<V, Keys>...>;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same the schema as Message");
|
||||
|
|
@ -193,22 +193,22 @@ public:
|
|||
class Reader;
|
||||
class builder {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg) : message{msg} {}
|
||||
builder(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, V...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
|
||||
init() {
|
||||
return typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>()};
|
||||
return typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
|
||||
template <StringLiteral Literal>
|
||||
|
|
@ -229,14 +229,14 @@ public:
|
|||
/*
|
||||
* If Schema is Array
|
||||
*/
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, V...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, V...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
init(size_t size = 0) {
|
||||
return typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>(), size};
|
||||
return typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>(), size};
|
||||
}
|
||||
|
||||
template <StringLiteral Literal>
|
||||
|
|
@ -257,17 +257,17 @@ public:
|
|||
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(MessageType &msg) : message{msg} {}
|
||||
Reader(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message}; }
|
||||
builder as_builder() { return builder{m_message}; }
|
||||
|
||||
template <size_t i>
|
||||
typename Container::template ElementType<i>::Reader get() {
|
||||
return typename Container::template ElementType<i>::Reader{
|
||||
message.container.template get<i>()};
|
||||
template <size_t I>
|
||||
typename Container::template ElementType<I>::Reader get() {
|
||||
return typename Container::template ElementType<I>::Reader{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
|
||||
template <StringLiteral Literal>
|
||||
|
|
@ -286,7 +286,7 @@ public:
|
|||
return MessageParameterKeyPackIndex<Literal, Keys...>::Value;
|
||||
}
|
||||
|
||||
size_t index() const noexcept { return message.container.index(); }
|
||||
size_t index() const noexcept { return m_message.m_container.index(); }
|
||||
|
||||
template <StringLiteral Literal> bool has_alternative() const {
|
||||
return index() == toIndex<Literal>();
|
||||
|
|
@ -303,7 +303,7 @@ private:
|
|||
using SchemaType = schema::Array<T>;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same Schema as Message");
|
||||
|
|
@ -315,42 +315,42 @@ public:
|
|||
class Reader;
|
||||
class builder {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg, size_t size) : message{msg} {
|
||||
builder(MessageType &msg, size_t size) : m_message{msg} {
|
||||
if (size > 0) {
|
||||
message.container.resize(size);
|
||||
m_message.m_container.resize(size);
|
||||
}
|
||||
}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
typename Container::ElementType::Builder init(size_t i) {
|
||||
return typename Container::ElementType::Builder{
|
||||
message.container.get(i)};
|
||||
m_message.m_container.get(i)};
|
||||
}
|
||||
|
||||
size_t size() const { return message.container.size(); }
|
||||
size_t size() const { return m_message.m_container.size(); }
|
||||
|
||||
void resize(size_t size) { message.container.resize(size); }
|
||||
void resize(size_t size) { m_message.m_container.resize(size); }
|
||||
};
|
||||
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(MessageType &msg) : message{msg} {}
|
||||
Reader(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message, 0}; }
|
||||
builder as_builder() { return builder{m_message, 0}; }
|
||||
|
||||
typename Container::ElementType::Reader get(size_t i) {
|
||||
return typename Container::ElementType::Reader{
|
||||
message.container.get(i)};
|
||||
m_message.m_container.get(i)};
|
||||
}
|
||||
|
||||
size_t size() const { return message.container.size(); }
|
||||
size_t size() const { return m_message.m_container.size(); }
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -363,7 +363,7 @@ private:
|
|||
using SchemaType = schema::Tuple<T...>;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same the schema as Message");
|
||||
|
|
@ -374,46 +374,46 @@ private:
|
|||
public:
|
||||
class Reader;
|
||||
class builder {
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg) : message{msg} {}
|
||||
builder(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
!SchemaIsArray<
|
||||
typename MessageParameterPackType<i, T...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, T...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
init() {
|
||||
return typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>()};
|
||||
return typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
|
||||
template <size_t i>
|
||||
template <size_t I>
|
||||
typename std::enable_if<
|
||||
SchemaIsArray<
|
||||
typename MessageParameterPackType<i, T...>::Type>::Value,
|
||||
typename Container::template ElementType<i>::Builder>::type
|
||||
typename MessageParameterPackType<I, T...>::Type>::Value,
|
||||
typename Container::template ElementType<I>::Builder>::type
|
||||
init(size_t size = 0) {
|
||||
return typename Container::template ElementType<i>::Builder{
|
||||
message.container.template get<i>(), size};
|
||||
return typename Container::template ElementType<I>::Builder{
|
||||
m_message.m_container.template get<I>(), size};
|
||||
}
|
||||
};
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(MessageType &msg) : message{msg} {}
|
||||
Reader(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message}; }
|
||||
builder as_builder() { return builder{m_message}; }
|
||||
|
||||
template <size_t i>
|
||||
typename Container::template ElementType<i>::Reader get() {
|
||||
return typename Container::template ElementType<i>::Reader{
|
||||
message.container.template get<i>()};
|
||||
template <size_t I>
|
||||
typename Container::template ElementType<I>::Reader get() {
|
||||
return typename Container::template ElementType<I>::Reader{
|
||||
m_message.m_container.template get<I>()};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
|
@ -428,7 +428,7 @@ private:
|
|||
using SchemaType = schema::Primitive<T, N>;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same the schema as Message");
|
||||
|
|
@ -440,29 +440,29 @@ public:
|
|||
class Reader;
|
||||
class builder {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg) : message{msg} {}
|
||||
builder(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
void set(const typename Container::ValueType &value) {
|
||||
message.container.set(value);
|
||||
m_message.m_container.set(value);
|
||||
}
|
||||
};
|
||||
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(Message &msg) : message{msg} {}
|
||||
Reader(Message &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message}; }
|
||||
builder as_builder() { return builder{m_message}; }
|
||||
|
||||
const typename Container::ValueType &get() const {
|
||||
return message.container.get();
|
||||
return m_message.m_container.get();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
|
@ -473,7 +473,7 @@ private:
|
|||
using SchemaType = schema::String;
|
||||
using MessageType = Message<SchemaType, Container>;
|
||||
|
||||
Container container;
|
||||
Container m_container;
|
||||
|
||||
static_assert(std::is_same_v<SchemaType, typename Container::SchemaType>,
|
||||
"Container should have same the schema as Message");
|
||||
|
|
@ -485,35 +485,35 @@ public:
|
|||
class Reader;
|
||||
class builder {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
builder(MessageType &msg) : message{msg} {}
|
||||
builder(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
Reader as_reader() { return Reader{message}; }
|
||||
Reader as_reader() { return Reader{m_message}; }
|
||||
|
||||
void set(std::string &&str) { message.container.set(std::move(str)); }
|
||||
void set(const std::string_view str) { message.container.set(str); }
|
||||
void set(std::string &&str) { m_message.m_container.set(std::move(str)); }
|
||||
void set(const std::string_view str) { m_message.m_container.set(str); }
|
||||
void set(const char *str) { set(std::string_view{str}); }
|
||||
};
|
||||
|
||||
class Reader {
|
||||
private:
|
||||
MessageType &message;
|
||||
MessageType &m_message;
|
||||
|
||||
public:
|
||||
Reader(MessageType &msg) : message{msg} {}
|
||||
Reader(MessageType &msg) : m_message{msg} {}
|
||||
|
||||
builder as_builder() { return builder{message}; }
|
||||
builder as_builder() { return builder{m_message}; }
|
||||
|
||||
const std::string_view get() const { return message.container.get(); }
|
||||
const std::string_view get() const { return m_message.m_container.get(); }
|
||||
};
|
||||
};
|
||||
|
||||
template <class Schema, class Container = MessageContainer<Schema>>
|
||||
class heap_message_root {
|
||||
private:
|
||||
Own<Message<Schema, Container>> root;
|
||||
Own<Message<Schema, Container>> m_root;
|
||||
|
||||
public:
|
||||
heap_message_root(Own<Message<Schema, Container>> r) : root{std::move(r)} {}
|
||||
|
|
@ -535,7 +535,7 @@ public:
|
|||
using Schema = schema::Array<T>;
|
||||
|
||||
private:
|
||||
Own<Message<Schema, Container>> root;
|
||||
Own<Message<Schema, Container>> m_root;
|
||||
|
||||
public:
|
||||
heap_message_root(Own<Message<Schema, Container>> r) : root{std::move(r)} {}
|
||||
|
|
|
|||
|
|
@ -97,14 +97,14 @@ struct ProtoKelEncodeImpl<Message<schema::String, Container>> {
|
|||
|
||||
template <class... T, class Container>
|
||||
struct ProtoKelEncodeImpl<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
|
||||
encode_members(typename Message<schema::Tuple<T...>, Container>::Reader,
|
||||
Buffer &) {
|
||||
return noError();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if<(i < sizeof...(T)), Error>::type
|
||||
encode_members(
|
||||
typename Message<schema::Tuple<T...>, Container>::Reader data,
|
||||
|
|
@ -125,19 +125,19 @@ struct ProtoKelEncodeImpl<Message<schema::Tuple<T...>, Container>> {
|
|||
return encodeMembers<0>(data, buffer);
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
static typename std::enable_if<i == sizeof...(T), size_t>::type
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if<I == sizeof...(T), size_t>::type
|
||||
size_members(typename Message<schema::Tuple<T...>, Container>::Reader) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(T), size_t>::type size_members(
|
||||
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 ProtoKelEncodeImpl<typename Container::template ElementType<I>>::
|
||||
size(reader.template get<I>()) +
|
||||
sizeMembers<I + 1>(reader);
|
||||
}
|
||||
|
||||
static size_t
|
||||
|
|
@ -149,7 +149,7 @@ struct ProtoKelEncodeImpl<Message<schema::Tuple<T...>, Container>> {
|
|||
template <typename... V, StringLiteral... K, class Container>
|
||||
struct ProtoKelEncodeImpl<
|
||||
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
|
||||
encode_members(
|
||||
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
|
|
@ -157,7 +157,7 @@ struct ProtoKelEncodeImpl<
|
|||
Buffer &) {
|
||||
return noError();
|
||||
}
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), Error>::type encode_members(
|
||||
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
|
|
@ -180,21 +180,21 @@ struct ProtoKelEncodeImpl<
|
|||
return encodeMembers<0>(data, buffer);
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
static typename std::enable_if<i == sizeof...(V), size_t>::type
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if<I == sizeof...(V), size_t>::type
|
||||
size_members(typename Message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
Container>::Reader) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), size_t>::type size_members(
|
||||
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 ProtoKelEncodeImpl<typename Container::template ElementType<I>>::
|
||||
size(reader.template get<I>()) +
|
||||
sizeMembers<I + 1>(reader);
|
||||
}
|
||||
|
||||
static size_t
|
||||
|
|
@ -208,7 +208,7 @@ template <typename... V, StringLiteral... K, class Container>
|
|||
struct ProtoKelEncodeImpl<
|
||||
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
|
||||
encode_members(typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Reader,
|
||||
|
|
@ -216,13 +216,13 @@ struct ProtoKelEncodeImpl<
|
|||
return noError();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), Error>::type encode_members(
|
||||
typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Reader reader,
|
||||
Buffer &buffer) {
|
||||
if (reader.index() == i) {
|
||||
if (reader.index() == I) {
|
||||
Error error =
|
||||
StreamValue<proto_kel_codec::UnionIdT>::encode(i, buffer);
|
||||
if (error.failed()) {
|
||||
|
|
@ -241,23 +241,23 @@ struct ProtoKelEncodeImpl<
|
|||
return encodeMembers<0>(reader, buffer);
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
static typename std::enable_if<i == sizeof...(V), size_t>::type
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if<I == sizeof...(V), size_t>::type
|
||||
size_members(typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Reader) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), size_t>::type size_members(
|
||||
I<sizeof...(V), size_t>::type size_members(
|
||||
typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Reader reader) {
|
||||
if (reader.index() == i) {
|
||||
if (reader.index() == I) {
|
||||
return ProtoKelEncodeImpl<typename Container::template ElementType<
|
||||
i>>::size(reader.template get<i>());
|
||||
I>>::size(reader.template get<I>());
|
||||
}
|
||||
return sizeMembers<i + 1>(reader);
|
||||
return sizeMembers<I + 1>(reader);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -365,14 +365,14 @@ struct ProtoKelDecodeImpl<Message<schema::String, Container>> {
|
|||
|
||||
template <class... T, class Container>
|
||||
struct ProtoKelDecodeImpl<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
|
||||
decode_members(typename Message<schema::Tuple<T...>, Container>::Builder,
|
||||
Buffer &) {
|
||||
return noError();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(T), Error>::type decode_members(
|
||||
typename Message<schema::Tuple<T...>, Container>::Builder builder,
|
||||
|
|
@ -398,7 +398,7 @@ template <class... V, StringLiteral... K, class Container>
|
|||
struct ProtoKelDecodeImpl<
|
||||
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
|
||||
decode_members(
|
||||
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
|
|
@ -407,7 +407,7 @@ struct ProtoKelDecodeImpl<
|
|||
return noError();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), Error>::type decode_members(
|
||||
typename Message<schema::Struct<schema::NamedMember<V, K>...>,
|
||||
|
|
@ -434,7 +434,7 @@ struct ProtoKelDecodeImpl<
|
|||
template <class... V, StringLiteral... K, class Container>
|
||||
struct ProtoKelDecodeImpl<
|
||||
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
|
||||
decode_members(typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Builder,
|
||||
|
|
@ -442,14 +442,14 @@ struct ProtoKelDecodeImpl<
|
|||
return noError();
|
||||
}
|
||||
|
||||
template <size_t i = 0>
|
||||
template <size_t I = 0>
|
||||
static typename std::enable_if <
|
||||
i<sizeof...(V), Error>::type decode_members(
|
||||
typename Message<schema::Union<schema::NamedMember<V, K>...>,
|
||||
Container>::Builder builder,
|
||||
Buffer &buffer, proto_kel_codec::UnionIdT id) {
|
||||
|
||||
if (id == i) {
|
||||
if (id == I) {
|
||||
Error error =
|
||||
ProtoKelDecodeImpl<typename Container::template ElementType<
|
||||
i>>::decode(builder.template init<i>(), buffer);
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ namespace saw {
|
|||
* platform independent. So it does not matter if the memory layout is
|
||||
* little endian or big endian
|
||||
*/
|
||||
template <typename T, size_t size = sizeof(T)> class ShiftStreamValue;
|
||||
template <typename T, size_t Size = sizeof(T)> class ShiftStreamValue;
|
||||
|
||||
template <typename T> class ShiftStreamValue<T, 1> {
|
||||
public:
|
||||
|
|
|
|||
Loading…
Reference in New Issue