Skip to content

Commit 1e24cb7

Browse files
MorganCaronMorganCaron
committed
Network: Code cleaning
1 parent 66caad6 commit 1e24cb7

5 files changed

Lines changed: 42 additions & 39 deletions

File tree

‎modules/Network/Http/Server.mpp‎

Lines changed: 8 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -24,17 +24,20 @@ export namespace CppUtils::Network::Http
2424
[this] {
2525
if (auto clientResult = m_server.accept(); clientResult)
2626
{
27-
clientResult.value().setBlocking(true);
27+
auto _ = clientResult.value().setBlocking(true);
2828
m_threadPool.call([this, client = std::move(clientResult.value())]() mutable {
2929
handleClient(std::move(client));
3030
});
3131
}
3232
},
33-
[this] { m_server.shutdown(); }
34-
}
33+
[this] { auto _ = m_server.shutdown(); }}
3534
{
36-
m_server.setReuseAddress(true);
37-
m_server.setBlocking(true);
35+
{
36+
auto _ = m_server.setReuseAddress(true);
37+
}
38+
{
39+
auto _ = m_server.setBlocking(true);
40+
}
3841
if (auto result = m_server.bind(port); not result)
3942
throw std::system_error{result.error(), "HTTP Server bind failed"};
4043
if (auto result = m_server.listen(); not result)

‎modules/Network/Server.mpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ export namespace CppUtils::Network
2525
Socket::Type type = Socket::Type::TCP):
2626
Socket{domain, type}
2727
{
28-
setIPv6Only(false);
28+
auto _ = setIPv6Only(false);
2929
}
3030

3131
[[nodiscard]] inline auto bind(std::uint16_t port) const -> std::expected<void, std::error_code>

‎modules/Network/Socket.mpp‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -202,7 +202,7 @@ export namespace CppUtils::Network
202202
#endif
203203
};
204204

205-
inline auto shutdown(ShutdownMode mode = ShutdownMode::Both) const -> std::expected<void, std::error_code>
205+
[[nodiscard]] inline auto shutdown(ShutdownMode mode = ShutdownMode::Both) const -> std::expected<void, std::error_code>
206206
{
207207
if (auto result = expectSocket(::shutdown(m_socket, static_cast<int>(mode))); not result)
208208
return std::unexpected{result.error()};
@@ -246,7 +246,7 @@ export namespace CppUtils::Network
246246
return addressToEndpoint(address);
247247
}
248248

249-
inline auto setIPv6Only(bool enable) const -> std::expected<void, std::error_code>
249+
[[nodiscard]] inline auto setIPv6Only(bool enable) const -> std::expected<void, std::error_code>
250250
{
251251
if (m_domain != Domain::IPV6)
252252
return {};
@@ -256,15 +256,15 @@ export namespace CppUtils::Network
256256
return {};
257257
}
258258

259-
inline auto setReuseAddress(bool enable) const -> std::expected<void, std::error_code>
259+
[[nodiscard]] inline auto setReuseAddress(bool enable) const -> std::expected<void, std::error_code>
260260
{
261261
auto value = static_cast<int>(enable);
262262
if (not setSocketOption(m_socket, SOL_SOCKET, SO_REUSEADDR, std::addressof(value), sizeof(value)))
263263
return std::unexpected{lastErrorCode()};
264264
return {};
265265
}
266266

267-
inline auto setBlocking(bool enable) -> std::expected<void, std::error_code>
267+
[[nodiscard]] inline auto setBlocking(bool enable) -> std::expected<void, std::error_code>
268268
{
269269
m_isBlocking = enable;
270270
#if defined(OS_WINDOWS)
@@ -325,7 +325,7 @@ export namespace CppUtils::Network
325325
return {};
326326
}
327327

328-
inline auto send(const void* data, std::size_t size) -> std::expected<void, std::error_code>
328+
[[nodiscard]] inline auto send(const void* data, std::size_t size) -> std::expected<void, std::error_code>
329329
{
330330
if (m_type == Type::UDP)
331331
return std::unexpected{std::make_error_code(std::errc::invalid_argument)};
@@ -350,7 +350,7 @@ export namespace CppUtils::Network
350350
return {};
351351
}
352352

353-
inline auto sendDatagram(const void* data, std::size_t size, std::string_view ip, std::uint16_t port) -> std::expected<void, std::error_code>
353+
[[nodiscard]] inline auto sendDatagram(const void* data, std::size_t size, std::string_view ip, std::uint16_t port) -> std::expected<void, std::error_code>
354354
{
355355
if (m_type != Type::UDP)
356356
return std::unexpected{std::make_error_code(std::errc::invalid_argument)};
@@ -366,22 +366,22 @@ export namespace CppUtils::Network
366366
return {};
367367
}
368368

369-
inline auto send(std::string_view string) -> std::expected<void, std::error_code>
369+
[[nodiscard]] inline auto send(std::string_view string) -> std::expected<void, std::error_code>
370370
{
371371
return send(std::data(string), std::size(string));
372372
}
373373

374-
inline auto send(const std::vector<std::byte>& data) -> std::expected<void, std::error_code>
374+
[[nodiscard]] inline auto send(const std::vector<std::byte>& data) -> std::expected<void, std::error_code>
375375
{
376376
return send(std::data(data), std::size(data));
377377
}
378378

379-
inline auto sendDatagram(std::string_view string, std::string_view ip, std::uint16_t port) -> std::expected<void, std::error_code>
379+
[[nodiscard]] inline auto sendDatagram(std::string_view string, std::string_view ip, std::uint16_t port) -> std::expected<void, std::error_code>
380380
{
381381
return sendDatagram(std::data(string), std::size(string), ip, port);
382382
}
383383

384-
inline auto send(const CppUtils::Type::TriviallyCopyable auto& data) -> std::expected<void, std::error_code>
384+
[[nodiscard]] inline auto send(const CppUtils::Type::TriviallyCopyable auto& data) -> std::expected<void, std::error_code>
385385
{
386386
return send(std::addressof(data), sizeof(decltype(data)));
387387
}

‎tests/Network/Server.mpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -15,24 +15,24 @@ namespace CppUtils::UnitTest::Network
1515

1616
suite.addTest("Bind IP", [&] {
1717
auto server = CppUtils::Network::Server{};
18-
server.setReuseAddress(true);
18+
suite.expect(server.setReuseAddress(true));
1919
suite.expect(server.bind(8'080));
2020
});
2121

2222
suite.addTest("Listening", [&] {
2323
auto server = CppUtils::Network::Server{};
24-
server.setReuseAddress(true);
24+
suite.expect(server.setReuseAddress(true));
2525
suite.expect(server.bind(8'080));
2626
suite.expect(server.listen());
2727
Logger::print("Server: Waiting for connections on port 8080...");
2828
});
2929

3030
suite.addTest("Abort connection", [&] {
3131
auto server = CppUtils::Network::Server{};
32-
server.setReuseAddress(true);
32+
suite.expect(server.setReuseAddress(true));
3333
suite.expect(server.bind(8'080));
3434
suite.expect(server.listen());
35-
server.setBlocking(false);
35+
suite.expect(server.setBlocking(false));
3636
Logger::print("Server: Waiting for connections on port 8080...");
3737
auto clientSocket = server.accept();
3838
suite.expect(not clientSocket);

‎tests/Network/Socket.mpp‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ namespace CppUtils::UnitTest::Network
1717

1818
auto serverListening = CppUtils::Thread::tryAsync([&] {
1919
auto server = CppUtils::Network::Server{};
20-
server.setReuseAddress(true);
20+
suite.expect(server.setReuseAddress(true));
2121
suite.expect(server.bind(8'080));
2222
suite.expect(server.listen());
2323
Logger::print("Server: Waiting for connections on port 8080...");
@@ -47,7 +47,7 @@ namespace CppUtils::UnitTest::Network
4747

4848
auto serverListening = CppUtils::Thread::tryAsync([&] {
4949
auto server = CppUtils::Network::Server{};
50-
server.setReuseAddress(true);
50+
suite.expect(server.setReuseAddress(true));
5151
suite.expect(server.bind(8'080));
5252
suite.expect(server.listen());
5353
Logger::print("Server: Waiting for connections on port 8080...");
@@ -56,7 +56,7 @@ namespace CppUtils::UnitTest::Network
5656
auto clientSocket = server.accept();
5757
suite.expect(clientSocket);
5858
Logger::print("Server: A new client has joined");
59-
clientSocket->setBlocking(true);
59+
suite.expect(clientSocket->setBlocking(true));
6060
Logger::print("Server: Blocking enabled");
6161
});
6262

@@ -65,7 +65,7 @@ namespace CppUtils::UnitTest::Network
6565
auto client = CppUtils::Network::Client{};
6666
Logger::print("Client: Attempting to connect...");
6767
suite.expect(client.connect("", 8'080));
68-
client.setBlocking(true);
68+
suite.expect(client.setBlocking(true));
6969
Logger::print("Client: Blocking enabled");
7070
});
7171

@@ -80,7 +80,7 @@ namespace CppUtils::UnitTest::Network
8080

8181
auto serverListening = CppUtils::Thread::tryAsync([&] {
8282
auto server = CppUtils::Network::Server{};
83-
server.setReuseAddress(true);
83+
suite.expect(server.setReuseAddress(true));
8484
suite.expect(server.bind(8'080));
8585
suite.expect(server.listen());
8686
Logger::print("Server: Waiting for connections on port 8080...");
@@ -92,7 +92,7 @@ namespace CppUtils::UnitTest::Network
9292
auto clientSocket = std::move(clientSocketResult.value());
9393
Logger::print("Server: A new client has joined");
9494

95-
clientSocket.setBlocking(true);
95+
suite.expect(clientSocket.setBlocking(true));
9696
Logger::print("Server: Socket set to blocking mode");
9797

9898
auto number = clientSocket.receive<int>();
@@ -110,7 +110,7 @@ namespace CppUtils::UnitTest::Network
110110
serverisReady.wait(false);
111111
auto client = CppUtils::Network::Client{};
112112
Logger::print("Client: Attempting to connect...");
113-
client.setBlocking(true);
113+
suite.expect(client.setBlocking(true));
114114
suite.expect(client.connect("", 8'080));
115115
Logger::print("Client: Connected to server");
116116

@@ -136,7 +136,7 @@ namespace CppUtils::UnitTest::Network
136136

137137
auto serverListening = CppUtils::Thread::tryAsync([&] {
138138
auto server = CppUtils::Network::Server{};
139-
server.setReuseAddress(true);
139+
suite.expect(server.setReuseAddress(true));
140140
suite.expect(server.bind(8'080));
141141
suite.expect(server.listen());
142142
Logger::print("Server: Waiting for connections on port 8080...");
@@ -148,7 +148,7 @@ namespace CppUtils::UnitTest::Network
148148
auto clientSocket = std::move(clientSocketResult.value());
149149
Logger::print("Server: A new client has joined");
150150

151-
clientSocket.setBlocking(true);
151+
suite.expect(clientSocket.setBlocking(true));
152152
Logger::print("Server: Socket set to blocking mode");
153153

154154
auto messageLength = clientSocket.receive<std::size_t>();
@@ -170,7 +170,7 @@ namespace CppUtils::UnitTest::Network
170170
serverisReady.wait(false);
171171
auto client = CppUtils::Network::Client{};
172172
Logger::print("Client: Attempting to connect...");
173-
client.setBlocking(true);
173+
suite.expect(client.setBlocking(true));
174174
suite.expect(client.connect("", 8'080));
175175
Logger::print("Client: Connected");
176176

@@ -200,7 +200,7 @@ namespace CppUtils::UnitTest::Network
200200

201201
auto serverListening = CppUtils::Thread::tryAsync([&] {
202202
auto server = CppUtils::Network::Server{CppUtils::Network::Socket::Domain::IPV4, CppUtils::Network::Socket::Type::UDP};
203-
server.setReuseAddress(true);
203+
suite.expect(server.setReuseAddress(true));
204204
suite.expect(server.bind(8'080));
205205

206206
serverisReady.store(true, std::memory_order_release);
@@ -242,7 +242,7 @@ namespace CppUtils::UnitTest::Network
242242

243243
auto serverListening = CppUtils::Thread::tryAsync([&] {
244244
auto server = CppUtils::Network::Server{};
245-
server.setReuseAddress(true);
245+
suite.expect(server.setReuseAddress(true));
246246
suite.expect(server.bind(8'080));
247247
suite.expect(server.listen());
248248
serverisReady.store(true, std::memory_order_release);
@@ -258,7 +258,7 @@ namespace CppUtils::UnitTest::Network
258258
serverisReady.wait(false);
259259
auto client = CppUtils::Network::Client{};
260260
suite.expect(client.connect("", 8'080));
261-
client.setBlocking(false);
261+
suite.expect(client.setBlocking(false));
262262

263263
suite.expect(client.isReadyForRead(5s));
264264
auto data = client.receive<int>();
@@ -279,7 +279,7 @@ namespace CppUtils::UnitTest::Network
279279

280280
auto serverListening = CppUtils::Thread::tryAsync([&] {
281281
auto server = CppUtils::Network::Server{};
282-
server.setReuseAddress(true);
282+
suite.expect(server.setReuseAddress(true));
283283
suite.expect(server.bind(8'080));
284284
suite.expect(server.listen());
285285
serverisReady.store(true, std::memory_order_release);
@@ -294,7 +294,7 @@ namespace CppUtils::UnitTest::Network
294294
serverisReady.wait(false);
295295
auto client = CppUtils::Network::Client{};
296296
suite.expect(client.connect("", 8'080));
297-
client.setBlocking(false);
297+
suite.expect(client.setBlocking(false));
298298
suite.expect(not client.isReadyForRead(100ms));
299299
});
300300

@@ -309,7 +309,7 @@ namespace CppUtils::UnitTest::Network
309309

310310
auto serverListening = CppUtils::Thread::tryAsync([&] {
311311
auto server = CppUtils::Network::Server{};
312-
server.setReuseAddress(true);
312+
suite.expect(server.setReuseAddress(true));
313313
suite.expect(server.bind(8'080));
314314
suite.expect(server.listen());
315315
serverisReady.store(true, std::memory_order_release);
@@ -324,7 +324,7 @@ namespace CppUtils::UnitTest::Network
324324
serverisReady.wait(false);
325325
auto client = CppUtils::Network::Client{};
326326
suite.expect(client.connect("", 8'080));
327-
client.setBlocking(false);
327+
suite.expect(client.setBlocking(false));
328328

329329
auto result = client.receive<int>();
330330
suite.expect(not result);
@@ -342,7 +342,7 @@ namespace CppUtils::UnitTest::Network
342342

343343
auto serverListening = CppUtils::Thread::tryAsync([&] {
344344
auto server = CppUtils::Network::Server{};
345-
server.setReuseAddress(true);
345+
suite.expect(server.setReuseAddress(true));
346346
suite.expect(server.bind(8'080));
347347
suite.expect(server.listen());
348348
serverisReady.store(true, std::memory_order_release);
@@ -371,7 +371,7 @@ namespace CppUtils::UnitTest::Network
371371

372372
auto serverListening = CppUtils::Thread::tryAsync([&] {
373373
auto server = CppUtils::Network::Server{};
374-
server.setReuseAddress(true);
374+
suite.expect(server.setReuseAddress(true));
375375
suite.expect(server.bind(8'080));
376376
suite.expect(server.listen());
377377
serverisReady.store(true, std::memory_order_release);

0 commit comments

Comments
 (0)