ModuleResourceManager.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/Buffer.h>
#include <NDEVR/String.h>
#include <NDEVR/TranslatedString.h>
#undef linux
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Stores String variables reprenting the type of OS that will be supported by a particular 
        module or resource
    **/
    struct NDEVR_BASE_API OSType
    {
        static String windows;
        static String android;
        static String macx;
        static String ios;
        static String wasm;
        static String all;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores String variables reprenting the type of compile configuration that will be supported 
        by a particular Module or resource (debug vs release)
    **/
    struct NDEVR_BASE_API ConfigType
    {
        static String debug;
        static String release;
        static String all;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores String variables reprenting the type of platform CPU configuration that will be supported
        by a particular Module or resource (x64, x86, arm etc)
    **/
    struct NDEVR_BASE_API PlatformType
    {
        static String x86;
        static String x64;
        static String armeabi;
        static String arm64;
        static String all;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores the type of dependency for a Module or resource.
    **/
    enum DependecyType
    {
          e_file
        , e_library
        , e_executable
        , e_module
        , e_type
        , e_firewall_exception
        , e_bundled_folder
        , e_rcc_resource
        , e_source_folder
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores all information relating to a particular feature or resource included by a Module.
    **/
    struct NDEVR_BASE_API ModuleConfiguration
    {
        ModuleConfiguration()
            : os_type(OSType::all)
            , config_type(ConfigType::all)
            , platform_type(PlatformType::all)
        {}
        ModuleConfiguration(const String& os_type, const String& config_type, const String& platform_type)
            : os_type(os_type)
            , config_type(config_type)
            , platform_type(platform_type)
        {}
 
        bool neededForOS(const String& os) const
        {
            return os_type.hasSubString(os);
        }
        bool neededForConfig(const String& os) const
        {
            return config_type.hasSubString(os);
        }
        bool neededForPlatform(const String& os) const
        {
            return platform_type.hasSubString(os);
        }
        static String Combine(std::initializer_list<String> l);
        static String& Remove(String& s, std::initializer_list<String> l);
        String os_type;
        String config_type;
        String platform_type;
    };
    
    /**--------------------------------------------------------------------------------------------------
    \brief describes the Module or feature to the end user.
    **/
    struct ModuleFeatureBase
    {
        String id;
        TranslatedString name;
        TranslatedString description;//Description for this firewall rule displayed in Windows Firewall manager in Windows Vista and later.
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information relating to a particular FireWallException needed by a Module or feature
    **/
    struct FireWallException : public ModuleFeatureBase
    {
        Buffer<String> remote_addresses;
        String protocol = "tcp";//tcp or udp
        String profile = "domain";//domain,private,public, or all
        String scope = "any";//any or localSubnet
        uint04 port = Constant<uint04>::Invalid;//Port to allow through the firewall for this exception.
        bool ignore_failure = true;//If true failures to register this firewall exception will be silently ignored. If false, failures will cause rollback.
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores variables needed to perform a file action for a particular Module or resource 
    **/
    struct FileHandlerVerb
    {
        String id;//ndv_open
        String command = "Open";
        String argument = "--open &quot;%1&quot;";
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A description of the type of file a Module or resource can handle
    **/
    struct FileHanderExtension
    {
        String id;//"ndv"
        String content_type;//"application/ndv"
        Buffer<FileHandlerVerb> verbs;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Stores information relating to a type of file the module can preview or handle
    **/
    struct FileHandler : public ModuleFeatureBase
    {
        String icon;
        bool advertise;
        Buffer<FileHanderExtension> extensions;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Available registry actions that can be taken on program installation.
    **/
    enum class RegistryActionType
    {
          e_append //Appends the specified value(s) to a multiString registry key.
        , e_create //Creates the key, if absent, when the parent component is installed.
        , e_remove//Removes a registry name when the parent component is installed.
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Available registry actions that can be taken on program installation.
    **/
    enum class RegistryType
    {
          e_string //The value is interpreted and stored as a string(REG_SZ).
        , e_integer //The value is interpreted and stored as an integer(REG_DWORD).
        , e_binary //The value is interpreted and stored as a hexadecimal value(REG_BINARY).
        , e_expandable //The value is interpreted and stored as an expandable string(REG_EXPAND_SZ).
        , e_multi_string
        , e_folder
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Information about a requested OS-permission typically requested at install time.
    **/
    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;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Information about a specific registry action to be taken, typically at install-time
    **/
    struct RegistryKeyAction : public ModuleFeatureBase
    {
        String root = "HKLM";//HKMU, HKCR, HKCU, HKLM, HKU
        String path;
        String value;
        RegistryType type = RegistryType::e_string;
        RegistryActionType action = RegistryActionType::e_create;
        Buffer<Permission> permissions;
        bool ownership = true;
        bool is_key_path = false;
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief A dependency of a Module. Either a resource, or install action, defined by the module and
        automatically handled by the NDEVR build environment
    **/
    struct NDEVR_BASE_API ModuleDependency : public ModuleConfiguration
    {
        ModuleDependency(DependecyType type, const String& resource, const String& os_type, const String& config_type, const String& platform_type = PlatformType::all)
            : ModuleConfiguration(os_type, config_type, platform_type)
            , resource(resource)
            , type(type)
        {}
        ModuleDependency(const String& resource, const String& os_type, const String& config_type, const String& platform_type = PlatformType::all)
            : ModuleConfiguration(os_type, config_type, platform_type)
            , resource(resource)
            , type(DependecyType::e_library)
        {}
        ModuleDependency(const FireWallException& exception, const String& os_type, const String& config_type, const String& platform_type = PlatformType::all);
        
        FireWallException getAsFirewallException() const;
        String resource;
        String os_type;
        DependecyType type = DependecyType::e_library;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores all dependencies for a combination of modules that make up a complete software package
    **/
    class ModuleResourceManager
    {
    public:
        Buffer<ModuleDependency> dependencies;//module takes full ownership of dependency
        Buffer<FireWallException> firewall_exceptions;
        Buffer<String> permissions;
        Buffer<FileHandler> file_handlers;
        Buffer<RegistryKeyAction> registry_actions;
        ModuleConfiguration supported_configurations;//blank for supported in all configurations
        String launch_function;
    };
}