Function parse_mod_config_manifest

RecompModTool/main.cpp:230–375

}

ModManifest parse_mod_config_manifest(const std::filesystem::path& basedir, const toml::table& manifest_table) {
    ModManifest ret;

    // Mod ID
    ret.mod_id = read_toml_value<std::string_view>(manifest_table, "id", true);
    if (!N64Recomp::validate_mod_id(ret.mod_id)) {
        throw toml::parse_error("Invalid mod id", manifest_table["id"].node()->source());
    }

    // Mod version
    ret.version_string = read_toml_value<std::string_view>(manifest_table, "version", true);
    bool version_has_label;
    if (!validate_version_string(ret.version_string, version_has_label)) {
        throw toml::parse_error("Invalid mod version", manifest_table["version"].node()->source());
    }

    // Display name
    ret.display_name = read_toml_value<std::string_view>(manifest_table, "display_name", true);

    // Description (optional)
    ret.description = read_toml_value<std::string_view>(manifest_table, "description", false);

    // Short description (optional)
    ret.short_description = read_toml_value<std::string_view>(manifest_table, "short_description", false);

    // Authors
    const toml::array& authors_array = read_toml_array(manifest_table, "authors", true);
    authors_array.for_each([&ret](auto&& el) {
        if constexpr (toml::is_string<decltype(el)>) {
            ret.authors.emplace_back(el.template ref<std::string>());
        }
        else {
            throw toml::parse_error("Invalid type for author entry", el.source());
        }
    });
   
    // Game ID
    ret.game_id = read_toml_value<std::string_view>(manifest_table, "game_id", true);

    // Minimum recomp version
    ret.minimum_recomp_version = read_toml_value<std::string_view>(manifest_table, "minimum_recomp_version", true);
    bool minimum_recomp_version_has_label;
    if (!validate_version_string(ret.minimum_recomp_version, minimum_recomp_version_has_label)) {
        throw toml::parse_error("Invalid minimum recomp version", manifest_table["minimum_recomp_version"].node()->source());
    }
    if (minimum_recomp_version_has_label) {
        throw toml::parse_error("Minimum recomp version may not have a label", manifest_table["minimum_recomp_version"].node()->source());
    }

    // Native libraries (optional)
    const toml::array& native_libraries = read_toml_array(manifest_table, "native_libraries", false);
    if (!native_libraries.empty()) {
        native_libraries.for_each([&ret](const auto& el) {
            if constexpr (toml::is_table<decltype(el)>) {
                const toml::table& el_table = *el.as_table();
                std::string_view library_name = read_toml_value<std::string_view>(el_table, "name", true);
                const toml::array funcs_array = read_toml_array(el_table, "funcs", true);
                std::vector<std::string> cur_funcs{};