WiiUPluginLoaderBackend/source/PluginManagement.h

#pragma once

#include "plugin/PluginContainer.h"
#include <coreinit/dynload.h>
#include <map>
#include <memory>
#include <set>
#include <wums/defines/relocation_defines.h>

class PluginManagement {
public:
    static std::vector<std::unique_ptr<PluginContainer>> loadPlugins(
            const std::set<std::shared_ptr<PluginData>> &pluginDataList,
            std::vector<relocation_trampoline_entry_t> &trampolineData);

    static void callInitHooks(const std::vector<std::unique_ptr<PluginContainer>> &plugins);

    static bool doRelocations(const std::vector<std::unique_ptr<PluginContainer>> &plugins,
                              std::vector<relocation_trampoline_entry_t> &trampData,
                              std::map<std::string, OSDynLoad_Module> &usedRPls);

    static bool doRelocation(const std::vector<std::unique_ptr<RelocationData>> &relocData,
                             std::vector<relocation_trampoline_entry_t> &trampData,
                             uint32_t trampolineID,
                             std::map<std::string, OSDynLoad_Module> &usedRPls);

    static bool DoFunctionPatches(const std::vector<std::unique_ptr<PluginContainer>> &plugins);

    static bool RestoreFunctionPatches(const std::vector<std::unique_ptr<PluginContainer>> &plugins);
};
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00			`#pragma once`

Format the code via clang-format 2022-02-04 16:25:44 +01:00			`#include "plugin/PluginContainer.h"`
Keep track of acquired RPLs and release them on exit 2022-10-05 20:08:49 +02:00			`#include <coreinit/dynload.h>`
			`#include <map>`
Format the code via clang-format 2022-02-04 16:25:44 +01:00			`#include <memory>`
- 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 2023-11-04 15:32:45 +01:00			`#include <set>`
Rewrite the plugin backend, use smart pointers is possible, don't persist in structs and simplify code 2022-05-14 14:00:20 +02:00			`#include <wums/defines/relocation_defines.h>`
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00
			`class PluginManagement {`
			`public:`
- 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 2023-11-04 15:32:45 +01:00			`static std::vector<std::unique_ptr<PluginContainer>> loadPlugins(`
			`const std::set<std::shared_ptr<PluginData>> &pluginDataList,`
			`std::vector<relocation_trampoline_entry_t> &trampolineData);`
Even more formatting 2020-05-03 12:30:15 +02:00
Rewrite the plugin backend, use smart pointers is possible, don't persist in structs and simplify code 2022-05-14 14:00:20 +02:00			`static void callInitHooks(const std::vector<std::unique_ptr<PluginContainer>> &plugins);`
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00
Keep track of acquired RPLs and release them on exit 2022-10-05 20:08:49 +02:00			`static bool doRelocations(const std::vector<std::unique_ptr<PluginContainer>> &plugins,`
- 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 2023-11-04 15:32:45 +01:00			`std::vector<relocation_trampoline_entry_t> &trampData,`
Keep track of acquired RPLs and release them on exit 2022-10-05 20:08:49 +02:00			`std::map<std::string, OSDynLoad_Module> &usedRPls);`
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00
Keep track of acquired RPLs and release them on exit 2022-10-05 20:08:49 +02:00			`static bool doRelocation(const std::vector<std::unique_ptr<RelocationData>> &relocData,`
- 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 2023-11-04 15:32:45 +01:00			`std::vector<relocation_trampoline_entry_t> &trampData,`
Keep track of acquired RPLs and release them on exit 2022-10-05 20:08:49 +02:00			`uint32_t trampolineID,`
			`std::map<std::string, OSDynLoad_Module> &usedRPls);`
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00
Rewrite the plugin backend, use smart pointers is possible, don't persist in structs and simplify code 2022-05-14 14:00:20 +02:00			`static bool DoFunctionPatches(const std::vector<std::unique_ptr<PluginContainer>> &plugins);`
Add a function to unload all plugins from memory in the PluginManagement 2020-05-03 14:16:11 +02:00
Rewrite the plugin backend, use smart pointers is possible, don't persist in structs and simplify code 2022-05-14 14:00:20 +02:00			`static bool RestoreFunctionPatches(const std::vector<std::unique_ptr<PluginContainer>> &plugins);`
Increase the maximum number of relocations from 500 to 1000. Refactor some code to a "PluginManagement" class. 2020-05-03 10:21:05 +02:00			`};`