ModuleResourceManager.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/Buffer.h>
#include <NDEVR/String.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/StringView.h>
#undef linux
namespace NDEVR
{
    struct NDEVR_BASE_API OSType
    {
        
 
        static constexpr StringView windows = "windows"; 
        static constexpr StringView android = "android"; 
        static constexpr StringView macx = "macx"; 
        static constexpr StringView ios = "ios"; 
        static constexpr StringView wasm = "wasm"; 
        static constexpr StringView all = "windows|android|macx|ios|wasm"; 
    };

    struct NDEVR_BASE_API ConfigType
    {
        static constexpr StringView debug = "debug"; 
        static constexpr StringView release = "release"; 
        static constexpr StringView all = "debug|release"; 
    };

    struct NDEVR_BASE_API PlatformType
    {
        static constexpr StringView x86 = "x86"; 
        static constexpr StringView x64 = "x64"; 
        static constexpr StringView armeabi = "armeabi"; 
        static constexpr StringView arm64 = "arm64"; 
        static constexpr StringView all = "x86|x64|armeabi|arm64"; 
    };

    enum DependencyType
    {
          e_file 
        , e_library 
        , e_executable 
        , e_module 
        , e_type 
        , e_firewall_exception 
        , e_bundled_folder 
        , e_rcc_resource 
        , e_source_folder 
        , e_install_executable 
    };

    struct NDEVR_BASE_API ModuleConfiguration
    {
        ModuleConfiguration()
            : os_type(OSType::all)
            , config_type(ConfigType::all)
            , platform_type(PlatformType::all)
        {}

        ModuleConfiguration(const StringView& os_type, const StringView& config_type, const StringView& platform_type)
            : os_type(os_type)
            , config_type(config_type)
            , platform_type(platform_type)
        {}

        bool neededForOS(const StringView& os) const
        {
            return os_type.hasSubString(os);
        }

        bool neededForConfig(const StringView& os) const
        {
            return config_type.hasSubString(os);
        }

        bool neededForPlatform(const StringView& os) const
        {
            return platform_type.hasSubString(os);
        }

        static String Combine(std::initializer_list<StringView> l);
        static String& Remove(String& s, std::initializer_list<StringView> l);
        String os_type; 
        String config_type; 
        String platform_type; 
    };
    
    struct ModuleFeatureBase
    {
        String id; 
        TranslatedString name; 
        TranslatedString description; 
    };

    struct FireWallException : public ModuleFeatureBase
    {
        Buffer<String> remote_addresses; 
        StringAllocatingView protocol = StringAllocatingView("tcp"); 
        StringAllocatingView profile = StringAllocatingView("domain"); 
        StringAllocatingView scope = StringAllocatingView("any"); 
        uint04 port = Constant<uint04>::Invalid; 
        bool ignore_failure = true; 
    };

    struct FileHandlerVerb
    {
        String id; 
        StringAllocatingView command = StringAllocatingView("Open"); 
        StringAllocatingView argument = StringAllocatingView("--open &quot;%1&quot;"); 
    };

    struct FileHanderExtension
    {
        String id; 
        String content_type; 
        Buffer<FileHandlerVerb> verbs; 
    };

    struct FileHandler : public ModuleFeatureBase
    {
        String icon; 
        bool advertise; 
        Buffer<FileHanderExtension> extensions; 
    };

    enum class RegistryActionType
    {
          e_append 
        , e_create 
        , e_remove 
    };

    enum class RegistryType
    {
          e_string 
        , e_integer 
        , e_binary 
        , e_expandable 
        , e_multi_string 
        , e_folder 
    };

    struct Permission
    {
        String domain; 
        String user; 
        bool append = false; 
        bool change_permission = false; 
        bool create_child = false; 
        bool create_file = false; 
        bool create_link = false; 
        bool create_subkey = false; 
        bool delete_object = false; 
        bool delete_child = false; 
        bool enumerate_subkey = false; 
        bool execute = false; 
        bool read = true; 
        bool notify = false; 
        bool take_ownership = false; 
        bool write = false; 
        bool all_rights = false; 
    };

    struct RegistryKeyAction : public ModuleFeatureBase
    {
        StringAllocatingView root = StringAllocatingView("HKLM"); 
        StringAllocatingView path; 
        StringAllocatingView value; 
        RegistryType type = RegistryType::e_string; 
        RegistryActionType action = RegistryActionType::e_create; 
        Buffer<Permission> permissions; 
        bool ownership = true; 
        bool is_key_path = false; 
    };

    struct NDEVR_BASE_API ModuleDependency : public ModuleConfiguration
    {
        ModuleDependency(DependencyType type, const StringView& resource, const StringView& os_type, const StringView& config_type, const StringView& platform_type = PlatformType::all)
            : ModuleConfiguration(os_type, config_type, platform_type)
            , resource(resource)
            , type(type)
        {}

        ModuleDependency(const StringView& resource, const StringView& os_type, const StringView& config_type, const StringView& platform_type = PlatformType::all)
            : ModuleConfiguration(os_type, config_type, platform_type)
            , resource(resource)
            , type(DependencyType::e_library)
        {}

        ModuleDependency(const FireWallException& exception, const StringView& os_type, const StringView& config_type, const StringView& platform_type = PlatformType::all);

        FireWallException getAsFirewallException() const;
        String resource; 
        String os_type; 
        DependencyType type = DependencyType::e_library; 
    };

    class NDEVR_BASE_API ModuleResourceManager
    {
    public:
        void addDependency(DependencyType type, const StringView& resource, const StringView& os_type = OSType::all, const StringView& config_type = ConfigType::all, const StringView& platform_type = PlatformType::all);
        void addModuleDependency(const StringView& resource, const StringView& os_type = OSType::all, const StringView& config_type = ConfigType::all, const StringView& platform_type = PlatformType::all);
        void addFileDependency(const StringView& resource, const StringView& os_type = OSType::all, const StringView& config_type = ConfigType::all, const StringView& platform_type = PlatformType::all);
        void addInstallExeDependency(const StringView& resource, const StringView& os_type = OSType::all, const StringView& config_type = ConfigType::all, const StringView& platform_type = PlatformType::all);
        Buffer<ModuleDependency> dependencies; 
        Buffer<FireWallException> firewall_exceptions; 
        Buffer<String> permissions; 
        Buffer<FileHandler> file_handlers; 
        Buffer<RegistryKeyAction> registry_actions; 
        ModuleConfiguration supported_configurations; 
        String launch_function; 
    };
}