Plugin.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Containers/SmallVector.h"
#include "../Containers/VectorMap.h"
#include "../Strings/SmallString.h"
#include "../Time/Time.h"
#include "Internal/DynamicLibrary.h"
 
namespace SC
{
struct PluginDefinition;
struct PluginScanner;
struct PluginFile;
struct PluginIdentity;
struct PluginDynamicLibrary;
struct PluginCompiler;
struct PluginCompilerEnvironment;
struct PluginSysroot;
struct PluginRegistry;
using PluginIdentifier = SmallString<30>;
} // namespace SC
 
 
 
struct SC::PluginFile
{
    SmallString<255> absolutePath; 
};
 
struct SC::PluginIdentity
{
    PluginIdentifier identifier; 
    SmallString<30>  name;       
    SmallString<10>  version;    
 
    bool operator==(const PluginIdentity& other) const { return identifier == other.identifier; }
};
 
struct SC::PluginDefinition
{
    PluginIdentity   identity;    
    SmallString<255> description; 
    SmallString<10>  category;    
    SmallString<255> directory;   
 
    SmallVector<PluginIdentifier, 8> dependencies; 
    SmallVector<SmallString<10>, 8>  build;        
    SmallVector<PluginFile, 10>      files;        
 
    PluginFile& getMainPluginFile() { return files[pluginFileIndex]; }
 
    const PluginFile& getMainPluginFile() const { return files[pluginFileIndex]; }
 
    [[nodiscard]] static bool find(const StringView text, StringView& extracted);
 
    [[nodiscard]] static bool parse(StringView text, PluginDefinition& pluginDefinition);
 
    [[nodiscard]] Result getDynamicLibraryAbsolutePath(String& fullDynamicPath) const;
 
    [[nodiscard]] Result getDynamicLibraryPDBAbsolutePath(String& fullDynamicPath) const;
 
  private:
    [[nodiscard]] static bool parseLine(StringIteratorASCII& iterator, StringView& key, StringView& value);
 
    size_t pluginFileIndex = 0;
    friend struct PluginScanner;
};
 
struct SC::PluginScanner
{
    [[nodiscard]] static Result scanDirectory(const StringView directory, Vector<PluginDefinition>& definitions);
};
 
struct SC::PluginCompiler
{
    Result compile(const PluginDefinition& definition, const PluginSysroot& sysroot,
                   const PluginCompilerEnvironment& environment, String& compilerLog) const;
 
    Result link(const PluginDefinition& definition, const PluginSysroot& sysroot,
                const PluginCompilerEnvironment& environment, StringView executablePath, String& linkerLog) const;
 
    enum class Type
    {
        ClangCompiler,
        GnuCompiler,
        MicrosoftCompiler
    };
    Type              type         = Type::ClangCompiler;    
    StringNative<256> compilerPath = StringEncoding::Native; 
    StringNative<256> linkerPath   = StringEncoding::Native; 
 
    SmallVector<StringNative<256>, 8> includePaths; 
 
    SmallVector<StringNative<256>, 8> compilerIncludePaths; 
    SmallVector<StringNative<256>, 8> compilerLibraryPaths; 
 
    [[nodiscard]] static Result findBestCompiler(PluginCompiler& compiler);
 
  private:
    [[nodiscard]] Result compileFile(const PluginDefinition& definition, const PluginSysroot& sysroot,
                                     const PluginCompilerEnvironment& compilerEnvironment, StringView sourceFile,
                                     StringView objectFile, String& compilerLog) const;
    struct Internal;
};
 
struct SC::PluginSysroot
{
    SmallVector<StringNative<256>, 8> includePaths; 
    SmallVector<StringNative<256>, 8> libraryPaths; 
 
    StringNative<256> isysroot; 
 
    [[nodiscard]] static Result findBestSysroot(PluginCompiler::Type compiler, PluginSysroot& sysroot);
};
 
struct SC::PluginCompilerEnvironment
{
    StringView cFlags;
    StringView ldFlags;
 
  private:
    struct Internal;
    friend struct PluginCompiler;
};
struct SC::PluginDynamicLibrary
{
    PluginDefinition     definition;     
    SystemDynamicLibrary dynamicLibrary; 
    Time::Absolute       lastLoadTime;   
    uint32_t             numReloads;     
    String               lastErrorLog;   
 
    template <typename T>
    [[nodiscard]] bool queryInterface(T*& outInterface) const
    {
        if (pluginQueryInterface and instance != nullptr)
        {
            return pluginQueryInterface(instance, T::InterfaceHash, reinterpret_cast<void**>(&outInterface));
        }
        return false;
    }
 
    PluginDynamicLibrary() : lastLoadTime(Time::Absolute::now()) { numReloads = 0; }
 
  private:
    void* instance                      = nullptr;
    bool (*pluginInit)(void*& instance) = nullptr;
    bool (*pluginClose)(void* instance) = nullptr;
 
    bool (*pluginQueryInterface)(void* instance, uint32_t hash, void** instanceInterface) = nullptr;
 
    friend struct PluginRegistry;
    [[nodiscard]] Result load(const PluginCompiler& compiler, const PluginSysroot& sysroot, StringView executablePath);
    [[nodiscard]] Result unload();
};
 
struct SC::PluginRegistry
{
    Result replaceDefinitions(Vector<PluginDefinition>&& definitions);
 
    enum class LoadMode
    {
        Load   = 0,
        Reload = 1,
    };
 
    [[nodiscard]] Result loadPlugin(const StringView identifier, const PluginCompiler& compiler,
                                    const PluginSysroot& sysroot, StringView executablePath,
                                    LoadMode loadMode = LoadMode::Load);
 
    [[nodiscard]] Result unloadPlugin(const StringView identifier);
 
    [[nodiscard]] Result removeAllBuildProducts(const StringView identifier);
 
    [[nodiscard]] const PluginDynamicLibrary* findPlugin(const StringView identifier);
 
    [[nodiscard]] size_t getNumberOfEntries() const { return libraries.size(); }
 
    [[nodiscard]] const PluginIdentifier& getIdentifierAt(size_t index) const { return libraries.items[index].key; }
 
    [[nodiscard]] const PluginDynamicLibrary& getPluginDynamicLibraryAt(size_t index)
    {
        return libraries.items[index].value;
    }
 
  private:
    VectorMap<PluginIdentifier, PluginDynamicLibrary> libraries;
};