--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/main/DelegatingJavaFileManager.java Mon Nov 06 13:10:43 2017 +0100
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.sun.tools.javac.main;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.ServiceLoader;
+import java.util.Set;
+
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileManager.Location;
+import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
+import javax.tools.StandardJavaFileManager;
+
+import com.sun.tools.javac.util.Context;
+
+/**
+ * A JavaFileManager that delegates to one of two delegate ClassLoaders.
+ */
+public class DelegatingJavaFileManager implements JavaFileManager {
+
+ public static void installReleaseFileManager(Context context,
+ JavaFileManager releaseFM,
+ JavaFileManager originalFM) {
+ context.put(JavaFileManager.class, (JavaFileManager) null);
+ JavaFileManager nue = originalFM instanceof StandardJavaFileManager
+ ? new DelegatingSJFM(releaseFM,
+ (StandardJavaFileManager) originalFM)
+ : new DelegatingJavaFileManager(releaseFM, originalFM);
+ context.put(JavaFileManager.class, nue);
+ }
+
+ private final JavaFileManager releaseFM;
+ private final JavaFileManager baseFM;
+
+ private DelegatingJavaFileManager(JavaFileManager releaseFM, JavaFileManager baseFM) {
+ this.releaseFM = releaseFM;
+ this.baseFM = baseFM;
+ }
+
+ private JavaFileManager delegate(Location location) {
+ if (releaseFM.hasLocation(location)) {
+ return releaseFM;
+ }
+ return baseFM;
+ }
+
+ @Override
+ public ClassLoader getClassLoader(Location location) {
+ return delegate(location).getClassLoader(location);
+ }
+
+ @Override
+ public Iterable<JavaFileObject> list(Location location, String packageName,
+ Set<Kind> kinds, boolean recurse) throws IOException {
+ return delegate(location).list(location, packageName, kinds, recurse);
+ }
+
+ @Override
+ public String inferBinaryName(Location location, JavaFileObject file) {
+ return delegate(location).inferBinaryName(location, file);
+ }
+
+ @Override
+ public boolean isSameFile(FileObject a, FileObject b) {
+ return baseFM.isSameFile(a, b);
+ }
+
+ @Override
+ public boolean handleOption(String current, Iterator<String> remaining) {
+ return baseFM.handleOption(current, remaining);
+ }
+
+ @Override
+ public boolean hasLocation(Location location) {
+ return releaseFM.hasLocation(location) || baseFM.hasLocation(location);
+ }
+
+ @Override
+ public JavaFileObject getJavaFileForInput(Location location, String className,
+ Kind kind) throws IOException {
+ return delegate(location).getJavaFileForInput(location, className, kind);
+ }
+
+ @Override
+ public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind,
+ FileObject sibling) throws IOException {
+ return delegate(location).getJavaFileForOutput(location, className, kind, sibling);
+ }
+
+ @Override
+ public FileObject getFileForInput(Location location, String packageName,
+ String relativeName) throws IOException {
+ return delegate(location).getFileForInput(location, packageName, relativeName);
+ }
+
+ @Override
+ public FileObject getFileForOutput(Location location, String packageName, String relativeName,
+ FileObject sibling) throws IOException {
+ return delegate(location).getFileForOutput(location, packageName, relativeName, sibling);
+ }
+
+ @Override
+ public void flush() throws IOException {
+ releaseFM.flush();
+ baseFM.flush();
+ }
+
+ @Override
+ public void close() throws IOException {
+ releaseFM.close();
+ baseFM.close();
+ }
+
+ @Override
+ public Location getLocationForModule(Location location,
+ String moduleName) throws IOException {
+ return delegate(location).getLocationForModule(location, moduleName);
+ }
+
+ @Override
+ public Location getLocationForModule(Location location,
+ JavaFileObject fo) throws IOException {
+ return delegate(location).getLocationForModule(location, fo);
+ }
+
+ @Override
+ public <S> ServiceLoader<S> getServiceLoader(Location location,
+ Class<S> service) throws IOException {
+ return delegate(location).getServiceLoader(location, service);
+ }
+
+ @Override
+ public String inferModuleName(Location location) throws IOException {
+ return delegate(location).inferModuleName(location);
+ }
+
+ @Override
+ public Iterable<Set<Location>> listLocationsForModules(Location location) throws IOException {
+ return delegate(location).listLocationsForModules(location);
+ }
+
+ @Override
+ public boolean contains(Location location, FileObject fo) throws IOException {
+ return delegate(location).contains(location, fo);
+ }
+
+ @Override
+ public int isSupportedOption(String option) {
+ return baseFM.isSupportedOption(option);
+ }
+
+ public JavaFileManager getBaseFileManager() {
+ return baseFM;
+ }
+
+ private static final class DelegatingSJFM extends DelegatingJavaFileManager
+ implements StandardJavaFileManager {
+
+ private final StandardJavaFileManager baseSJFM;
+
+ private DelegatingSJFM(JavaFileManager releaseFM,
+ StandardJavaFileManager baseSJFM) {
+ super(releaseFM, baseSJFM);
+ this.baseSJFM = baseSJFM;
+ }
+
+ @Override
+ public boolean isSameFile(FileObject a, FileObject b) {
+ return baseSJFM.isSameFile(a, b);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles
+ (Iterable<? extends File> files) {
+ return baseSJFM.getJavaFileObjectsFromFiles(files);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths
+ (Iterable<? extends Path> paths) {
+ return baseSJFM.getJavaFileObjectsFromPaths(paths);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
+ return baseSJFM.getJavaFileObjects(files);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {
+ return baseSJFM.getJavaFileObjects(paths);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings
+ (Iterable<String> names) {
+ return baseSJFM.getJavaFileObjectsFromStrings(names);
+ }
+
+ @Override
+ public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
+ return baseSJFM.getJavaFileObjects(names);
+ }
+
+ @Override
+ public void setLocation(Location location,
+ Iterable<? extends File> files) throws IOException {
+ baseSJFM.setLocation(location, files);
+ }
+
+ @Override
+ public void setLocationFromPaths(Location location,
+ Collection<? extends Path> paths) throws IOException {
+ baseSJFM.setLocationFromPaths(location, paths);
+ }
+
+ @Override
+ public void setLocationForModule(Location location, String moduleName,
+ Collection<? extends Path> paths) throws IOException {
+ baseSJFM.setLocationForModule(location, moduleName, paths);
+ }
+
+ @Override
+ public Iterable<? extends File> getLocation(Location location) {
+ return baseSJFM.getLocation(location);
+ }
+
+ @Override
+ public Iterable<? extends Path> getLocationAsPaths(Location location) {
+ return baseSJFM.getLocationAsPaths(location);
+ }
+
+ @Override
+ public Path asPath(FileObject file) {
+ return baseSJFM.asPath(file);
+ }
+
+ @Override
+ public void setPathFactory(PathFactory f) {
+ baseSJFM.setPathFactory(f);
+ }
+
+ }
+}