module.hpp

#pragma once
 
#include <cstdint>
#include <optional>
#include <plugify/path.hpp>
#include <plugify/reference_wrapper.hpp>
#include <plugify_export.h>
 
namespace plugify {
    class Module;
    class LanguageModuleDescriptorRef;
 
    enum class ModuleState : uint8_t {
        NotLoaded,
        Error,
        Loaded,
        Unknown,
    };
 
    using UniqueId = std::ptrdiff_t;
 
    class PLUGIFY_API ModuleRef : public Ref<const Module> {
        using Ref::Ref;
    public:
        UniqueId GetId() const noexcept;
 
        std::string_view GetName() const noexcept;
 
        std::string_view GetLanguage() const noexcept;
 
        std::string_view GetFriendlyName() const noexcept;
 
        std::filesystem::path_view GetFilePath() const noexcept;
 
        std::filesystem::path_view GetBaseDir() const noexcept;
 
        LanguageModuleDescriptorRef GetDescriptor() const noexcept;
 
        ModuleState GetState() const noexcept;
 
        std::string_view GetError() const noexcept;
 
        std::optional<std::filesystem::path_view> FindResource(std::filesystem::path_view path) const;
    };
    static_assert(is_ref_v<ModuleRef>);
 
    namespace ModuleUtils {
        constexpr std::string_view ToString(ModuleState state) noexcept {
            switch (state) {
                case ModuleState::NotLoaded: return "NotLoaded";
                case ModuleState::Error:     return "Error";
                case ModuleState::Loaded:    return "Loaded";
                default:                     return "Unknown";
            }
        }
 
        constexpr ModuleState FromString(std::string_view state) noexcept {
            if (state == "NotLoaded") {
                return ModuleState::NotLoaded;
            } else if (state == "Error") {
                return ModuleState::Error;
            } else if (state == "Loaded") {
                return ModuleState::Loaded;
            }
            return ModuleState::Unknown;
        }
    } // namespace ModuleUtils
 
} // namespace plugify