Java Location类代码示例

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
@Override
public void visit(Location o, Location t) {
    Archive targetArchive = findArchive(t);
    if (filter.accepts(o, archive, t, targetArchive)) {
        addDep(o, t);
        if (!requires.contains(targetArchive)) {
            requires.add(targetArchive);
        }
    }
    if (targetArchive instanceof JDKArchive) {
        Profile p = Profile.getProfile(t.getPackageName());
        if (profile == null || (p != null && p.compareTo(profile) > 0)) {
            profile = p;
        }
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
protected Dep addDep(Location o, Location t) {
    String origin = getLocationName(o);
    String target = getLocationName(t);
    Archive targetArchive = findArchive(t);
    if (curDep != null &&
            curDep.origin().equals(origin) &&
            curDep.originArchive() == archive &&
            curDep.target().equals(target) &&
            curDep.targetArchive() == targetArchive) {
        return curDep;
    }

    Dep e = new Dep(origin, archive, target, targetArchive);
    if (deps.contains(e)) {
        for (Dep e1 : deps) {
            if (e.equals(e1)) {
                curDep = e1;
            }
        }
    } else {
        deps.add(e);
        curDep = e;
    }
    return curDep;
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private void transitiveArchiveDeps(int depth) throws IOException {
    Stream<Location> deps = archives.stream()
                                    .flatMap(Archive::getDependencies);

    // start with the unresolved archives
    Set<Archive> unresolved = unresolvedArchives(deps);
    do {
        // parse all unresolved archives
        Set<Location> targets = apiOnly
            ? finder.parseExportedAPIs(unresolved.stream())
            : finder.parse(unresolved.stream());
        archives.addAll(unresolved);

        // Add dependencies to the next batch for analysis
        unresolved = unresolvedArchives(targets.stream());
    } while (!unresolved.isEmpty() && depth-- > 0);
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
Archive findArchive(Location t) {
    // local in this archive
    if (archive.getClasses().contains(t))
        return archive;

    Archive target;
    if (locationToArchive.containsKey(t)) {
        target = locationToArchive.get(t);
    } else {
        // special case JDK removed API
        target = configuration.findClass(t)
            .orElseGet(() -> REMOVED_JDK_INTERNALS.contains(t)
                                ? REMOVED_JDK_INTERNALS
                                : NOT_FOUND);
    }
    return locationToArchive.computeIfAbsent(t, _k -> target);
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
@Override
public void visit(Location o, Location t) {
    Archive targetArchive = findArchive(t);
    if (filter.accepts(o, archive, t, targetArchive)) {
        addDep(o, t);
        if (archive != targetArchive && !requires.contains(targetArchive)) {
            requires.add(targetArchive);
        }
    }
    if (targetArchive.getModule().isNamed()) {
        Profile p = Profile.getProfile(t.getPackageName());
        if (profile == null || (p != null && p.compareTo(profile) > 0)) {
            profile = p;
        }
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private Set<Location> waitForTasksCompleted() {
    try {
        Set<Location> targets = new HashSet<>();
        FutureTask<Set<Location>> task;
        while ((task = tasks.poll()) != null) {
            // wait for completion
            if (!task.isDone())
                targets.addAll(task.get());
        }
        return targets;
    } catch (InterruptedException|ExecutionException e) {
        throw new Error(e);
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
@Override
public void visit(Location o, Location t) {
    Archive targetArchive = findArchive(t);
    if (filter.accepts(o, archive, t, targetArchive)) {
        addDep(o, t);
        if (archive != targetArchive && !requires.contains(targetArchive)) {
            requires.add(targetArchive);
        }
    }
    if (targetArchive instanceof JDKArchive) {
        Profile p = Profile.getProfile(t.getPackageName());
        if (profile == null || (p != null && p.compareTo(profile) > 0)) {
            profile = p;
        }
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
public void addClass(Location origin) {
    Set<Location> set = deps.get(origin);
    if (set == null) {
        set = new HashSet<>();
        deps.put(origin, set);
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
public void visitDependences(Visitor v) {
    for (Map.Entry<Location,Set<Location>> e: deps.entrySet()) {
        for (Location target : e.getValue()) {
            v.visit(e.getKey(), target);
        }
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private boolean run() throws IOException {
    // parse classfiles and find all dependencies
    findDependencies();

    Analyzer analyzer = new Analyzer(options.verbose, new Analyzer.Filter() {
        @Override
        public boolean accepts(Location origin, Archive originArchive,
                               Location target, Archive targetArchive)
        {
            if (options.findJDKInternals) {
                // accepts target that is JDK class but not exported
                return isJDKArchive(targetArchive) &&
                          !((JDKArchive) targetArchive).isExported(target.getClassName());
            } else if (options.filterSameArchive) {
                // accepts origin and target that from different archive
                return originArchive != targetArchive;
            }
            return true;
        }
    });

    // analyze the dependencies
    analyzer.run(sourceLocations);

    // output result
    if (options.dotOutputDir != null) {
        Path dir = Paths.get(options.dotOutputDir);
        Files.createDirectories(dir);
        generateDotFiles(dir, analyzer);
    } else {
        printRawOutput(log, analyzer);
    }

    if (options.findJDKInternals && !options.nowarning) {
        showReplacements(analyzer);
    }
    return true;
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private void buildLocationArchiveMap(List<Archive> archives) {
    // build a map from Location to Archive
    for (Archive archive: archives) {
        for (Location l: archive.getClasses()) {
            if (!map.containsKey(l)) {
                map.put(l, archive);
            } else {
                // duplicated class warning?
            }
        }
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
Archive findArchive(Location t) {
    Archive target = archive.getClasses().contains(t) ? archive : map.get(t);
    if (target == null) {
        map.put(t, target = NOT_FOUND);
    }
    return target;
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private String getLocationName(Location o) {
    if (level == Type.CLASS || level == Type.VERBOSE) {
        return o.getClassName();
    } else {
        String pkg = o.getPackageName();
        return pkg.isEmpty() ? "<unnamed>" : pkg;
    }
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
/**
 * Returns the archives that contains the given locations and
 * not parsed and analyzed.
 */
private Set<Archive> unresolvedArchives(Stream<Location> locations) {
    return locations.filter(l -> !finder.isParsed(l))
                    .distinct()
                    .map(configuration::findClass)
                    .flatMap(Optional::stream)
                    .collect(toSet());
}
 

import com.sun.tools.classfile.Dependency.Location; //导入依赖的package包/类
private void transitiveDeps(int depth) throws IOException {
    Stream<Location> deps = archives.stream()
                                    .flatMap(Archive::getDependencies);

    Deque<Location> unresolved = deps.collect(Collectors.toCollection(LinkedList::new));
    ConcurrentLinkedDeque<Location> deque = new ConcurrentLinkedDeque<>();
    do {
        Location target;
        while ((target = unresolved.poll()) != null) {
            if (finder.isParsed(target))
                continue;

            Archive archive = configuration.findClass(target).orElse(null);
            if (archive != null) {
                archives.add(archive);

                String name = target.getName();
                Set<Location> targets = apiOnly
                        ? finder.parseExportedAPIs(archive, name)
                        : finder.parse(archive, name);

                // build unresolved dependencies
                targets.stream()
                       .filter(t -> !finder.isParsed(t))
                       .forEach(deque::add);
            }
        }
        unresolved = deque;
        deque = new ConcurrentLinkedDeque<>();
    } while (!unresolved.isEmpty() && depth-- > 0);
}