Code cleanup

source/plugin/FunctionData.cpp

@@ -1,67 +1,75 @@
 #include "FunctionData.h"
+#include "utils/logger.h"
 
-FunctionData::FunctionData(void *paddress, void *vaddress, std::string_view name, function_replacement_library_type_t library, void *replaceAddr, void *replaceCall, FunctionPatcherTargetProcess targetProcess) {
-    this->paddress      = paddress;
-    this->vaddress      = vaddress;
-    this->name          = name;
-    this->library       = library;
-    this->targetProcess = targetProcess;
-    this->replaceAddr   = replaceAddr;
-    this->replaceCall   = replaceCall;
+#include <function_patcher/function_patching.h>
+#include <string>
+
+FunctionData::FunctionData(void *paddress, void *vaddress,
+                           const std::string_view name,
+                           const function_replacement_library_type_t library,
+                           void *replaceAddr, void *replaceCall,
+                           const FunctionPatcherTargetProcess targetProcess) {
+    this->mPAddress      = paddress;
+    this->mVAddress      = vaddress;
+    this->mName          = name;
+    this->mLibrary       = library;
+    this->mTargetProcess = targetProcess;
+    this->mReplaceAddr   = replaceAddr;
+    this->mReplaceCall   = replaceCall;
 }
 
 FunctionData::~FunctionData() {
-    if (handle != 0) {
+    if (mHandle != 0) {
         DEBUG_FUNCTION_LINE_WARN("Destroying FunctionData while it was still patched. This should never happen.");
         RemovePatch();
     }
 }
 
 const std::string &FunctionData::getName() const {
-    return this->name;
+    return this->mName;
 }
 
 function_replacement_library_type_t FunctionData::getLibrary() const {
-    return this->library;
+    return this->mLibrary;
 }
 
 const void *FunctionData::getPhysicalAddress() const {
-    return paddress;
+    return mPAddress;
 }
 
 const void *FunctionData::getVirtualAddress() const {
-    return vaddress;
+    return mVAddress;
 }
 
 const void *FunctionData::getReplaceAddress() const {
-    return replaceAddr;
+    return mReplaceAddr;
 }
 
 const void *FunctionData::getReplaceCall() const {
-    return replaceCall;
+    return mReplaceCall;
 }
 
 FunctionPatcherTargetProcess FunctionData::getTargetProcess() const {
-    return targetProcess;
+    return mTargetProcess;
 }
 
 bool FunctionData::AddPatch() {
-    if (handle == 0) {
+    if (mHandle == 0) {
         function_replacement_data_t functionData = {
                 .version       = FUNCTION_REPLACEMENT_DATA_STRUCT_VERSION,
                 .type          = FUNCTION_PATCHER_REPLACE_BY_LIB_OR_ADDRESS,
-                .physicalAddr  = reinterpret_cast<uint32_t>(this->paddress),
-                .virtualAddr   = reinterpret_cast<uint32_t>(this->vaddress),
-                .replaceAddr   = reinterpret_cast<uint32_t>(this->replaceAddr),
-                .replaceCall   = static_cast<uint32_t *>(this->replaceCall),
-                .targetProcess = this->targetProcess,
+                .physicalAddr  = reinterpret_cast<uint32_t>(this->mPAddress),
+                .virtualAddr   = reinterpret_cast<uint32_t>(this->mVAddress),
+                .replaceAddr   = reinterpret_cast<uint32_t>(this->mReplaceAddr),
+                .replaceCall   = static_cast<uint32_t *>(this->mReplaceCall),
+                .targetProcess = this->mTargetProcess,
                 .ReplaceInRPL  = {
-                         .function_name = this->name.c_str(),
-                         .library       = this->library,
+                         .function_name = this->mName.c_str(),
+                         .library       = this->mLibrary,
                 }};
 
-        if (FunctionPatcher_AddFunctionPatch(&functionData, &handle, nullptr) != FUNCTION_PATCHER_RESULT_SUCCESS) {
-            DEBUG_FUNCTION_LINE_ERR("Failed to add patch for function (\"%s\" PA:%08X VA:%08X)", this->name.c_str(), this->paddress, this->vaddress);
+        if (FunctionPatcher_AddFunctionPatch(&functionData, &mHandle, nullptr) != FUNCTION_PATCHER_RESULT_SUCCESS) {
+            DEBUG_FUNCTION_LINE_ERR("Failed to add patch for function (\"%s\" PA:%08X VA:%08X)", this->mName.c_str(), this->mPAddress, this->mVAddress);
             return false;
         }
     } else {
@@ -71,12 +79,12 @@ bool FunctionData::AddPatch() {
 }
 
 bool FunctionData::RemovePatch() {
-    if (handle != 0) {
-        if (FunctionPatcher_RemoveFunctionPatch(handle) != FUNCTION_PATCHER_RESULT_SUCCESS) {
+    if (mHandle != 0) {
+        if (FunctionPatcher_RemoveFunctionPatch(mHandle) != FUNCTION_PATCHER_RESULT_SUCCESS) {
             DEBUG_FUNCTION_LINE_ERR("Failed to remove patch for function");
             return false;
         }
-        handle = 0;
+        mHandle = 0;
     } else {
         DEBUG_FUNCTION_LINE_VERBOSE("Was not patched.");
     }

source/plugin/FunctionData.h

@@ -16,45 +16,48 @@
  ****************************************************************************/
 #pragma once
 
-#include "utils/logger.h"
 #include <function_patcher/fpatching_defines.h>
-#include <function_patcher/function_patching.h>
 #include <string>
 
 class FunctionData {
 
 public:
-    FunctionData(void *paddress, void *vaddress, std::string_view name, function_replacement_library_type_t library, void *replaceAddr, void *replaceCall,
+    FunctionData(void *paddress,
+                 void *vaddress,
+                 std::string_view name,
+                 function_replacement_library_type_t library,
+                 void *replaceAddr,
+                 void *replaceCall,
                  FunctionPatcherTargetProcess targetProcess);
 
     ~FunctionData();
 
     [[nodiscard]] const std::string &getName() const;
 
-    [[maybe_unused]] [[nodiscard]] function_replacement_library_type_t getLibrary() const;
+    [[nodiscard]] function_replacement_library_type_t getLibrary() const;
 
-    [[maybe_unused]] [[nodiscard]] const void *getPhysicalAddress() const;
+    [[nodiscard]] const void *getPhysicalAddress() const;
 
-    [[maybe_unused]] [[nodiscard]] const void *getVirtualAddress() const;
+    [[nodiscard]] const void *getVirtualAddress() const;
 
-    [[maybe_unused]] [[nodiscard]] const void *getReplaceAddress() const;
+    [[nodiscard]] const void *getReplaceAddress() const;
 
-    [[maybe_unused]] [[nodiscard]] const void *getReplaceCall() const;
+    [[nodiscard]] const void *getReplaceCall() const;
 
-    [[maybe_unused]] [[nodiscard]] FunctionPatcherTargetProcess getTargetProcess() const;
+    [[nodiscard]] FunctionPatcherTargetProcess getTargetProcess() const;
 
     bool AddPatch();
 
     bool RemovePatch();
 
 private:
-    void *paddress = nullptr;
-    void *vaddress = nullptr;
-    std::string name;
-    function_replacement_library_type_t library;
-    FunctionPatcherTargetProcess targetProcess;
-    void *replaceAddr = nullptr;
-    void *replaceCall = nullptr;
+    void *mPAddress = nullptr;
+    void *mVAddress = nullptr;
+    std::string mName;
+    function_replacement_library_type_t mLibrary;
+    FunctionPatcherTargetProcess mTargetProcess;
+    void *mReplaceAddr = nullptr;
+    void *mReplaceCall = nullptr;
 
-    PatchedFunctionHandle handle = 0;
+    PatchedFunctionHandle mHandle = 0;
 };

source/plugin/FunctionSymbolData.cpp

@@ -0,0 +1,26 @@
+#include "FunctionSymbolData.h"
+
+FunctionSymbolData::FunctionSymbolData(const FunctionSymbolData &o2) = default;
+
+FunctionSymbolData::FunctionSymbolData(std::string_view name, void *address, uint32_t size) : mName(name),
+                                                                                              mAddress(address),
+                                                                                              mSize(size) {
+}
+
+bool FunctionSymbolData::operator<(const FunctionSymbolData &rhs) const {
+    return reinterpret_cast<uint32_t>(mAddress) < reinterpret_cast<uint32_t>(rhs.mAddress);
+}
+
+FunctionSymbolData::~FunctionSymbolData() = default;
+
+[[nodiscard]] const std::string &FunctionSymbolData::getName() const {
+    return mName;
+}
+
+[[nodiscard]] void *FunctionSymbolData::getAddress() const {
+    return mAddress;
+}
+
+[[nodiscard]] uint32_t FunctionSymbolData::getSize() const {
+    return mSize;
+}

source/plugin/FunctionSymbolData.h

@@ -17,35 +17,25 @@
 
 #pragma once
 
+#include <cstdint>
 #include <string>
 
 class FunctionSymbolData {
 
 public:
-    FunctionSymbolData(const FunctionSymbolData &o2) = default;
+    FunctionSymbolData(const FunctionSymbolData &o2);
 
-    FunctionSymbolData(std::string_view name, void *address, uint32_t size) : mName(name),
-                                                                              mAddress(address),
-                                                                              mSize(size) {
-    }
+    FunctionSymbolData(std::string_view name, void *address, uint32_t size);
 
-    bool operator<(const FunctionSymbolData &rhs) const {
-        return (uint32_t) mAddress < (uint32_t) rhs.mAddress;
-    }
+    bool operator<(const FunctionSymbolData &rhs) const;
 
-    virtual ~FunctionSymbolData() = default;
+    virtual ~FunctionSymbolData();
 
-    [[nodiscard]] const std::string &getName() const {
-        return mName;
-    }
+    [[nodiscard]] const std::string &getName() const;
 
-    [[nodiscard]] void *getAddress() const {
-        return mAddress;
-    }
+    [[nodiscard]] void *getAddress() const;
 
-    [[nodiscard]] uint32_t getSize() const {
-        return mSize;
-    }
+    [[nodiscard]] uint32_t getSize() const;
 
 private:
     std::string mName;

source/plugin/HookData.cpp

@@ -0,0 +1,16 @@
+#include "HookData.h"
+
+HookData::HookData(void *functionPointer, const wups_loader_hook_type_t type) {
+    this->mFunctionPointer = functionPointer;
+    this->mType            = type;
+}
+
+HookData::~HookData() = default;
+
+[[nodiscard]] void *HookData::getFunctionPointer() const {
+    return mFunctionPointer;
+}
+
+[[nodiscard]] wups_loader_hook_type_t HookData::getType() const {
+    return mType;
+}

source/plugin/HookData.h

@@ -17,27 +17,20 @@
 
 #pragma once
 
-#include <string>
 #include <wups/hooks.h>
+
 class HookData {
 
 public:
-    HookData(void *function_pointer, wups_loader_hook_type_t type) {
-        this->function_pointer = function_pointer;
-        this->type             = type;
-    }
+    HookData(void *functionPointer, wups_loader_hook_type_t type);
 
-    ~HookData() = default;
+    ~HookData();
 
-    [[nodiscard]] void *getFunctionPointer() const {
-        return function_pointer;
-    }
+    [[nodiscard]] void *getFunctionPointer() const;
 
-    [[nodiscard]] wups_loader_hook_type_t getType() const {
-        return this->type;
-    }
+    [[nodiscard]] wups_loader_hook_type_t getType() const;
 
 private:
-    void *function_pointer;
-    wups_loader_hook_type_t type;
+    void *mFunctionPointer;
+    wups_loader_hook_type_t mType;
 };

source/plugin/ImportRPLInformation.cpp

@@ -0,0 +1,20 @@
+#include "ImportRPLInformation.h"
+#include <cstring>
+
+ImportRPLInformation::ImportRPLInformation(std::string_view name) {
+    this->mName = name;
+}
+
+ImportRPLInformation::~ImportRPLInformation() = default;
+
+[[nodiscard]] const std::string &ImportRPLInformation::getName() const {
+    return mName;
+}
+
+[[nodiscard]] std::string ImportRPLInformation::getRPLName() const {
+    return mName.substr(strlen(".dimport_"));
+}
+
+[[nodiscard]] bool ImportRPLInformation::isData() const {
+    return mName.starts_with(".dimport_");
+}

source/plugin/ImportRPLInformation.h

@@ -17,30 +17,20 @@
 
 #pragma once
 
-#include "../utils/logger.h"
 #include <string>
-#include <utility>
 
 class ImportRPLInformation {
 
 public:
-    explicit ImportRPLInformation(std::string_view name) {
-        this->mName = name;
-    }
+    explicit ImportRPLInformation(std::string_view name);
 
-    ~ImportRPLInformation() = default;
+    ~ImportRPLInformation();
 
-    [[nodiscard]] const std::string &getName() const {
-        return mName;
-    }
+    [[nodiscard]] const std::string &getName() const;
 
-    [[nodiscard]] std::string getRPLName() const {
-        return mName.substr(strlen(".dimport_"));
-    }
+    [[nodiscard]] std::string getRPLName() const;
 
-    [[nodiscard]] bool isData() const {
-        return mName.starts_with(".dimport_");
-    }
+    [[nodiscard]] bool isData() const;
 
 private:
     std::string mName;

source/plugin/PluginConfigData.cpp

@@ -1,8 +1,12 @@
 #include "PluginConfigData.h"
 
-PluginConfigData::PluginConfigData(std::string_view name, WUPSConfigAPI_MenuOpenedCallback openedCallback, WUPSConfigAPI_MenuClosedCallback closedCallback) : mName(name),
-                                                                                                                                                              mOpenedCallback(openedCallback),
-                                                                                                                                                              mClosedCallback(closedCallback) {
+#include <config/WUPSConfigAPI.h>
+
+PluginConfigData::PluginConfigData(const std::string_view name,
+                                   const WUPSConfigAPI_MenuOpenedCallback openedCallback,
+                                   const WUPSConfigAPI_MenuClosedCallback closedCallback) : mName(name),
+                                                                                            mOpenedCallback(openedCallback),
+                                                                                            mClosedCallback(closedCallback) {
 }
 
 std::optional<WUPSConfigHandle> PluginConfigData::createConfig() const {
@@ -13,7 +17,7 @@ std::optional<WUPSConfigHandle> PluginConfigData::createConfig() const {
     return std::nullopt;
 }
 
-WUPSConfigAPIStatus PluginConfigData::CallMenuOpenendCallback(WUPSConfigHandle config) const {
+WUPSConfigAPIStatus PluginConfigData::CallMenuOpenedCallback(const WUPSConfigHandle config) const {
     if (mOpenedCallback == nullptr) {
         return WUPSCONFIG_API_RESULT_MISSING_CALLBACK;
     }
@@ -31,7 +35,9 @@ WUPSConfigAPIStatus PluginConfigData::CallMenuClosedCallback() const {
     return WUPSCONFIG_API_RESULT_SUCCESS;
 }
 
-std::optional<PluginConfigData> PluginConfigData::create(WUPSConfigAPIOptions options, WUPSConfigAPI_MenuOpenedCallback openedCallback, WUPSConfigAPI_MenuClosedCallback closedCallback) {
+std::optional<PluginConfigData> PluginConfigData::create(const WUPSConfigAPIOptions options,
+                                                         const WUPSConfigAPI_MenuOpenedCallback openedCallback,
+                                                         const WUPSConfigAPI_MenuClosedCallback closedCallback) {
     if (options.version != 1) {
         return std::nullopt;
     }

source/plugin/PluginConfigData.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "config/WUPSConfigAPI.h"
 #include <optional>
 #include <string>
+#include <wups/config.h>
 #include <wups/config_api.h>
 
 class PluginConfigData {
@@ -13,7 +13,7 @@ public:
 
     [[nodiscard]] std::optional<WUPSConfigHandle> createConfig() const;
 
-    [[nodiscard]] WUPSConfigAPIStatus CallMenuOpenendCallback(WUPSConfigHandle config) const;
+    [[nodiscard]] WUPSConfigAPIStatus CallMenuOpenedCallback(WUPSConfigHandle config) const;
 
     [[nodiscard]] WUPSConfigAPIStatus CallMenuClosedCallback() const;
 

source/plugin/PluginContainer.cpp

@@ -1,22 +1,24 @@
 #include "PluginContainer.h"
 
+#include <utils/storage/StorageUtils.h>
+
 PluginContainer::PluginContainer(PluginMetaInformation metaInformation, PluginInformation pluginInformation, std::shared_ptr<PluginData> pluginData)
     : mMetaInformation(std::move(metaInformation)),
       mPluginInformation(std::move(pluginInformation)),
       mPluginData(std::move(pluginData)) {
 }
 
-PluginContainer::PluginContainer(PluginContainer &&src) : mMetaInformation(std::move(src.mMetaInformation)),
-                                                          mPluginInformation(std::move(src.mPluginInformation)),
-                                                          mPluginData(std::move(src.mPluginData)),
-                                                          mPluginConfigData(std::move(src.mPluginConfigData)),
-                                                          storageRootItem(src.storageRootItem)
+PluginContainer::PluginContainer(PluginContainer &&src) noexcept : mMetaInformation(std::move(src.mMetaInformation)),
+                                                                   mPluginInformation(std::move(src.mPluginInformation)),
+                                                                   mPluginData(std::move(src.mPluginData)),
+                                                                   mPluginConfigData(std::move(src.mPluginConfigData)),
+                                                                   storageRootItem(src.storageRootItem)
 
 {
     src.storageRootItem = {};
 }
 
-PluginContainer &PluginContainer::operator=(PluginContainer &&src) {
+PluginContainer &PluginContainer::operator=(PluginContainer &&src) noexcept {
     if (this != &src) {
         this->mMetaInformation   = src.mMetaInformation;
         this->mPluginInformation = std::move(src.mPluginInformation);

source/plugin/PluginContainer.h

@@ -21,10 +21,10 @@
 #include "PluginData.h"
 #include "PluginInformation.h"
 #include "PluginMetaInformation.h"
-#include "utils/storage/StorageUtils.h"
+
 #include <memory>
-#include <utility>
-#include <wups/config_api.h>
+#include <optional>
+#include <wups/storage.h>
 
 class PluginContainer {
 public:
@@ -34,9 +34,9 @@ public:
     PluginContainer(const PluginContainer &) = delete;
 
 
-    PluginContainer(PluginContainer &&src);
+    PluginContainer(PluginContainer &&src) noexcept;
 
-    PluginContainer &operator=(PluginContainer &&src);
+    PluginContainer &operator=(PluginContainer &&src) noexcept;
 
 
     [[nodiscard]] const PluginMetaInformation &getMetaInformation() const;

source/plugin/PluginData.cpp

@@ -1,7 +1,26 @@
 #include "PluginData.h"
 
+PluginData::PluginData(std::vector<uint8_t> &&buffer, const std::string_view source) : mBuffer(std::move(buffer)), mSource(source) {
+}
+
+PluginData::PluginData(std::span<uint8_t> buffer, const std::string_view source) : mBuffer(buffer.begin(), buffer.end()), mSource(source) {
+}
+
+
+PluginData::PluginData(PluginData &&src) : mBuffer(std::move(src.mBuffer)),
+                                           mSource(std::move(src.mSource)) {
+}
+
+PluginData &PluginData::operator=(PluginData &&src) noexcept {
+    if (this != &src) {
+        this->mBuffer = std::move(src.mBuffer);
+        this->mSource = std::move(src.mSource);
+    }
+    return *this;
+}
+
 uint32_t PluginData::getHandle() const {
-    return (uint32_t) this;
+    return reinterpret_cast<uint32_t>(this);
 }
 
 std::span<const uint8_t> PluginData::getBuffer() const {

source/plugin/PluginData.h

@@ -17,21 +17,22 @@
 
 #pragma once
 
-#include <coreinit/memexpheap.h>
-#include <malloc.h>
-#include <memory>
-#include <optional>
+#include <cstdint>
 #include <span>
-#include <utility>
+#include <string>
 #include <vector>
 
 class PluginData {
 public:
-    explicit PluginData(std::vector<uint8_t> &&buffer, std::string_view source) : mBuffer(std::move(buffer)), mSource(source) {
-    }
+    explicit PluginData(std::vector<uint8_t> &&buffer, std::string_view source);
 
-    explicit PluginData(std::span<uint8_t> buffer, std::string_view source) : mBuffer(buffer.begin(), buffer.end()), mSource(source) {
-    }
+    explicit PluginData(std::span<uint8_t> buffer, std::string_view source);
+
+    PluginData(const PluginData &) = delete;
+
+    PluginData(PluginData &&src) noexcept;
+
+    PluginData &operator=(PluginData &&src) noexcept;
 
     [[nodiscard]] uint32_t getHandle() const;
 

source/plugin/PluginDataFactory.cpp

@@ -14,19 +14,20 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  ****************************************************************************/
+
 #include "PluginDataFactory.h"
 #include "NotificationsUtils.h"
 #include "fs/FSUtils.h"
 #include "utils/StringTools.h"
 #include "utils/logger.h"
-#include "utils/utils.h"
-#include <dirent.h>
-#include <forward_list>
-#include <memory>
 
-std::set<std::shared_ptr<PluginData>> PluginDataFactory::loadDir(std::string_view path) {
+#include <memory>
+#include <set>
+#include <sys/dirent.h>
+
+std::set<std::shared_ptr<PluginData>> PluginDataFactory::loadDir(const std::string_view path) {
     std::set<std::shared_ptr<PluginData>> result;
-    struct dirent *dp;
+    dirent *dp;
     DIR *dfd;
 
     if (path.empty()) {
@@ -50,8 +51,7 @@ std::set<std::shared_ptr<PluginData>> PluginDataFactory::loadDir(std::string_vie
 
         auto full_file_path = string_format("%s/%s", path.data(), dp->d_name);
         DEBUG_FUNCTION_LINE("Loading plugin: %s", full_file_path.c_str());
-        auto pluginData = load(full_file_path);
-        if (pluginData) {
+        if (auto pluginData = load(full_file_path)) {
             result.insert(std::move(pluginData));
         } else {
             auto errMsg = string_format("Failed to load plugin: %s", full_file_path.c_str());
@@ -65,15 +65,15 @@ std::set<std::shared_ptr<PluginData>> PluginDataFactory::loadDir(std::string_vie
     return result;
 }
 
-std::unique_ptr<PluginData> PluginDataFactory::load(std::string_view filename) {
+std::unique_ptr<PluginData> PluginDataFactory::load(const std::string_view path) {
     std::vector<uint8_t> buffer;
-    if (FSUtils::LoadFileToMem(filename, buffer) < 0) {
-        DEBUG_FUNCTION_LINE_ERR("Failed to load %s into memory", filename.data());
+    if (FSUtils::LoadFileToMem(path, buffer) < 0) {
+        DEBUG_FUNCTION_LINE_ERR("Failed to load %s into memory", path.data());
         return nullptr;
     }
 
     DEBUG_FUNCTION_LINE_VERBOSE("Loaded file!");
-    return load(std::move(buffer), filename);
+    return load(std::move(buffer), path);
 }
 
 std::unique_ptr<PluginData> PluginDataFactory::load(std::vector<uint8_t> &&buffer, std::string_view source) {

source/plugin/PluginDataFactory.h

@@ -16,14 +16,10 @@
  ****************************************************************************/
 
 #pragma once
-
 #include "PluginData.h"
-#include <coreinit/memexpheap.h>
-#include <forward_list>
+
 #include <memory>
-#include <optional>
 #include <set>
-#include <string>
 #include <vector>
 
 class PluginDataFactory {

source/plugin/PluginInformation.cpp

@@ -28,7 +28,7 @@ PluginInformation &PluginInformation::operator=(PluginInformation &&src) {
     return *this;
 }
 
-void PluginInformation::addHookData(HookData hook_data) {
+void PluginInformation::addHookData(const HookData &hook_data) {
     mHookDataList.push_back(hook_data);
 }
 
@@ -75,7 +75,7 @@ std::optional<SectionInfo> PluginInformation::getSectionInfo(const std::string &
     return std::nullopt;
 }
 
-void PluginInformation::setTrampolineId(uint8_t trampolineId) {
+void PluginInformation::setTrampolineId(const uint8_t trampolineId) {
     this->mTrampolineId = trampolineId;
 }
 
@@ -83,15 +83,15 @@ uint8_t PluginInformation::getTrampolineId() const {
     return mTrampolineId;
 }
 
-const FunctionSymbolData *PluginInformation::getNearestFunctionSymbolData(uint32_t address) const {
+const FunctionSymbolData *PluginInformation::getNearestFunctionSymbolData(const uint32_t address) const {
     const FunctionSymbolData *result = nullptr;
 
     bool foundHit = false;
     for (auto &cur : mSymbolDataList) {
-        if (foundHit && address < (uint32_t) cur.getAddress()) {
+        if (foundHit && address < reinterpret_cast<uint32_t>(cur.getAddress())) {
             break;
         }
-        if (address >= (uint32_t) cur.getAddress()) {
+        if (address >= reinterpret_cast<uint32_t>(cur.getAddress())) {
             result   = &cur;
             foundHit = true;
         }

source/plugin/PluginInformation.h

@@ -20,15 +20,12 @@
 #include "FunctionData.h"
 #include "FunctionSymbolData.h"
 #include "HookData.h"
-#include "PluginMetaInformation.h"
 #include "RelocationData.h"
 #include "SectionInfo.h"
 #include "utils/HeapMemoryFixedSize.h"
-#include "utils/utils.h"
+#include <cstdint>
 #include <map>
-#include <memory>
 #include <optional>
-#include <ranges>
 #include <set>
 #include <string>
 #include <vector>
@@ -71,7 +68,7 @@ public:
 private:
     PluginInformation() = default;
 
-    void addHookData(HookData hook_data);
+    void addHookData(const HookData &hook_data);
 
     void addFunctionData(FunctionData function_data);
 

source/plugin/PluginInformationFactory.cpp

@@ -16,13 +16,12 @@
  ****************************************************************************/
 
 #include "PluginInformationFactory.h"
-#include "../utils/ElfUtils.h"
-#include "utils/HeapMemoryFixedSize.h"
+#include "utils/ElfUtils.h"
+#include "utils/logger.h"
+#include "utils/utils.h"
 #include "utils/wiiu_zlib.hpp"
+
 #include <coreinit/cache.h>
-#include <map>
-#include <memory>
-#include <string>
 #include <wups/function_patching.h>
 
 using namespace ELFIO;
@@ -50,7 +49,7 @@ PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocat
         DEBUG_FUNCTION_LINE_ERR("Failed alloc memory for destinations array");
         return std::nullopt;
     }
-    std::span<uint8_t *> destinations(destinationsData.get(), sec_num);
+    std::span destinations(destinationsData.get(), sec_num);
 
     uint32_t totalSize = 0;
 
@@ -265,7 +264,7 @@ PluginInformationFactory::load(const PluginData &pluginData, std::vector<relocat
     return pluginInfo;
 }
 
-bool PluginInformationFactory::addImportRelocationData(PluginInformation &pluginInfo, const elfio &reader, std::span<uint8_t *> destinations) {
+bool PluginInformationFactory::addImportRelocationData(PluginInformation &pluginInfo, const elfio &reader, const std::span<uint8_t *> destinations) {
     std::map<uint32_t, std::shared_ptr<ImportRPLInformation>> infoMap;
 
     uint32_t sec_num = reader.sections.size();

source/plugin/PluginInformationFactory.h

@@ -16,15 +16,11 @@
  ****************************************************************************/
 
 #pragma once
-
-#include "../elfio/elfio.hpp"
-#include "PluginContainer.h"
+#include "PluginData.h"
 #include "PluginInformation.h"
-#include <coreinit/memheap.h>
-#include <map>
+
+#include <elfio/elfio.hpp>
 #include <optional>
-#include <string>
-#include <vector>
 #include <wums/defines/relocation_defines.h>
 
 class PluginInformationFactory {

source/plugin/PluginMetaInformation.cpp

@@ -0,0 +1,79 @@
+#include "PluginMetaInformation.h"
+
+[[nodiscard]] const std::string &PluginMetaInformation::getName() const {
+    return mName;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getAuthor() const {
+    return mAuthor;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getVersion() const {
+    return mVersion;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getLicense() const {
+    return mLicense;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getBuildTimestamp() const {
+    return mBuildTimestamp;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getDescription() const {
+    return mDescription;
+}
+
+[[nodiscard]] const WUPSVersion &PluginMetaInformation::getWUPSVersion() const {
+    return this->mWUPSVersion;
+}
+
+[[nodiscard]] const std::string &PluginMetaInformation::getStorageId() const {
+    return mStorageId;
+}
+
+[[nodiscard]] size_t PluginMetaInformation::getSize() const {
+    return mSize;
+}
+
+PluginMetaInformation::PluginMetaInformation() = default;
+
+void PluginMetaInformation::setName(std::string name) {
+    mName = std::move(name);
+}
+
+void PluginMetaInformation::setAuthor(std::string author) {
+    mAuthor = std::move(author);
+}
+
+void PluginMetaInformation::setVersion(std::string version) {
+    mVersion = std::move(version);
+}
+
+void PluginMetaInformation::setLicense(std::string license) {
+    mLicense = std::move(license);
+}
+
+void PluginMetaInformation::setBuildTimestamp(std::string buildTimestamp) {
+    mBuildTimestamp = std::move(buildTimestamp);
+}
+
+void PluginMetaInformation::setDescription(std::string description) {
+    mDescription = std::move(description);
+}
+
+void PluginMetaInformation::setWUPSVersion(const uint16_t major, const uint16_t minor, const uint16_t revision) {
+    mWUPSVersion = WUPSVersion(major, minor, revision);
+}
+
+void PluginMetaInformation::setWUPSVersion(const WUPSVersion &wupsVersion) {
+    mWUPSVersion = wupsVersion;
+}
+
+void PluginMetaInformation::setSize(const size_t size) {
+    mSize = size;
+}
+
+void PluginMetaInformation::setStorageId(std::string storageId) {
+    mStorageId = std::move(storageId);
+}

source/plugin/PluginMetaInformation.h

@@ -19,98 +19,59 @@
 
 #include "WUPSVersion.h"
 #include <string>
-#include <vector>
 
 class PluginMetaInformation {
 public:
-    [[nodiscard]] const std::string &getName() const {
-        return name;
-    }
+    [[nodiscard]] const std::string &getName() const;
 
-    [[nodiscard]] const std::string &getAuthor() const {
-        return this->author;
-    }
+    [[nodiscard]] const std::string &getAuthor() const;
 
-    [[nodiscard]] const std::string &getVersion() const {
-        return this->version;
-    }
+    [[nodiscard]] const std::string &getVersion() const;
 
-    [[nodiscard]] const std::string &getLicense() const {
-        return this->license;
-    }
+    [[nodiscard]] const std::string &getLicense() const;
 
-    [[nodiscard]] const std::string &getBuildTimestamp() const {
-        return this->buildtimestamp;
-    }
+    [[nodiscard]] const std::string &getBuildTimestamp() const;
 
-    [[nodiscard]] const std::string &getDescription() const {
-        return this->description;
-    }
+    [[nodiscard]] const std::string &getDescription() const;
 
-    [[nodiscard]] const WUPSVersion &getWUPSVersion() const {
-        return this->wupsversion;
-    }
+    [[nodiscard]] const WUPSVersion &getWUPSVersion() const;
 
-    [[nodiscard]] const std::string &getStorageId() const {
-        return this->storageId;
-    }
+    [[nodiscard]] const std::string &getStorageId() const;
 
-    [[nodiscard]] size_t getSize() const {
-        return this->size;
-    }
+    [[nodiscard]] size_t getSize() const;
 
 private:
-    PluginMetaInformation() = default;
+    PluginMetaInformation();
 
-    void setName(std::string _name) {
-        this->name = std::move(_name);
-    }
+    void setName(std::string name);
 
-    void setAuthor(std::string _author) {
-        this->author = std::move(_author);
-    }
+    void setAuthor(std::string author);
 
-    void setVersion(std::string _version) {
-        this->version = std::move(_version);
-    }
+    void setVersion(std::string version);
 
-    void setLicense(std::string _license) {
-        this->license = std::move(_license);
-    }
+    void setLicense(std::string license);
 
-    void setBuildTimestamp(std::string _buildtimestamp) {
-        this->buildtimestamp = std::move(_buildtimestamp);
-    }
+    void setBuildTimestamp(std::string buildTimestamp);
 
-    void setDescription(std::string _description) {
-        this->description = std::move(_description);
-    }
+    void setDescription(std::string description);
 
-    void setWUPSVersion(uint16_t major, uint16_t minor, uint16_t revision) {
-        this->wupsversion = WUPSVersion(major, minor, revision);
-    }
+    void setWUPSVersion(uint16_t major, uint16_t minor, uint16_t revision);
 
-    void setWUPSVersion(WUPSVersion &_wupsversion) {
-        this->wupsversion = _wupsversion;
-    }
+    void setWUPSVersion(const WUPSVersion &wupsVersion);
 
-    void setSize(size_t _size) {
-        this->size = _size;
-    }
+    void setSize(size_t size);
 
-    void setStorageId(std::string _storageId) {
-        this->storageId = std::move(_storageId);
-    }
+    void setStorageId(std::string storageId);
 
-    std::string name;
-    std::string author;
-    std::string version;
-    std::string license;
-    std::string buildtimestamp;
-    std::string description;
-    std::string storageId;
-    size_t size{};
-    WUPSVersion wupsversion = WUPSVersion(0, 0, 0);
+    std::string mName;
+    std::string mAuthor;
+    std::string mVersion;
+    std::string mLicense;
+    std::string mBuildTimestamp;
+    std::string mDescription;
+    std::string mStorageId;
+    size_t mSize             = {};
+    WUPSVersion mWUPSVersion = WUPSVersion(0, 0, 0);
 
     friend class PluginMetaInformationFactory;
 

source/plugin/PluginMetaInformationFactory.cpp

@@ -16,11 +16,15 @@
  ****************************************************************************/
 
 #include "PluginMetaInformationFactory.h"
-#include "elfio/elfio.hpp"
+
+#include "PluginData.h"
+#include "PluginMetaInformation.h"
 #include "fs/FSUtils.h"
 #include "utils/logger.h"
 #include "utils/wiiu_zlib.hpp"
-#include <memory>
+
+#include <elfio/elfio.hpp>
+#include <optional>
 
 std::optional<PluginMetaInformation> PluginMetaInformationFactory::loadPlugin(const PluginData &pluginData, PluginParseErrors &error) {
     return loadPlugin(pluginData.getBuffer(), error);

source/plugin/PluginMetaInformationFactory.h

@@ -19,11 +19,10 @@
 
 #include "PluginData.h"
 #include "PluginMetaInformation.h"
-#include "elfio/elfio.hpp"
-#include <memory>
+
 #include <optional>
-#include <string>
-#include <vector>
+#include <span>
+#include <string_view>
 
 enum PluginParseErrors {
     PLUGIN_PARSE_ERROR_NONE,

source/plugin/RelocationData.cpp

@@ -0,0 +1,42 @@
+#include "RelocationData.h"
+
+RelocationData::RelocationData(const char type,
+                               const size_t offset,
+                               const int32_t addend,
+                               void *destination,
+                               std::string name,
+                               std::shared_ptr<ImportRPLInformation> rplInfo) : mType(type),
+                                                                                mOffset(offset),
+                                                                                mAddend(addend),
+                                                                                mDestination(destination),
+                                                                                mName(std::move(name)),
+                                                                                mRPLInfo(std::move(rplInfo)) {
+}
+
+RelocationData::RelocationData(const RelocationData &o2) = default;
+
+RelocationData::~RelocationData() = default;
+
+[[nodiscard]] char RelocationData::getType() const {
+    return mType;
+}
+
+[[nodiscard]] size_t RelocationData::getOffset() const {
+    return mOffset;
+}
+
+[[nodiscard]] int32_t RelocationData::getAddend() const {
+    return mAddend;
+}
+
+[[nodiscard]] const void *RelocationData::getDestination() const {
+    return mDestination;
+}
+
+[[nodiscard]] const std::string &RelocationData::getName() const {
+    return mName;
+}
+
+[[nodiscard]] const ImportRPLInformation &RelocationData::getImportRPLInformation() const {
+    return *mRPLInfo;
+}

source/plugin/RelocationData.h

@@ -18,54 +18,36 @@
 #pragma once
 
 #include "ImportRPLInformation.h"
+#include <cstdint>
 #include <memory>
 #include <string>
-#include <utility>
 
 class RelocationData {
 
 public:
-    RelocationData(const char type, size_t offset, int32_t addend, void *destination, std::string name, std::shared_ptr<ImportRPLInformation> rplInfo) : type(type),
-                                                                                                                                                         offset(offset),
-                                                                                                                                                         addend(addend),
-                                                                                                                                                         destination(destination),
-                                                                                                                                                         name(std::move(name)),
-                                                                                                                                                         rplInfo(std::move(rplInfo)) {
-    }
+    RelocationData(char type, size_t offset, int32_t addend, void *destination, std::string name, std::shared_ptr<ImportRPLInformation> rplInfo);
 
-    RelocationData(const RelocationData &o2) = default;
+    RelocationData(const RelocationData &o2);
 
-    virtual ~RelocationData() = default;
+    virtual ~RelocationData();
 
-    [[nodiscard]] char getType() const {
-        return type;
-    }
+    [[nodiscard]] char getType() const;
 
-    [[nodiscard]] size_t getOffset() const {
-        return offset;
-    }
+    [[nodiscard]] size_t getOffset() const;
 
-    [[nodiscard]] int32_t getAddend() const {
-        return addend;
-    }
+    [[nodiscard]] int32_t getAddend() const;
 
-    [[nodiscard]] const void *getDestination() const {
-        return destination;
-    }
+    [[nodiscard]] const void *getDestination() const;
 
-    [[nodiscard]] const std::string &getName() const {
-        return name;
-    }
+    [[nodiscard]] const std::string &getName() const;
 
-    [[nodiscard]] const ImportRPLInformation &getImportRPLInformation() const {
-        return *rplInfo;
-    }
+    [[nodiscard]] const ImportRPLInformation &getImportRPLInformation() const;
 
 private:
-    char type;
-    size_t offset;
-    int32_t addend;
-    void *destination;
-    std::string name;
-    std::shared_ptr<ImportRPLInformation> rplInfo;
+    char mType;
+    size_t mOffset;
+    int32_t mAddend;
+    void *mDestination;
+    std::string mName;
+    std::shared_ptr<ImportRPLInformation> mRPLInfo;
 };

source/plugin/SectionInfo.cpp

@@ -0,0 +1,24 @@
+#include "SectionInfo.h"
+
+SectionInfo::SectionInfo(std::string name,
+                         const uint32_t address,
+                         const uint32_t sectionSize) : mName(std::move(name)),
+                                                       mAddress(address),
+                                                       mSectionSize(sectionSize) {
+}
+
+[[nodiscard]] const std::string &SectionInfo::getName() const {
+    return mName;
+}
+
+[[nodiscard]] uint32_t SectionInfo::getAddress() const {
+    return mAddress;
+}
+
+[[nodiscard]] uint32_t SectionInfo::getSize() const {
+    return mSectionSize;
+}
+
+[[nodiscard]] uint32_t SectionInfo::isInSection(uint32_t addr) const {
+    return addr >= mAddress && addr < mAddress + mSectionSize;
+}

source/plugin/SectionInfo.h

@@ -17,34 +17,24 @@
 
 #pragma once
 
+#include <cstdint>
 #include <string>
 
 class SectionInfo {
 
 public:
-    SectionInfo(std::string name, uint32_t address, uint32_t sectionSize) : name(std::move(name)),
-                                                                            address(address),
-                                                                            sectionSize(sectionSize) {
-    }
+    SectionInfo(std::string name, uint32_t address, uint32_t sectionSize);
 
-    [[nodiscard]] const std::string &getName() const {
-        return name;
-    }
+    [[nodiscard]] const std::string &getName() const;
 
-    [[nodiscard]] uint32_t getAddress() const {
-        return address;
-    }
+    [[nodiscard]] uint32_t getAddress() const;
 
-    [[nodiscard]] uint32_t getSize() const {
-        return sectionSize;
-    }
+    [[nodiscard]] uint32_t getSize() const;
 
-    [[nodiscard]] uint32_t isInSection(uint32_t addr) const {
-        return addr >= address && addr < address + sectionSize;
-    }
+    [[nodiscard]] uint32_t isInSection(uint32_t addr) const;
 
 private:
-    std::string name;
-    uint32_t address{};
-    uint32_t sectionSize{};
+    std::string mName;
+    uint32_t mAddress     = {};
+    uint32_t mSectionSize = {};
 };

source/plugin/WUPSVersion.cpp

@@ -0,0 +1,41 @@
+#include "WUPSVersion.h"
+#include "utils/StringTools.h"
+
+WUPSVersion::WUPSVersion(const int major, const int minor, const int revision)
+    : mMajor(major), mMinor(minor), mRevision(revision) {
+}
+
+std::optional<WUPSVersion> WUPSVersion::createFromString(const std::string &versionStr) {
+    char *end;
+    errno = 0; // Initialize errno before calling strtol
+
+    const auto major = strtol(versionStr.c_str(), &end, 10);
+    if (errno || *end != '.') {
+        return std::nullopt;
+    }
+
+
+    const auto minor = strtol(end + 1, &end, 10);
+    if (errno || *end != '.') {
+        return std::nullopt;
+    }
+
+    const auto revision = strtol(end + 1, &end, 10);
+    if (errno || *end != '\0') {
+        return std::nullopt;
+    }
+
+    return WUPSVersion(static_cast<int>(major), static_cast<int>(minor), static_cast<int>(revision));
+}
+
+std::strong_ordering WUPSVersion::operator<=>(const WUPSVersion &other) const {
+    if (const auto cmp = mMajor <=> other.mMajor; cmp != std::strong_ordering::equal) return cmp;
+    if (const auto cmp = mMinor <=> other.mMinor; cmp != std::strong_ordering::equal) return cmp;
+    return mRevision <=> other.mRevision;
+}
+
+[[nodiscard]] std::string WUPSVersion::toString() const {
+    return string_format("%d.%d.%d", mMajor,
+                         mMinor,
+                         mRevision);
+}

source/plugin/WUPSVersion.h

@@ -1,47 +1,19 @@
-#include "utils/StringTools.h"
 #include <cstdint>
 #include <optional>
+#include <string>
 
 class WUPSVersion {
 public:
-    WUPSVersion(int major, int minor, int revision)
-        : mVersion((static_cast<uint64_t>(major) << 32) |
-                   (static_cast<uint64_t>(minor) << 16) |
-                   static_cast<uint64_t>(revision)) {}
+    WUPSVersion(int major, int minor, int revision);
 
-    static std::optional<WUPSVersion> createFromString(const std::string &versionStr) {
-        char *end;
-        errno = 0; // Initialize errno before calling strtol
+    static std::optional<WUPSVersion> createFromString(const std::string &versionStr);
 
-        auto major = strtol(versionStr.c_str(), &end, 10);
-        if (errno || *end != '.') {
-            return std::nullopt;
-        }
+    std::strong_ordering operator<=>(const WUPSVersion &other) const;
 
-
-        auto minor = strtol(end + 1, &end, 10);
-        if (errno || *end != '.') {
-            return std::nullopt;
-        }
-
-        auto revision = strtol(end + 1, &end, 10);
-        if (errno || *end != '\0') {
-            return std::nullopt;
-        }
-
-        return WUPSVersion(static_cast<int>(major), static_cast<int>(minor), static_cast<int>(revision));
-    }
-
-    std::strong_ordering operator<=>(const WUPSVersion &other) const {
-        return mVersion <=> other.mVersion;
-    }
-
-    [[nodiscard]] std::string toString() const {
-        return string_format("%d.%d.%d", static_cast<int>((mVersion >> 32) & 0xFFFF),
-                             static_cast<int>((mVersion >> 16) & 0xFFFF),
-                             static_cast<int>((mVersion) &0xFFFF));
-    }
+    [[nodiscard]] std::string toString() const;
 
 private:
-    uint64_t mVersion{};
+    uint32_t mMajor;
+    uint32_t mMinor;
+    uint32_t mRevision;
 };