plugin.hpp

#pragma once
 
#include <cstdint>
#include <optional>
#include <plugify/mem_addr.hpp>
#include <plugify/path.hpp>
#include <plugify/reference_wrapper.hpp>
#include <plugify_export.h>
#include <span>
#include <string>
 
namespace plugify {
    class Plugin;
    class PluginDescriptorRef;
    class MethodRef;
 
    enum class PluginState : uint8_t {
        NotLoaded,
        Error,
        Loaded,
        Running,
        Terminating,
        Unknown,
    };
 
    using UniqueId = std::ptrdiff_t;
 
    using MethodData = std::pair<MethodRef, MemAddr>;
 
    class PLUGIFY_API PluginRef : public Ref<const Plugin> {
        using Ref::Ref;
    public:
        UniqueId GetId() const noexcept;
 
        std::string_view GetName() const noexcept;
 
        std::string_view GetFriendlyName() const noexcept;
 
        std::filesystem::path_view GetBaseDir() const noexcept;
 
        PluginDescriptorRef GetDescriptor() const noexcept;
 
        PluginState GetState() const noexcept;
 
        std::string_view GetError() const noexcept;
 
        std::span<const MethodData> GetMethods() const noexcept;
 
        std::optional<std::filesystem::path_view> FindResource(std::filesystem::path_view path) const;
    };
    static_assert(is_ref_v<PluginRef>);
 
    namespace PluginUtils {
        [[maybe_unused]] constexpr std::string_view ToString(PluginState state) {
            switch (state) {
                case PluginState::NotLoaded:   return "NotLoaded";
                case PluginState::Error:       return "Error";
                case PluginState::Loaded:      return "Loaded";
                case PluginState::Running:     return "Running";
                case PluginState::Terminating: return "Terminating";
                default:                       return "Unknown";
            }
        }
 
        [[maybe_unused]] constexpr PluginState FromString(std::string_view state) {
            if (state == "NotLoaded") {
                return PluginState::NotLoaded;
            } else if (state == "Error") {
                return PluginState::Error;
            } else if (state == "Loaded") {
                return PluginState::Loaded;
            } else if (state == "Running") {
                return PluginState::Running;
            } else if (state == "Terminating") {
                return PluginState::Terminating;
            }
            return PluginState::Unknown;
        }
    } // namespace PluginUtils
 
} // namespace plugify