botchain/rpc
1
0
Fork 0
mirror of https://github.com/BotChain-Robots/rpc.git synced 2026-03-09 23:12:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

Finish implementation

Browse Source
This commit is contained in:
Johnathon Slightham
2026-02-10 23:11:23 -05:00
parent c5e6e0592e
commit 880e7ab454
18 changed files with 344 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/ICommunicationClient.h
View File

@@ -12,4 +12,4 @@ class ICommunicationClient {
virtual int send_msg(void *sendbuff, uint32_t len) = 0;
};
#endif //INETWORKCLIENT_H
#endif // INETWORKCLIENT_H

29
include/flatbuffers/CallBuilder.h Normal file
View File

@@ -0,0 +1,29 @@
#ifndef CALLBUILDER_H
#define CALLBUILDER_H
#include <vector>
#include "SerializedMessage.h"
#include "flatbuffers/flatbuffers.h"
#include "flatbuffers_generated/ReturnCall_generated.h"
#include "flatbuffers_generated/SendCall_generated.h"
namespace Flatbuffers {
class CallBuilder {
public:
CallBuilder() : builder_(1024) {
}
SerializedMessage build_send_call(uint8_t tag, uint8_t unique_id,
const std::vector<uint8_t> &parameters);
static const Messaging::ReturnCall *parse_return_call(const uint8_t *buffer);
private:
flatbuffers::FlatBufferBuilder builder_;
};
} // namespace Flatbuffers
#endif // CALLBUILDER_H

2
include/flatbuffers/MPIMessageBuilder.h
View File

@@ -30,4 +30,4 @@ class MPIMessageBuilder {
};
} // namespace Flatbuffers
#endif //MPIMESSAGEBUILDER_H
#endif // MPIMESSAGEBUILDER_H

2
include/flatbuffers/SerializedMessage.h
View File

@@ -12,4 +12,4 @@ struct SerializedMessage {
};
} // namespace Flatbuffers
#endif //SERIALIZEDMESSAGE_H
#endif // SERIALIZEDMESSAGE_H

1
include/flatbuffers_generated/MPIMessage_generated.h
View File

@@ -1,6 +1,5 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_MPIMESSAGE_MESSAGING_H_
#define FLATBUFFERS_GENERATED_MPIMESSAGE_MESSAGING_H_

152
include/flatbuffers_generated/ReturnCall_generated.h
View File

@@ -1,6 +1,5 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_RETURNCALL_MESSAGING_H_
#define FLATBUFFERS_GENERATED_RETURNCALL_MESSAGING_H_
@@ -19,110 +18,95 @@ struct ReturnCall;
struct ReturnCallBuilder;
struct ReturnCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef ReturnCallBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_UNIQUE_ID = 4,
VT_LENGTH = 6,
VT_RETURN_VALUE = 8
};
uint8_t unique_id() const {
return GetField<uint8_t>(VT_UNIQUE_ID, 0);
}
uint16_t length() const {
return GetField<uint16_t>(VT_LENGTH, 0);
}
const ::flatbuffers::Vector<uint8_t> *return_value() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_RETURN_VALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_UNIQUE_ID, 1) &&
VerifyField<uint16_t>(verifier, VT_LENGTH, 2) &&
VerifyOffset(verifier, VT_RETURN_VALUE) &&
verifier.VerifyVector(return_value()) &&
verifier.EndTable();
}
typedef ReturnCallBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_UNIQUE_ID = 4,
VT_LENGTH = 6,
VT_RETURN_VALUE = 8
};
uint8_t unique_id() const {
return GetField<uint8_t>(VT_UNIQUE_ID, 0);
}
uint16_t length() const {
return GetField<uint16_t>(VT_LENGTH, 0);
}
const ::flatbuffers::Vector<uint8_t> *return_value() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_RETURN_VALUE);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_UNIQUE_ID, 1) &&
VerifyField<uint16_t>(verifier, VT_LENGTH, 2) &&
VerifyOffset(verifier, VT_RETURN_VALUE) && verifier.VerifyVector(return_value()) &&
verifier.EndTable();
}
};
struct ReturnCallBuilder {
typedef ReturnCall Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_unique_id(uint8_t unique_id) {
fbb_.AddElement<uint8_t>(ReturnCall::VT_UNIQUE_ID, unique_id, 0);
}
void add_length(uint16_t length) {
fbb_.AddElement<uint16_t>(ReturnCall::VT_LENGTH, length, 0);
}
void add_return_value(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> return_value) {
fbb_.AddOffset(ReturnCall::VT_RETURN_VALUE, return_value);
}
explicit ReturnCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ReturnCall> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ReturnCall>(end);
return o;
}
typedef ReturnCall Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_unique_id(uint8_t unique_id) {
fbb_.AddElement<uint8_t>(ReturnCall::VT_UNIQUE_ID, unique_id, 0);
}
void add_length(uint16_t length) {
fbb_.AddElement<uint16_t>(ReturnCall::VT_LENGTH, length, 0);
}
void add_return_value(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> return_value) {
fbb_.AddOffset(ReturnCall::VT_RETURN_VALUE, return_value);
}
explicit ReturnCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<ReturnCall> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<ReturnCall>(end);
return o;
}
};
inline ::flatbuffers::Offset<ReturnCall> CreateReturnCall(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t unique_id = 0,
uint16_t length = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> return_value = 0) {
ReturnCallBuilder builder_(_fbb);
builder_.add_return_value(return_value);
builder_.add_length(length);
builder_.add_unique_id(unique_id);
return builder_.Finish();
inline ::flatbuffers::Offset<ReturnCall>
CreateReturnCall(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t unique_id = 0, uint16_t length = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> return_value = 0) {
ReturnCallBuilder builder_(_fbb);
builder_.add_return_value(return_value);
builder_.add_length(length);
builder_.add_unique_id(unique_id);
return builder_.Finish();
}
inline ::flatbuffers::Offset<ReturnCall> CreateReturnCallDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t unique_id = 0,
uint16_t length = 0,
const std::vector<uint8_t> *return_value = nullptr) {
auto return_value__ = return_value ? _fbb.CreateVector<uint8_t>(*return_value) : 0;
return Messaging::CreateReturnCall(
_fbb,
unique_id,
length,
return_value__);
inline ::flatbuffers::Offset<ReturnCall>
CreateReturnCallDirect(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t unique_id = 0,
uint16_t length = 0, const std::vector<uint8_t> *return_value = nullptr) {
auto return_value__ = return_value ? _fbb.CreateVector<uint8_t>(*return_value) : 0;
return Messaging::CreateReturnCall(_fbb, unique_id, length, return_value__);
}
inline const Messaging::ReturnCall *GetReturnCall(const void *buf) {
return ::flatbuffers::GetRoot<Messaging::ReturnCall>(buf);
return ::flatbuffers::GetRoot<Messaging::ReturnCall>(buf);
}
inline const Messaging::ReturnCall *GetSizePrefixedReturnCall(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Messaging::ReturnCall>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Messaging::ReturnCall>(buf);
}
inline bool VerifyReturnCallBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Messaging::ReturnCall>(nullptr);
inline bool VerifyReturnCallBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Messaging::ReturnCall>(nullptr);
}
inline bool VerifySizePrefixedReturnCallBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::ReturnCall>(nullptr);
inline bool VerifySizePrefixedReturnCallBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::ReturnCall>(nullptr);
}
inline void FinishReturnCallBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ReturnCall> root) {
fbb.Finish(root);
inline void FinishReturnCallBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ReturnCall> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedReturnCallBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ReturnCall> root) {
fbb.FinishSizePrefixed(root);
inline void FinishSizePrefixedReturnCallBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::ReturnCall> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Messaging
} // namespace Messaging
#endif // FLATBUFFERS_GENERATED_RETURNCALL_MESSAGING_H_
#endif // FLATBUFFERS_GENERATED_RETURNCALL_MESSAGING_H_

3
include/flatbuffers_generated/RobotModule_generated.h
View File

@@ -1,6 +1,5 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_ROBOTMODULE_H_
#define FLATBUFFERS_GENERATED_ROBOTMODULE_H_
@@ -8,7 +7,7 @@
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
//static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
// static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
// FLATBUFFERS_VERSION_MINOR == 2 &&
// FLATBUFFERS_VERSION_REVISION == 10,
// "Non-compatible flatbuffers version included");

174
include/flatbuffers_generated/SendCall_generated.h
View File

@@ -1,6 +1,5 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_SENDCALL_MESSAGING_H_
#define FLATBUFFERS_GENERATED_SENDCALL_MESSAGING_H_
@@ -19,122 +18,105 @@ struct SendCall;
struct SendCallBuilder;
struct SendCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
typedef SendCallBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TAG = 4,
VT_UNIQUE_ID = 6,
VT_LENGTH = 8,
VT_PARAMETERS = 10
};
uint8_t tag() const {
return GetField<uint8_t>(VT_TAG, 0);
}
uint8_t unique_id() const {
return GetField<uint8_t>(VT_UNIQUE_ID, 0);
}
uint16_t length() const {
return GetField<uint16_t>(VT_LENGTH, 0);
}
const ::flatbuffers::Vector<uint8_t> *parameters() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PARAMETERS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint8_t>(verifier, VT_TAG, 1) &&
VerifyField<uint8_t>(verifier, VT_UNIQUE_ID, 1) &&
VerifyField<uint16_t>(verifier, VT_LENGTH, 2) &&
VerifyOffset(verifier, VT_PARAMETERS) &&
verifier.VerifyVector(parameters()) &&
verifier.EndTable();
}
typedef SendCallBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_TAG = 4,
VT_UNIQUE_ID = 6,
VT_LENGTH = 8,
VT_PARAMETERS = 10
};
uint8_t tag() const {
return GetField<uint8_t>(VT_TAG, 0);
}
uint8_t unique_id() const {
return GetField<uint8_t>(VT_UNIQUE_ID, 0);
}
uint16_t length() const {
return GetField<uint16_t>(VT_LENGTH, 0);
}
const ::flatbuffers::Vector<uint8_t> *parameters() const {
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PARAMETERS);
}
bool Verify(::flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) && VerifyField<uint8_t>(verifier, VT_TAG, 1) &&
VerifyField<uint8_t>(verifier, VT_UNIQUE_ID, 1) &&
VerifyField<uint16_t>(verifier, VT_LENGTH, 2) &&
VerifyOffset(verifier, VT_PARAMETERS) && verifier.VerifyVector(parameters()) &&
verifier.EndTable();
}
};
struct SendCallBuilder {
typedef SendCall Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_tag(uint8_t tag) {
fbb_.AddElement<uint8_t>(SendCall::VT_TAG, tag, 0);
}
void add_unique_id(uint8_t unique_id) {
fbb_.AddElement<uint8_t>(SendCall::VT_UNIQUE_ID, unique_id, 0);
}
void add_length(uint16_t length) {
fbb_.AddElement<uint16_t>(SendCall::VT_LENGTH, length, 0);
}
void add_parameters(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> parameters) {
fbb_.AddOffset(SendCall::VT_PARAMETERS, parameters);
}
explicit SendCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SendCall> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SendCall>(end);
return o;
}
typedef SendCall Table;
::flatbuffers::FlatBufferBuilder &fbb_;
::flatbuffers::uoffset_t start_;
void add_tag(uint8_t tag) {
fbb_.AddElement<uint8_t>(SendCall::VT_TAG, tag, 0);
}
void add_unique_id(uint8_t unique_id) {
fbb_.AddElement<uint8_t>(SendCall::VT_UNIQUE_ID, unique_id, 0);
}
void add_length(uint16_t length) {
fbb_.AddElement<uint16_t>(SendCall::VT_LENGTH, length, 0);
}
void add_parameters(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> parameters) {
fbb_.AddOffset(SendCall::VT_PARAMETERS, parameters);
}
explicit SendCallBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) {
start_ = fbb_.StartTable();
}
::flatbuffers::Offset<SendCall> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = ::flatbuffers::Offset<SendCall>(end);
return o;
}
};
inline ::flatbuffers::Offset<SendCall> CreateSendCall(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t tag = 0,
uint8_t unique_id = 0,
uint16_t length = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> parameters = 0) {
SendCallBuilder builder_(_fbb);
builder_.add_parameters(parameters);
builder_.add_length(length);
builder_.add_unique_id(unique_id);
builder_.add_tag(tag);
return builder_.Finish();
inline ::flatbuffers::Offset<SendCall>
CreateSendCall(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t tag = 0, uint8_t unique_id = 0,
uint16_t length = 0,
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> parameters = 0) {
SendCallBuilder builder_(_fbb);
builder_.add_parameters(parameters);
builder_.add_length(length);
builder_.add_unique_id(unique_id);
builder_.add_tag(tag);
return builder_.Finish();
}
inline ::flatbuffers::Offset<SendCall> CreateSendCallDirect(
::flatbuffers::FlatBufferBuilder &_fbb,
uint8_t tag = 0,
uint8_t unique_id = 0,
uint16_t length = 0,
const std::vector<uint8_t> *parameters = nullptr) {
auto parameters__ = parameters ? _fbb.CreateVector<uint8_t>(*parameters) : 0;
return Messaging::CreateSendCall(
_fbb,
tag,
unique_id,
length,
parameters__);
inline ::flatbuffers::Offset<SendCall>
CreateSendCallDirect(::flatbuffers::FlatBufferBuilder &_fbb, uint8_t tag = 0, uint8_t unique_id = 0,
uint16_t length = 0, const std::vector<uint8_t> *parameters = nullptr) {
auto parameters__ = parameters ? _fbb.CreateVector<uint8_t>(*parameters) : 0;
return Messaging::CreateSendCall(_fbb, tag, unique_id, length, parameters__);
}
inline const Messaging::SendCall *GetSendCall(const void *buf) {
return ::flatbuffers::GetRoot<Messaging::SendCall>(buf);
return ::flatbuffers::GetRoot<Messaging::SendCall>(buf);
}
inline const Messaging::SendCall *GetSizePrefixedSendCall(const void *buf) {
return ::flatbuffers::GetSizePrefixedRoot<Messaging::SendCall>(buf);
return ::flatbuffers::GetSizePrefixedRoot<Messaging::SendCall>(buf);
}
inline bool VerifySendCallBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Messaging::SendCall>(nullptr);
inline bool VerifySendCallBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<Messaging::SendCall>(nullptr);
}
inline bool VerifySizePrefixedSendCallBuffer(
::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::SendCall>(nullptr);
inline bool VerifySizePrefixedSendCallBuffer(::flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<Messaging::SendCall>(nullptr);
}
inline void FinishSendCallBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SendCall> root) {
fbb.Finish(root);
inline void FinishSendCallBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SendCall> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedSendCallBuffer(
::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SendCall> root) {
fbb.FinishSizePrefixed(root);
inline void FinishSizePrefixedSendCallBuffer(::flatbuffers::FlatBufferBuilder &fbb,
::flatbuffers::Offset<Messaging::SendCall> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace Messaging
} // namespace Messaging
#endif // FLATBUFFERS_GENERATED_SENDCALL_MESSAGING_H_
#endif // FLATBUFFERS_GENERATED_SENDCALL_MESSAGING_H_

21
include/librpc.h
View File

@@ -3,15 +3,18 @@
#include <chrono>
#include <memory>
#include <semaphore>
#include <shared_mutex>
#include <thread>
#include "BlockingQueue.h"
#include "constants.h"
#include "flatbuffers/CallBuilder.h"
#include "mDNSDiscoveryService.h"
constexpr auto RX_QUEUE_SIZE = 100;
constexpr auto FN_CALL_TAG = 100; // reserved tag for RPC functionality
constexpr auto FN_CALL_TIMEOUT = std::chrono::seconds(3);
struct SizeAndSource {
size_t bytes_written;
@@ -22,6 +25,7 @@ class MessagingInterface {
public:
MessagingInterface()
: m_stop_flag(false), m_rx_thread(std::thread(&MessagingInterface::handle_recv, this)),
m_fn_rx_thread(std::thread(&MessagingInterface::handle_fn_recv, this)),
m_rx_queue(std::make_shared<BlockingQueue<std::unique_ptr<std::vector<uint8_t>>>>(
RX_QUEUE_SIZE)) {
#ifdef _WIN32
@@ -37,23 +41,36 @@ class MessagingInterface {
int broadcast(uint8_t *buffer, size_t size, bool durable); // todo
std::optional<SizeAndSource> recv(uint8_t *buffer, size_t size, uint8_t tag);
int sendrecv(uint8_t *send_buffer, size_t send_size, uint8_t dest, uint8_t send_tag,
uint8_t *recv_buffer, size_t recv_size, uint8_t recv_tag); // todo
uint8_t *recv_buffer, size_t recv_size,
uint8_t recv_tag); // todo
std::optional<std::unique_ptr<std::vector<uint8_t>>>
remote_call(uint8_t function_tag, uint8_t module, const std::vector<uint8_t> &parameters);
std::unordered_set<uint8_t> find_connected_modules(std::chrono::duration<double> scan_duration);
private:
void handle_recv();
void handle_fn_recv();
uint16_t m_sequence_number = 0;
uint8_t unique_fn_call_id = 0; // this is designed to overflow, change to uint16_t if we plan on
// having way more calls per second.
std::unordered_map<uint8_t, std::shared_ptr<ICommunicationClient>> m_id_to_lossless_client;
std::unordered_map<uint8_t, std::shared_ptr<ICommunicationClient>> m_id_to_lossy_client;
std::unordered_map<int, std::unique_ptr<BlockingQueue<std::unique_ptr<std::vector<uint8_t>>>>>
m_tag_to_queue_map;
// The semaphore needs to be in a unique_ptr, since it is not copyable or
// movable unordered_maps need to copy/move to reshuffle.
std::unordered_map<uint8_t, std::unique_ptr<std::binary_semaphore>> m_fn_call_to_semaphore;
std::unordered_map<uint8_t, std::unique_ptr<std::vector<uint8_t>>> m_fn_call_to_result;
std::unique_ptr<IDiscoveryService> m_discovery_service;
std::atomic<bool> m_stop_flag;
std::thread m_rx_thread;
std::thread m_fn_rx_thread;
std::shared_ptr<BlockingQueue<std::unique_ptr<std::vector<uint8_t>>>> m_rx_queue;
std::shared_mutex m_client_mutex;
std::shared_mutex m_scan_mutex;
std::mutex m_fn_call_mutex;
std::mutex m_tag_queue_mutex;
};
#endif // RPC_LIBRARY_H

2
include/mDNSRobotModule.h
View File

@@ -16,4 +16,4 @@ struct mDNSRobotModule {
std::vector<int> connected_module_ids;
};
#endif //ROBOTMODULEINSTANCE_H
#endif // ROBOTMODULEINSTANCE_H

2
include/util/log.h
View File

@@ -29,4 +29,4 @@ void print_errno() {
#endif
#endif //LOG_H
#endif // LOG_H

2
include/util/string.h
View File

@@ -20,4 +20,4 @@ inline std::vector<std::string> split(const std::string &str, const char delimit
return result;
}
#endif //STRING_H
#endif // STRING_H