juzu.impl.compiler.VirtualFileManager Maven / Gradle / Ivy
/*
* Copyright 2013 eXo Platform SAS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package juzu.impl.compiler;
import juzu.impl.compiler.file.CompositeFileManager;
import juzu.impl.common.FileKey;
import juzu.impl.compiler.file.FileManager;
import juzu.impl.compiler.file.JavaFileObjectImpl;
import juzu.impl.compiler.file.SimpleFileManager;
import juzu.impl.fs.spi.ReadFileSystem;
import juzu.impl.fs.spi.ReadWriteFileSystem;
import javax.tools.FileObject;
import javax.tools.ForwardingJavaFileManager;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/** @author Julien Viet */
class VirtualFileManager extends ForwardingJavaFileManager implements StandardJavaFileManager {
/** . */
final SimpleFileManager sourcePath;
/** . */
final SimpleFileManager classOutput;
/** . */
final CompositeFileManager classPath;
/** . */
final SimpleFileManager sourceOutput;
public VirtualFileManager(
JavaFileManager fileManager,
ReadFileSystem sourcePath,
Collection> classPath,
ReadWriteFileSystem sourceOutput,
ReadWriteFileSystem classOutput) {
super(fileManager);
//
this.sourcePath = safeWrap(StandardLocation.SOURCE_PATH, sourcePath);
this.classPath = new CompositeFileManager(StandardLocation.CLASS_PATH, classPath);
this.classOutput = safeWrap(StandardLocation.CLASS_OUTPUT, classOutput);
this.sourceOutput = safeWrap(StandardLocation.SOURCE_OUTPUT, sourceOutput);
}
private SimpleFileManager
safeWrap(StandardLocation location, ReadFileSystem
fs) {
return fs != null ? new SimpleFileManager
(location, fs) : null;
}
private FileManager getFiles(Location location) {
if (location instanceof StandardLocation) {
switch ((StandardLocation)location) {
case SOURCE_PATH:
return sourcePath;
case SOURCE_OUTPUT:
return sourceOutput;
case CLASS_OUTPUT:
return classOutput;
case CLASS_PATH:
return classPath;
}
}
return null;
}
//
public Iterable getJavaFileObjectsFromFiles(Iterable files) {
throw new UnsupportedOperationException();
}
public Iterable getJavaFileObjects(File... files) {
throw new UnsupportedOperationException();
}
public Iterable getJavaFileObjectsFromStrings(Iterable names) {
throw new UnsupportedOperationException();
}
public Iterable getJavaFileObjects(String... names) {
throw new UnsupportedOperationException();
}
public void setLocation(Location location, Iterable path) throws IOException {
throw new UnsupportedOperationException();
}
public Iterable getLocation(Location location) {
if (location == StandardLocation.CLASS_PATH) {
FileManager manager = getFiles(location);
if (manager != null) {
try {
HashSet files = new HashSet();
manager.populateRoots(files);
return files;
}
catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
// **************
@Override
public JavaFileObject getJavaFileForInput(Location location, String className, JavaFileObject.Kind kind) throws IOException {
throw new UnsupportedOperationException("Does not seem used at the moment, for now we leave it as is");
}
@Override
public Iterable list(Location location, String packageName, Set kinds, boolean recurse) throws IOException {
Iterable ret;
if (location == StandardLocation.PLATFORM_CLASS_PATH) {
ret = super.list(location, packageName, kinds, recurse);
}
else {
FileManager files = getFiles(location);
if (files != null) {
ret = files.list(packageName, kinds, recurse, new ArrayList());
}
else {
ret = Collections.emptyList();
}
}
return ret;
}
@Override
public String inferBinaryName(Location location, JavaFileObject file) {
if (file instanceof JavaFileObjectImpl) {
JavaFileObjectImpl fileClass = (JavaFileObjectImpl)file;
return fileClass.getKey().fqn;
}
else {
return super.inferBinaryName(location, file);
}
}
@Override
public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
FileKey key = FileKey.newResourceName(packageName, relativeName);
FileManager files = getFiles(location);
if (files != null) {
return files.getReadable(key);
}
else {
throw new FileNotFoundException("Cannot write: " + location);
}
}
@Override
public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
FileKey key = FileKey.newResourceName(packageName, relativeName);
// Address a bug
if (location == StandardLocation.SOURCE_PATH) {
FileObject file = sourcePath.getReadable(key);
if (file == null) {
throw new FileNotFoundException("Not found:" + key.toString());
}
return file;
}
else {
FileManager files = getFiles(location);
if (files != null) {
return files.getWritable(key);
}
else {
throw new FileNotFoundException("Cannot write: " + location);
}
}
}
@Override
public boolean isSameFile(FileObject a, FileObject b) {
FileKey ka = ((JavaFileObjectImpl)a).getKey();
FileKey kb = ((JavaFileObjectImpl)b).getKey();
return ka.equals(kb);
}
@Override
public JavaFileObject getJavaFileForOutput(Location location, String className, JavaFileObject.Kind kind, FileObject sibling) throws IOException {
FileManager files = getFiles(location);
if (files != null) {
FileKey key = FileKey.newJavaName(className, kind);
return files.getWritable(key);
}
else {
throw new UnsupportedOperationException("Location " + location + " not supported");
}
}
}