}

    @Override
    public Set<Entry<String, String>> entrySet() {
        return new AbstractSet<Entry<String, String>>() {
            @Override
            public Iterator<Entry<String, String>> iterator() {
                Iterator<Entry<Object, Object>> iterator = properties.entrySet().iterator();
                return new Iterator<Entry<String, String>>() {
                    Entry<String, String> next;

                    {

                boolean caseSensitive = !Os.IS_WINDOWS;
                for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
                    String key = "env."
                            + (caseSensitive ? entry.getKey() : entry.getKey().toUpperCase(Locale.ENGLISH));
                    tmp.setProperty(key, entry.getValue());
                }
                envVars = tmp;
            }

             */
            try (JarFile jar = new JarFile(path.toFile())) {
                ZipEntry entry = jar.getEntry(MODULE_INFO);
                if (entry != null) {
                    String name = null;
                    if (resolve) {
                        try (InputStream in = jar.getInputStream(entry)) {
                            name = getModuleName(in);
                        }
                    }

    }

    public static <K, T extends Map<K, Artifact>> T copyArtifacts(Map<K, ? extends Artifact> from, T to) {
        if (from != null) {
            for (Map.Entry<K, ? extends Artifact> entry : from.entrySet()) {
                to.put(entry.getKey(), ArtifactUtils.copyArtifact(entry.getValue()));
            }
        }

        return to;
    }

    private static <T> List<T> copyList(List<T> original) {

    }

    @Override
    public Set<Entry<String, String>> entrySet() {
        return new AbstractSet<Entry<String, String>>() {
            @Override
            public Iterator<Entry<String, String>> iterator() {
                Iterator<Entry<Object, Object>> iterator = properties.entrySet().iterator();
                return new Iterator<Entry<String, String>>() {
                    Entry<String, String> next;

                    {

    /**
     * construct a single vertex
     */
    public MetadataGraph(MetadataGraphVertex entry) throws MetadataResolutionException {
        checkVertex(entry);
        checkVertices(1);

        entry.setCompareVersion(versionedVertices);
        entry.setCompareScope(scopedVertices);

        vertices.add(entry);
        this.entry = entry;
    }
    // ------------------------------------------------------------------------

 *
 */
@Deprecated
public class MetadataGraph {
    /** all graph nodes */
    Collection<MetadataGraphNode> nodes;

    /** entry point for tree-like structures */
    MetadataGraphNode entry;

    public MetadataGraph(MetadataGraphNode entry) {
        this();

        this.entry = entry;
    }

    public MetadataGraph() {
        nodes = new ArrayList<>(64);
    }

            logger.warn("");
            for (Map.Entry<String, PluginValidationIssues> entry : issuesMap.entrySet()) {
                PluginValidationIssues issues = entry.getValue();
                if (!hasAnythingToReport(issues, issueLocalitiesToReport)) {
                    continue;
                }
                logger.warn(" * {}", entry.getKey());

        Set<String> artifacts = new LinkedHashSet<>();
        Set<String> packages = new LinkedHashSet<>();

        try {
            for (File entry : classpath) {
                ExtensionDescriptor descriptor = BUILDER.build(entry);
                if (descriptor != null) {
                    artifacts.addAll(descriptor.getExportedArtifacts());

 */
public class CoreExports {
    private final Set<String> artifacts;

    private final Map<String, ClassLoader> packages;

    public CoreExports(CoreExtensionEntry entry) {
        this(entry.getClassRealm(), entry.getExportedArtifacts(), entry.getExportedPackages());
    }

    public CoreExports(ClassRealm realm, Set<String> exportedArtifacts, Set<String> exportedPackages) {