Plugin.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Function.h"
#include "../Foundation/Platform.h"
#include "../Foundation/PrimitiveTypes.h"
#include "../Foundation/StringPath.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;
template <int N>
using FixedString       = detail::StringNativeFixed<N>;
using PluginIdentifier  = FixedString<64>;
using PluginBuildOption = FixedString<32>;
 
template <typename T, size_t N>
struct FixedVector
{
    constexpr size_t size() const { return numValues; }
    constexpr void   clear() { numValues = 0; }
 
    operator Span<const T>() const { return {values, numValues}; }
 
    template <typename U>
    [[nodiscard]] constexpr bool contains(const U& value, size_t* outIndex = nullptr) const
    {
        for (size_t idx = 0; idx < numValues; ++idx)
        {
            if (values[idx] == value)
            {
                if (outIndex)
                    *outIndex = idx;
                return true;
            }
        }
        return false;
    }
 
    [[nodiscard]] constexpr bool isEmpty() const { return numValues == 0; }
 
    [[nodiscard]] constexpr bool push_back(const T& value)
    {
        if (numValues < N)
        {
            values[numValues++] = value;
            return true;
        }
        return false;
    }
 
    constexpr T*       begin() { return values; }
    constexpr T*       end() { return values + numValues; }
    constexpr T&       operator[](size_t idx) { return values[idx]; }
    constexpr const T* begin() const { return values; }
    constexpr const T* end() const { return values + numValues; }
    constexpr const T& operator[](size_t idx) const { return values[idx]; }
 
  private:
    T      values[N];
    size_t numValues = 0;
};
 
 
 
struct PluginFile
{
    StringPath absolutePath; 
};
 
struct PluginIdentity
{
    PluginIdentifier identifier; 
    FixedString<64>  name;       
    FixedString<16>  version;    
 
    bool operator==(const PluginIdentity& other) const { return identifier.view() == other.identifier.view(); }
};
 
struct PluginDefinition
{
    PluginIdentity identity; 
 
    FixedString<256> description; 
    FixedString<64>  category;    
    StringPath       directory;   
 
    FixedVector<PluginIdentifier, 8>  dependencies; 
    FixedVector<PluginBuildOption, 8> build;        
    FixedVector<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);
 
    Result getDynamicLibraryAbsolutePath(StringPath& fullDynamicPath) const;
 
    Result getDynamicLibraryPDBAbsolutePath(StringPath& fullDynamicPath) const;
 
  private:
    [[nodiscard]] static bool parseLine(StringIteratorASCII& iterator, StringView& key, StringView& value);
 
    size_t pluginFileIndex = 0;
    friend struct PluginScanner;
};
 
struct PluginScanner
{
    template <typename T>
    static Result scanDirectory(const StringView directory, Span<PluginDefinition> definitionsStorage,
                                T& tempFileBuffer, Span<PluginDefinition>& foundDefinitions)
    {
        return scanDirectory(directory, definitionsStorage, GrowableBuffer<T>{tempFileBuffer}, foundDefinitions);
    }
 
  private:
    static Result scanDirectory(const StringView directory, Span<PluginDefinition> definitionsStorage,
                                IGrowableBuffer&& tempFileBuffer, Span<PluginDefinition>& foundDefinitions);
    struct ScannerState;
};
 
struct PluginCompiler
{
    Result compile(const PluginDefinition& definition, const PluginSysroot& sysroot,
                   const PluginCompilerEnvironment& environment, Span<char>& compilerLog) const;
 
    Result link(const PluginDefinition& definition, const PluginSysroot& sysroot,
                const PluginCompilerEnvironment& environment, StringView executablePath, Span<char>& linkerLog) const;
 
    enum class Type
    {
        ClangCompiler,
        GnuCompiler,
        MicrosoftCompiler
    };
    Type       type = Type::ClangCompiler; 
    StringPath compilerPath;               
    StringPath linkerPath;                 
 
    FixedVector<StringPath, 8> includePaths; 
 
    FixedVector<StringPath, 8> compilerIncludePaths; 
    FixedVector<StringPath, 8> compilerLibraryPaths; 
 
    [[nodiscard]] static Result findBestCompiler(PluginCompiler& compiler);
 
  private:
    mutable native_char_t buffer[4096];
 
    Result compileFile(const PluginDefinition& definition, const PluginSysroot& sysroot,
                       const PluginCompilerEnvironment& compilerEnvironment, StringView sourceFile,
                       StringView objectFile, Span<char>& compilerLog) const;
    struct CompilerFinder;
};
 
struct PluginSysroot
{
    FixedVector<StringPath, 8> includePaths; 
    FixedVector<StringPath, 8> libraryPaths; 
 
    StringPath isysroot; 
 
    [[nodiscard]] static Result findBestSysroot(PluginCompiler::Type compiler, PluginSysroot& sysroot);
};
 
struct PluginCompilerEnvironment
{
    StringView cFlags;
    StringView ldFlags;
 
  private:
    struct Internal;
    friend struct PluginCompiler;
};
struct PluginDynamicLibrary
{
    PluginDefinition     definition;     
    SystemDynamicLibrary dynamicLibrary; 
    TimeMs               lastLoadTime;   
    uint32_t             numReloads;     
 
    char       errorStorage[1024 * 8] = {}; 
    StringView 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();
 
  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;
    Result load(const PluginCompiler& compiler, const PluginSysroot& sysroot, StringView executablePath);
    Result unload();
};
 
struct PluginRegistry
{
    void init(Span<PluginDynamicLibrary> librariesStorage);
 
    Result close();
 
    Result replaceDefinitions(Span<PluginDefinition>&& definitions);
 
    enum class LoadMode
    {
        Load   = 0,
        Reload = 1,
    };
 
    Result loadPlugin(const StringView identifier, const PluginCompiler& compiler, const PluginSysroot& sysroot,
                      StringView executablePath, LoadMode loadMode = LoadMode::Load);
 
    Result unloadPlugin(const StringView identifier);
 
    Result removeAllBuildProducts(const StringView identifier);
 
    [[nodiscard]] PluginDynamicLibrary* findPlugin(const StringView identifier);
 
    [[nodiscard]] size_t getNumberOfEntries() const { return libraries.sizeInElements(); }
 
    [[nodiscard]] const PluginIdentifier& getIdentifierAt(size_t index) const
    {
        return libraries[index].definition.identity.identifier;
    }
 
    [[nodiscard]] const PluginDynamicLibrary& getPluginDynamicLibraryAt(size_t index) { return libraries[index]; }
 
    void getPluginsToReloadBecauseOf(StringView relativePath, TimeMs tolerance,
                                     Function<void(const PluginIdentifier&)> onPlugin);
 
  private:
    Span<PluginDynamicLibrary> storage;
    Span<PluginDynamicLibrary> libraries;
};
 
} // namespace SC