22284637621

Committed 22 Feb 2026 10:51AM UTC coverage: 74.25% (-0.2%) from 74.442%

Build # 22284637621

Build Type

push

github

Committed by

Razakhel

Commit Message

[Network/HttpClient] Added an HTTP client class

- It internally uses the TCP client and can only handle GET requests for now

Run Details

9 of 42 new or added lines in 3 files covered. (21.43%)

8587 of 11565 relevant lines covered (74.25%)

1709.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.89

/src/RaZ/Script/LuaNetwork.cpp

#include "RaZ/Network/HttpClient.hpp"
#include "RaZ/Network/TcpClient.hpp"
#include "RaZ/Network/TcpServer.hpp"
#include "RaZ/Network/UdpClient.hpp"
#include "RaZ/Network/UdpServer.hpp"
#include "RaZ/Script/LuaWrapper.hpp"
#include "RaZ/Utils/TypeUtils.hpp"

#define SOL_ALL_SAFETIES_ON 1
#include "sol/sol.hpp"

namespace Raz {

using namespace TypeUtils;

void LuaWrapper::registerNetworkTypes() {
  sol::state& state = getState();

  {
    sol::usertype<HttpClient> httpClient = state.new_usertype<HttpClient>("HttpClient",
                                                                          sol::constructors<HttpClient(),
                                                                                            HttpClient(std::string)>());
    httpClient["connect"]    = &HttpClient::connect;
    httpClient["get"]        = &HttpClient::get;
    httpClient["disconnect"] = &HttpClient::disconnect;
  }

  {
    sol::usertype<TcpClient> tcpClient = state.new_usertype<TcpClient>("TcpClient",
                                                                       sol::constructors<TcpClient(),
                                                                                         TcpClient(const std::string&, unsigned short)>());
    tcpClient["isConnected"]               = &TcpClient::isConnected;
    tcpClient["connect"]                   = &TcpClient::connect;
    tcpClient["send"]                      = &TcpClient::send;
    tcpClient["recoverAvailableByteCount"] = &TcpClient::recoverAvailableByteCount;
    tcpClient["receive"]                   = sol::overload([] (TcpClient& c) { return c.receive(); },
                                                           PickOverload<bool>(&TcpClient::receive));
    tcpClient["receiveAtLeast"]            = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveAtLeast(b); },
                                                           PickOverload<std::size_t, bool>(&TcpClient::receiveAtLeast));
    tcpClient["receiveExactly"]            = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveExactly(b); },
                                                           PickOverload<std::size_t, bool>(&TcpClient::receiveExactly));
    tcpClient["receiveUntil"]              = sol::overload([] (TcpClient& c, std::string_view d) { return c.receiveUntil(d); },
                                                           PickOverload<std::string_view, bool>(&TcpClient::receiveUntil));
    tcpClient["disconnect"]                = &TcpClient::disconnect;
  }

  {
    sol::usertype<TcpServer> tcpServer = state.new_usertype<TcpServer>("TcpServer",
                                                                       sol::constructors<TcpServer(),
                                                                                         TcpServer(unsigned short)>());
    tcpServer["isRunning"] = &TcpServer::isRunning;
    tcpServer["start"]     = &TcpServer::start;
    tcpServer["stop"]      = &TcpServer::stop;
  }

  {
    sol::usertype<UdpClient> udpClient = state.new_usertype<UdpClient>("UdpClient",
                                                                       sol::constructors<UdpClient(),
                                                                                         UdpClient(const std::string&, unsigned short)>());
    udpClient["setDestination"]            = &UdpClient::setDestination;
    udpClient["send"]                      = &UdpClient::send;
    udpClient["recoverAvailableByteCount"] = &UdpClient::recoverAvailableByteCount;
    udpClient["receive"]                   = &UdpClient::receive;
    udpClient["close"]                     = &UdpClient::close;
  }

  {
    sol::usertype<UdpServer> udpServer = state.new_usertype<UdpServer>("UdpServer",
                                                                       sol::constructors<UdpServer(),
                                                                                         UdpServer(unsigned short)>());
    udpServer["isRunning"] = &UdpServer::isRunning;
    udpServer["start"]     = &UdpServer::start;
    udpServer["stop"]      = &UdpServer::stop;
  }
}

} // namespace Raz

1	#include "RaZ/Network/HttpClient.hpp"
2	#include "RaZ/Network/TcpClient.hpp"
3	#include "RaZ/Network/TcpServer.hpp"
4	#include "RaZ/Network/UdpClient.hpp"
5	#include "RaZ/Network/UdpServer.hpp"
6	#include "RaZ/Script/LuaWrapper.hpp"
7	#include "RaZ/Utils/TypeUtils.hpp"
8
9	#define SOL_ALL_SAFETIES_ON 1
10	#include "sol/sol.hpp"
11
12	namespace Raz {
13
14	using namespace TypeUtils;
15
16	void LuaWrapper::registerNetworkTypes() {	2✔
17	sol::state& state = getState();	2✔
18
19	{
20	sol::usertype<HttpClient> httpClient = state.new_usertype<HttpClient>("HttpClient",
NEW 21	sol::constructors<HttpClient(),	×
22	HttpClient(std::string)>());	2✔
23	httpClient["connect"] = &HttpClient::connect;	2✔
24	httpClient["get"] = &HttpClient::get;	2✔
25	httpClient["disconnect"] = &HttpClient::disconnect;	2✔
26	}	2✔
27
28	{
29	sol::usertype<TcpClient> tcpClient = state.new_usertype<TcpClient>("TcpClient",
30	sol::constructors<TcpClient(),	×
31	TcpClient(const std::string&, unsigned short)>());	2✔
32	tcpClient["isConnected"] = &TcpClient::isConnected;	2✔
33	tcpClient["connect"] = &TcpClient::connect;	2✔
34	tcpClient["send"] = &TcpClient::send;	2✔
35	tcpClient["recoverAvailableByteCount"] = &TcpClient::recoverAvailableByteCount;	2✔
36	tcpClient["receive"] = sol::overload([] (TcpClient& c) { return c.receive(); },	2✔
37	PickOverload<bool>(&TcpClient::receive));	4✔
38	tcpClient["receiveAtLeast"] = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveAtLeast(b); },	2✔
39	PickOverload<std::size_t, bool>(&TcpClient::receiveAtLeast));	4✔
40	tcpClient["receiveExactly"] = sol::overload([] (TcpClient& c, std::size_t b) { return c.receiveExactly(b); },	2✔
41	PickOverload<std::size_t, bool>(&TcpClient::receiveExactly));	4✔
42	tcpClient["receiveUntil"] = sol::overload([] (TcpClient& c, std::string_view d) { return c.receiveUntil(d); },	2✔
43	PickOverload<std::string_view, bool>(&TcpClient::receiveUntil));	4✔
44	tcpClient["disconnect"] = &TcpClient::disconnect;	2✔
45	}	2✔
46
47	{
48	sol::usertype<TcpServer> tcpServer = state.new_usertype<TcpServer>("TcpServer",
49	sol::constructors<TcpServer(),	×
50	TcpServer(unsigned short)>());	2✔
51	tcpServer["isRunning"] = &TcpServer::isRunning;	2✔
52	tcpServer["start"] = &TcpServer::start;	2✔
53	tcpServer["stop"] = &TcpServer::stop;	2✔
54	}	2✔
55
56	{
57	sol::usertype<UdpClient> udpClient = state.new_usertype<UdpClient>("UdpClient",
58	sol::constructors<UdpClient(),	×
59	UdpClient(const std::string&, unsigned short)>());	2✔
60	udpClient["setDestination"] = &UdpClient::setDestination;	2✔
61	udpClient["send"] = &UdpClient::send;	2✔
62	udpClient["recoverAvailableByteCount"] = &UdpClient::recoverAvailableByteCount;	2✔
63	udpClient["receive"] = &UdpClient::receive;	2✔
64	udpClient["close"] = &UdpClient::close;	2✔
65	}	2✔
66
67	{
68	sol::usertype<UdpServer> udpServer = state.new_usertype<UdpServer>("UdpServer",
69	sol::constructors<UdpServer(),	×
70	UdpServer(unsigned short)>());	2✔
71	udpServer["isRunning"] = &UdpServer::isRunning;	2✔
72	udpServer["start"] = &UdpServer::start;	2✔
73	udpServer["stop"] = &UdpServer::stop;	2✔
74	}	2✔
75	}	2✔
76
77	} // namespace Raz

Razakhel / RaZ / 22284637621

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous