/**
* Try to load a module from this module loader. Returns {@code null} if the module is not found.
* The returned module may not yet be resolved. The returned module may have a different name than
* the given identifier if the identifier is an alias for another module.
*
* @param identifier the module identifier
* @return the module
* @throws ModuleLoadException if an error occurs while loading the module
*/
protected final Module loadModuleLocal(ModuleIdentifier identifier) throws ModuleLoadException {
FutureModule futureModule = moduleMap.get(identifier);
if (futureModule != null) {
return futureModule.getModule();
}
FutureModule newFuture = new FutureModule(identifier);
futureModule = moduleMap.putIfAbsent(identifier, newFuture);
if (futureModule != null) {
return futureModule.getModule();
}
boolean ok = false;
try {
final ModuleLogger log = Module.log;
log.trace("Locally loading module %s from %s", identifier, this);
final long startTime = Metrics.getCurrentCPUTime();
final ModuleSpec moduleSpec = findModule(identifier);
loadTimeUpdater.addAndGet(this, Metrics.getCurrentCPUTime() - startTime);
if (moduleSpec == null) {
log.trace("Module %s not found from %s", identifier, this);
return null;
}
if (!moduleSpec.getModuleIdentifier().equals(identifier)) {
throw new ModuleLoadException("Module loader found a module with the wrong name");
}
final Module module;
if (moduleSpec instanceof AliasModuleSpec) {
final ModuleIdentifier aliasTarget = ((AliasModuleSpec) moduleSpec).getAliasTarget();
try {
newFuture.setModule(module = loadModuleLocal(aliasTarget));
} catch (RuntimeException e) {
log.trace(e, "Failed to load module %s (alias for %s)", identifier, aliasTarget);
throw e;
} catch (Error e) {
log.trace(e, "Failed to load module %s (alias for %s)", identifier, aliasTarget);
throw e;
}
} else {
module = defineModule((ConcreteModuleSpec) moduleSpec, newFuture);
}
log.trace("Loaded module %s from %s", identifier, this);
ok = true;
return module;
} finally {
if (!ok) {
newFuture.setModule(null);
moduleMap.remove(identifier, newFuture);
}
}
}
private TypeSpec buildModule(ModuleSpec spec) {
CodeBlock.Builder blockBuilder =
CodeBlock.builder().add("return new $T(", spec.getPresenterTypeName());
int i = 0;
for (ParameterSpec parameterSpec : spec.getPresenterArgs()) {
blockBuilder.add(parameterSpec.name);
if (i++ < spec.getPresenterArgs().size() - 1) {
blockBuilder.add(", ");
}
}
blockBuilder.add(");\n");
MethodSpec.Builder methodSpecBuilder =
MethodSpec.methodBuilder("providesPresenter")
.addModifiers(Modifier.PUBLIC)
.returns(spec.getPresenterTypeName())
.addAnnotation(Provides.class)
.addParameters(spec.getProvideParameters())
.addCode(blockBuilder.build());
if (spec.getScopeAnnotationSpec() != null) {
methodSpecBuilder.addAnnotation(spec.getScopeAnnotationSpec());
}
return TypeSpec.classBuilder(spec.getClassName().simpleName())
.addModifiers(Modifier.PUBLIC)
.addAnnotation(Module.class)
.addMethod(methodSpecBuilder.build())
.build();
}
/**
* Create an aggregate module based on a module identifier and list of dependencies to
* import/export.
*
* @param moduleIdentifier The module identifier
* @param dependencies The module identifiers to aggregate
* @return The loaded Module
* @throws ModuleLoadException If any dependent module can not be loaded
*/
public Module createAggregate(
ModuleIdentifier moduleIdentifier, List<ModuleIdentifier> dependencies)
throws ModuleLoadException {
final ModuleSpec moduleSpec = new ModuleSpec(moduleIdentifier);
for (ModuleIdentifier identifier : dependencies) {
DependencySpec dependencySpec = new DependencySpec();
dependencySpec.setModuleIdentifier(identifier);
dependencySpec.setExport(true);
moduleSpec.addDependency(dependencySpec);
}
moduleSpec.setContentLoader(ModuleContentLoader.build().create());
return defineModule(moduleSpec);
}
/**
* Initialize all members with the given number of tiles and components.
*
* @param nt Number of tiles
* @param nc Number of components
*/
public DecoderSpecs(int nt, int nc) {
// Quantization
qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Wavelet transform
wfs = new SynWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Component transformation
cts = new CompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Entropy decoder
ecopts = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
ers = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Precinct partition
pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, dls);
// Codestream
nls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pos = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pcs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
sops = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
ephs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pphs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
iccs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pphs.setDefault(new Boolean(false));
}
/**
* Defines a Module based on a specification. Use of this method is required by any ModuleLoader
* implementations in order to fully define a Module.
*
* @param moduleSpec The module specification to create the Module from
* @return The defined Module
* @throws ModuleLoadException If any dependent modules can not be loaded
*/
protected final Module defineModule(ModuleSpec moduleSpec) throws ModuleLoadException {
final ModuleIdentifier moduleIdentifier = moduleSpec.getIdentifier();
FutureModule futureModule = moduleMap.get(moduleIdentifier);
if (futureModule == null) {
FutureModule newFuture = new FutureModule(moduleIdentifier);
futureModule = moduleMap.putIfAbsent(moduleIdentifier, newFuture);
if (futureModule == null) futureModule = newFuture;
}
// early detect
if (futureModule.module != null) {
throw new ModuleAlreadyExistsException(moduleIdentifier.toString());
}
try {
final List<Dependency> dependencies =
new ArrayList<Dependency>(moduleSpec.getDependencies().size());
for (DependencySpec dependencySpec : moduleSpec.getDependencies()) {
final Module dependencyModule;
try {
dependencyModule = loadModule(dependencySpec.getModuleIdentifier());
} catch (ModuleLoadException e) {
if (dependencySpec.isOptional()) {
continue;
} else {
throw e;
}
}
final Dependency dependency = new Dependency(dependencyModule, dependencySpec.isExport());
dependencies.add(dependency);
}
final Module module = new Module(moduleSpec, dependencies, moduleSpec.getModuleFlags(), this);
synchronized (futureModule) {
futureModule.setModule(module);
}
return module;
} catch (ModuleLoadException e) {
futureModule.setModule(null);
throw e;
} catch (RuntimeException e) {
futureModule.setModule(null);
throw e;
} catch (Error e) {
futureModule.setModule(null);
throw e;
}
}
private static ModuleSpec parse(
final File root,
InputStream source,
final File moduleInfoFile,
final ModuleIdentifier moduleIdentifier)
throws ModuleLoadException {
try {
final XMLInputFactory inputFactory = INPUT_FACTORY;
setIfSupported(inputFactory, XMLInputFactory.IS_VALIDATING, Boolean.FALSE);
setIfSupported(inputFactory, XMLInputFactory.SUPPORT_DTD, Boolean.FALSE);
final XMLStreamReader streamReader = inputFactory.createXMLStreamReader(source);
try {
return parseDocument(root, streamReader, ModuleSpec.build(moduleIdentifier));
} finally {
safeClose(streamReader);
}
} catch (XMLStreamException e) {
throw new ModuleLoadException("Error loading module from " + moduleInfoFile.getPath(), e);
}
}
public ModuleSpec findModule(final ModuleIdentifier identifier, final ModuleLoader delegateLoader)
throws ModuleLoadException {
if (identifier.equals(myIdentifier)) {
// special root JAR module
Manifest manifest;
try {
manifest = jarFile.getManifest();
} catch (IOException e) {
throw new ModuleLoadException("Failed to load MANIFEST from JAR", e);
}
ModuleSpec.Builder builder = ModuleSpec.build(identifier);
Attributes mainAttributes = manifest.getMainAttributes();
String mainClass = mainAttributes.getValue(Attributes.Name.MAIN_CLASS);
if (mainClass != null) {
builder.setMainClass(mainClass);
}
String classPath = mainAttributes.getValue(Attributes.Name.CLASS_PATH);
String dependencies = mainAttributes.getValue("Dependencies");
MultiplePathFilterBuilder pathFilterBuilder = PathFilters.multiplePathFilterBuilder(true);
pathFilterBuilder.addFilter(PathFilters.is("modules"), false);
pathFilterBuilder.addFilter(PathFilters.isChildOf("modules"), false);
builder.addResourceRoot(
ResourceLoaderSpec.createResourceLoaderSpec(
new JarFileResourceLoader("", jarFile), pathFilterBuilder.create()));
String[] classPathEntries =
classPath == null ? JarModuleLoader.NO_STRINGS : classPath.split("\\s+");
for (String entry : classPathEntries) {
if (!entry.isEmpty()) {
if (entry.startsWith("../")
|| entry.startsWith("./")
|| entry.startsWith("/")
|| entry.contains("/../")) {
// invalid
continue;
}
if (entry.endsWith("/")) {
// directory reference
File root = new File(jarFile.getName(), entry);
FileResourceLoader resourceLoader = new FileResourceLoader(entry, root);
builder.addResourceRoot(ResourceLoaderSpec.createResourceLoaderSpec(resourceLoader));
} else {
// assume a JAR
File root = new File(jarFile.getName(), entry);
JarFile childJarFile;
try {
childJarFile = new JarFile(root, true);
} catch (IOException e) {
// ignore and continue
continue;
}
builder.addResourceRoot(
ResourceLoaderSpec.createResourceLoaderSpec(
new JarFileResourceLoader(entry, childJarFile)));
}
}
}
String[] dependencyEntries =
dependencies == null ? JarModuleLoader.NO_STRINGS : dependencies.split("\\s*,\\s*");
for (String dependencyEntry : dependencyEntries) {
boolean optional = false;
boolean export = false;
dependencyEntry = dependencyEntry.trim();
if (!dependencyEntry.isEmpty()) {
String[] fields = dependencyEntry.split("\\s+");
if (fields.length < 1) {
continue;
}
String moduleName = fields[0];
for (int i = 1; i < fields.length; i++) {
String field = fields[i];
if (field.equals("optional")) {
optional = true;
} else if (field.equals("export")) {
export = true;
}
// else ignored
}
builder.addDependency(
DependencySpec.createModuleDependencySpec(
ModuleIdentifier.fromString(moduleName), export, optional));
}
}
builder.addDependency(DependencySpec.createSystemDependencySpec(JDKPaths.JDK));
builder.addDependency(DependencySpec.createLocalDependencySpec());
return builder.create();
} else {
String namePath = identifier.getName().replace('.', '/');
String basePath = "modules/" + namePath + "/" + identifier.getSlot();
JarEntry moduleXmlEntry = jarFile.getJarEntry(basePath + "/module.xml");
if (moduleXmlEntry == null) {
return null;
}
ModuleSpec moduleSpec;
try {
InputStream inputStream = jarFile.getInputStream(moduleXmlEntry);
try {
moduleSpec =
ModuleXmlParser.parseModuleXml(
new ModuleXmlParser.ResourceRootFactory() {
public ResourceLoader createResourceLoader(
final String rootPath, final String loaderPath, final String loaderName)
throws IOException {
return new JarFileResourceLoader(loaderName, jarFile, loaderPath);
}
},
basePath,
inputStream,
moduleXmlEntry.getName(),
delegateLoader,
identifier);
} finally {
JarModuleLoader.safeClose(inputStream);
}
} catch (IOException e) {
throw new ModuleLoadException("Failed to read module.xml file", e);
}
return moduleSpec;
}
}
