- use const auto& where possible

- avoid using const std::unique_ptr& and const std::shared_ptr&
- avoid wrapping results in std::optional
- prefer std::string_view over const std::string&
- update FSUtils::LoadFileToMem to write into std::vector<uint8_t>
- use std::span when possible
- Avoid unnessecary copies in PluginDataFactory
- allocate plugins as HeapMemoryFixedSize which bascially is a std::unique_ptr with fixed size

source/fs/FSUtils.cpp

@@ -1,26 +1,23 @@
 #include "fs/FSUtils.h"
-#include "fs/CFile.hpp"
 #include "utils/logger.h"
 #include "utils/utils.h"
 #include <cstdio>
 #include <cstring>
 #include <fcntl.h>
-#include <malloc.h>
+#include <filesystem>
 #include <unistd.h>
+#include <vector>
 
-int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
-    //! always initialze input
-    *inbuffer = NULL;
-    if (size) {
-        *size = 0;
-    }
+int32_t FSUtils::LoadFileToMem(std::string_view filepath, std::vector<uint8_t> &buffer) {
+    //! always initialize input
+    buffer.clear();
 
-    int32_t iFd = open(filepath, O_RDONLY);
+    int32_t iFd = open(filepath.data(), O_RDONLY);
     if (iFd < 0) {
         return -1;
     }
 
-    struct stat file_stat;
+    struct stat file_stat {};
     int rc = fstat(iFd, &file_stat);
     if (rc < 0) {
         close(iFd);
@@ -28,11 +25,7 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
     }
     uint32_t filesize = file_stat.st_size;
 
-    auto *buffer = (uint8_t *) memalign(0x40, ROUNDUP(filesize, 0x40));
-    if (buffer == nullptr) {
-        close(iFd);
-        return -2;
-    }
+    buffer.resize(filesize);
 
     uint32_t blocksize = 0x80000;
     uint32_t done      = 0;
@@ -42,7 +35,7 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
         if (done + blocksize > filesize) {
             blocksize = filesize - done;
         }
-        readBytes = read(iFd, buffer + done, blocksize);
+        readBytes = read(iFd, buffer.data() + done, blocksize);
         if (readBytes <= 0) {
             break;
         }
@@ -52,99 +45,17 @@ int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_
     ::close(iFd);
 
     if (done != filesize) {
-        free(buffer);
-        buffer = nullptr;
+        buffer.clear();
         return -3;
     }
 
-    *inbuffer = buffer;
-
-    //! sign is optional input
-    if (size) {
-        *size = filesize;
-    }
-
-    return filesize;
-}
-
-int32_t FSUtils::CheckFile(const char *filepath) {
-    if (!filepath)
-        return 0;
-
-    struct stat filestat;
-
-    char dirnoslash[strlen(filepath) + 2];
-    snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
-
-    while (dirnoslash[strlen(dirnoslash) - 1] == '/')
-        dirnoslash[strlen(dirnoslash) - 1] = '\0';
-
-    char *notRoot = strrchr(dirnoslash, '/');
-    if (!notRoot) {
-        strcat(dirnoslash, "/");
-    }
-
-    if (stat(dirnoslash, &filestat) == 0)
-        return 1;
-
     return 0;
 }
 
-int32_t FSUtils::CreateSubfolder(const char *fullpath) {
-    if (!fullpath)
-        return 0;
-
-    int32_t result = 0;
-
-    char dirnoslash[strlen(fullpath) + 1];
-    strcpy(dirnoslash, fullpath);
-
-    int32_t pos = strlen(dirnoslash) - 1;
-    while (dirnoslash[pos] == '/') {
-        dirnoslash[pos] = '\0';
-        pos--;
+bool FSUtils::CreateSubfolder(std::string_view fullpath) {
+    std::error_code err;
+    if (!std::filesystem::create_directories(fullpath, err)) {
+        return std::filesystem::exists(fullpath, err);
     }
-
-    if (CheckFile(dirnoslash)) {
-        return 1;
-    } else {
-        char parentpath[strlen(dirnoslash) + 2];
-        strcpy(parentpath, dirnoslash);
-        char *ptr = strrchr(parentpath, '/');
-
-        if (!ptr) {
-            //!Device root directory (must be with '/')
-            strcat(parentpath, "/");
-            struct stat filestat;
-            if (stat(parentpath, &filestat) == 0)
-                return 1;
-
-            return 0;
-        }
-
-        ptr++;
-        ptr[0] = '\0';
-
-        result = CreateSubfolder(parentpath);
-    }
-
-    if (!result)
-        return 0;
-
-    if (mkdir(dirnoslash, 0777) == -1) {
-        return 0;
-    }
-
-    return 1;
-}
-
-int32_t FSUtils::saveBufferToFile(const char *path, void *buffer, uint32_t size) {
-    CFile file(path, CFile::WriteOnly);
-    if (!file.isOpen()) {
-        DEBUG_FUNCTION_LINE("Failed to open %s\n", path);
-        return 0;
-    }
-    int32_t written = file.write((const uint8_t *) buffer, size);
-    file.close();
-    return written;
+    return true;
 }

source/fs/FSUtils.h

@@ -1,18 +1,12 @@
-#ifndef __FS_UTILS_H_
-#define __FS_UTILS_H_
+#pragma once
 
+#include <string>
+#include <vector>
 #include <wut_types.h>
 
 class FSUtils {
 public:
-    static int32_t LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size);
+    static int32_t LoadFileToMem(std::string_view filepath, std::vector<uint8_t> &buffer);
 
-    //! todo: C++ class
-    static int32_t CreateSubfolder(const char *fullpath);
-
-    static int32_t CheckFile(const char *filepath);
-
-    static int32_t saveBufferToFile(const char *path, void *buffer, uint32_t size);
+    static bool CreateSubfolder(std::string_view fullpath);
 };
-
-#endif // __FS_UTILS_H_