Fix compilation and apply suggestions (part 4)

Author: PabloMK7

src/core/file_sys/archive_artic.cpp

@@ -140,7 +140,7 @@ ResultVal<std::unique_ptr<FileBackend>> ArticArchive::OpenFile(const Path& path,
         client->ReportArticEvent(static_cast<u64>(report_artic_event) | (1ULL << 32));
     }
 
-    return std::make_unique<ArticFileBackend>(client, *handle_opt, *this, cache_provider, path);
+    return std::make_unique<ArticFileBackend>(client, *handle_opt, *this, *cache_provider, path);
 }
 
 Result ArticArchive::DeleteFile(const Path& path) const {

src/network/artic_base/artic_base_client.cpp

@@ -51,8 +51,7 @@
 
 // #define DISABLE_PING_TIMEOUT
 
-namespace Network {
-namespace ArticBase {
+namespace Network::ArticBase {
 
 using namespace std::chrono_literals;
 
@@ -61,10 +60,9 @@ bool Client::Request::AddParameterS8(s8 parameter) {
         ARTICBASE_ERROR("Too many parameters added to method: {}", method_name);
         return false;
     }
-    ArticBaseCommon::RequestParameter currParam;
-    currParam.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_8;
-    *reinterpret_cast<s8*>(currParam.data) = parameter;
-    parameters.push_back(currParam);
+    auto& param = parameters.emplace_back();
+    param.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_8;
+    memcpy(param.data, &parameter, sizeof(s8));
     return true;
 }
 
@@ -73,10 +71,9 @@ bool Client::Request::AddParameterS16(s16 parameter) {
         ARTICBASE_ERROR("Too many parameters added to method: {}", method_name);
         return false;
     }
-    ArticBaseCommon::RequestParameter currParam;
-    currParam.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_16;
-    *reinterpret_cast<s16*>(currParam.data) = parameter;
-    parameters.push_back(currParam);
+    auto& param = parameters.emplace_back();
+    param.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_16;
+    memcpy(param.data, &parameter, sizeof(s16));
     return true;
 }
 
@@ -85,10 +82,9 @@ bool Client::Request::AddParameterS32(s32 parameter) {
         ARTICBASE_ERROR("Too many parameters added to method: {}", method_name);
         return false;
     }
-    ArticBaseCommon::RequestParameter currParam;
-    currParam.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_32;
-    *reinterpret_cast<s32*>(currParam.data) = parameter;
-    parameters.push_back(currParam);
+    auto& param = parameters.emplace_back();
+    param.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_32;
+    memcpy(param.data, &parameter, sizeof(s32));
     return true;
 }
 
@@ -97,10 +93,9 @@ bool Client::Request::AddParameterS64(s64 parameter) {
         ARTICBASE_ERROR("Too many parameters added to method: {}", method_name);
         return false;
     }
-    ArticBaseCommon::RequestParameter currParam;
-    currParam.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_64;
-    *reinterpret_cast<s64*>(currParam.data) = parameter;
-    parameters.push_back(currParam);
+    auto& param = parameters.emplace_back();
+    param.type = ArticBaseCommon::RequestParameterType::IN_INTEGER_64;
+    memcpy(param.data, &parameter, sizeof(s64));
     return true;
 }
 
@@ -109,18 +104,18 @@ bool Client::Request::AddParameterBuffer(const void* buffer, size_t size) {
         ARTICBASE_ERROR("Too many parameters added to method: {}", method_name);
         return false;
     }
-    ArticBaseCommon::RequestParameter currParam;
-    if (size <= sizeof(currParam.data)) {
-        currParam.type = ArticBaseCommon::RequestParameterType::IN_SMALL_BUFFER;
-        memcpy(currParam.data, buffer, size);
-        currParam.parameterSize = static_cast<u16>(size);
+    auto& param = parameters.emplace_back();
+    if (size <= sizeof(param.data)) {
+        param.type = ArticBaseCommon::RequestParameterType::IN_SMALL_BUFFER;
+        memcpy(param.data, buffer, size);
+        param.parameterSize = static_cast<u16>(size);
     } else {
-        currParam.type = ArticBaseCommon::RequestParameterType::IN_BIG_BUFFER;
-        currParam.bigBufferID = static_cast<u16>(pending_big_buffers.size());
-        *reinterpret_cast<s32*>(currParam.data) = static_cast<s32>(size);
+        param.type = ArticBaseCommon::RequestParameterType::IN_BIG_BUFFER;
+        param.bigBufferID = static_cast<u16>(pending_big_buffers.size());
+        s32 size_32 = static_cast<s32>(size);
+        memcpy(param.data, &size_32, sizeof(size_32));
         pending_big_buffers.push_back(std::make_pair(buffer, size));
     }
-    parameters.push_back(currParam);
     return true;
 }
 
@@ -152,7 +147,7 @@ bool Client::Connect() {
     if (connected)
         return true;
 
-    auto strToUInt = [](const std::string& str) -> int {
+    auto str_to_int = [](const std::string& str) -> int {
         char* pEnd = NULL;
         unsigned long ul = ::strtoul(str.c_str(), &pEnd, 10);
         if (*pEnd)
@@ -203,7 +198,7 @@ bool Client::Connect() {
 
     auto version = SendSimpleRequest("VERSION");
     if (version.has_value()) {
-        int version_value = strToUInt(*version);
+        int version_value = str_to_int(*version);
         if (version_value != SERVER_VERSION) {
             shutdown(main_socket, SHUT_RDWR);
             closesocket(main_socket);
@@ -222,7 +217,7 @@ bool Client::Connect() {
     auto max_work_size = SendSimpleRequest("MAXSIZE");
     int max_work_size_value = -1;
     if (max_work_size.has_value()) {
-        max_work_size_value = strToUInt(*max_work_size);
+        max_work_size_value = str_to_int(*max_work_size);
     }
     if (max_work_size_value < 0) {
         shutdown(main_socket, SHUT_RDWR);
@@ -236,7 +231,7 @@ bool Client::Connect() {
     auto max_params = SendSimpleRequest("MAXPARAM");
     int max_param_value = -1;
     if (max_params.has_value()) {
-        max_param_value = strToUInt(*max_params);
+        max_param_value = str_to_int(*max_params);
     }
     if (max_param_value < 0) {
         shutdown(main_socket, SHUT_RDWR);
@@ -259,7 +254,7 @@ bool Client::Connect() {
     std::string str_port;
     std::stringstream ss_port(*worker_ports);
     while (std::getline(ss_port, str_port, ',')) {
-        int port = strToUInt(str_port);
+        int port = str_to_int(str_port);
         if (port < 0 || port > USHRT_MAX) {
             shutdown(main_socket, SHUT_RDWR);
             closesocket(main_socket);
@@ -376,7 +371,7 @@ std::optional<Client::Response> Client::Send(Request& request) {
     }
 
     std::unique_lock<std::mutex> cv_lk(resp.cv_mutex);
-    resp.cv.wait(cv_lk, [&resp]() { return resp._done; });
+    resp.cv.wait(cv_lk, [&resp]() { return resp.is_done; });
 
     return std::optional<Client::Response>(std::move(resp.response));
 }
@@ -726,7 +721,7 @@ void Client::Handler::RunLoop() {
 
         {
             std::scoped_lock<std::mutex> lk(pending_response->cv_mutex);
-            pending_response->_done = true;
+            pending_response->is_done = true;
             pending_response->cv.notify_one();
         }
     }
@@ -742,12 +737,11 @@ void Client::OnAllHandlersFinished() {
         std::scoped_lock l(recv_map_mutex);
         for (auto it = pending_responses.begin(); it != pending_responses.end(); it++) {
             std::scoped_lock l2(it->second->cv_mutex);
-            it->second->_done = true;
+            it->second->is_done = true;
             it->second->cv.notify_one();
         }
         pending_responses.clear();
     }
 }
 
-} // namespace ArticBase
-} // namespace Network
+} // namespace Network::ArticBase

src/network/artic_base/artic_base_client.h

@@ -19,8 +19,7 @@ using SocketHolder = unsigned long long;
 using SocketHolder = int;
 #endif // _WIN32
 
-namespace Network {
-namespace ArticBase {
+namespace Network::ArticBase {
 
 class Client {
 public:
@@ -261,7 +260,7 @@ class Client {
 private:
     class PendingResponse {
     public:
-        bool _done = false;
+        bool is_done = false;
 
     private:
         friend class Client;
@@ -282,5 +281,4 @@ class Client {
     std::atomic<size_t> running_handlers;
     void OnAllHandlersFinished();
 };
-} // namespace ArticBase
-} // namespace Network
+} // namespace Network::ArticBase