| Package | Description |
|---|---|
| net.mountainblade.modular | |
| net.mountainblade.modular.annotations | |
| net.mountainblade.modular.impl |
| Modifier and Type | Interface and Description |
|---|---|
interface |
ModuleManager
Represents a module manager.
|
| Modifier and Type | Method and Description |
|---|---|
<M extends Module> |
ModuleManager.getModule(Class<M> module)
Gets a specific module by its class.
|
<M extends Module> |
ModuleManager.loadModule(Class<M> moduleClass,
Filter... filters)
Loads only the given module class and its dependencies.
|
<T extends Module> |
ModuleManager.provide(T module)
Stores the given module instance in the registry,
but also executes all injection magic and calls the usual methods.
|
<T extends Module> |
ModuleManager.provideSimple(T module)
Simply provides a module instance and stores it in the registry.
|
| Modifier and Type | Method and Description |
|---|---|
Collection<Module> |
ModuleManager.loadModules(Collection<URI> uris,
String packageName,
Filter... filters)
Loads modules from a collection of URIs with support for a resource package filter.
|
Collection<Module> |
ModuleManager.loadModules(File file,
Filter... filters)
Loads modules from the given file.
|
Collection<Module> |
ModuleManager.loadModules(String resource,
Filter... filters)
Loads modules inside the current class path with the given string representing either
a class file directly or a package and thus functioning as a filter.
|
Collection<Module> |
ModuleManager.loadModules(URI uri,
Filter... filters)
Load modules from a URI.
|
Collection<Module> |
ModuleManager.loadModules(URI uri,
String packageName,
Filter... filters)
Loads modules from a URI with support for a resource package filter.
|
| Modifier and Type | Method and Description |
|---|---|
com.google.common.base.Optional<ModuleInformation> |
ModuleManager.getInformation(Class<? extends Module> module)
Gets information about a specific module.
|
| Modifier and Type | Class and Description |
|---|---|
static class |
Implementation.Default
Default implementation representing that an implementation should use its default implementation (current class).
|
static class |
Inject.Current
Default implementation representing that an injection should use the current model instance.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseModuleManager
Represents the default implementation for module managers.
|
class |
DefaultModuleManager
Represents the default implementation of a
ModuleManager. |
class |
HierarchicModuleManager
Represents a hierarchical ModuleManager that inherits the modules from its parent, but allows scoped sub-modules.
|
| Modifier and Type | Method and Description |
|---|---|
<M extends Module> |
ModuleRegistry.getModule(Class<M> moduleClass)
Gets a module by its class.
|
<M extends Module> |
HierarchicModuleManager.getModule(Class<M> module) |
<M extends Module> |
BaseModuleManager.getModule(Class<M> module) |
<M extends Module> |
BaseModuleManager.loadModule(Class<M> moduleClass,
Filter... filters) |
<T extends Module> |
BaseModuleManager.provide(T module) |
<T extends Module> |
BaseModuleManager.provideSimple(T module) |
| Modifier and Type | Method and Description |
|---|---|
Module |
ModuleRegistry.Entry.getModule()
Returns the module implementation instance.
|
Module |
ModuleLoader.loadModule(ModuleManager moduleManager,
ModuleLoader.ClassEntry classEntry)
Loads a module using its pre-compiled class entry.
|
| Modifier and Type | Method and Description |
|---|---|
Class<? extends Module> |
ModuleLoader.ClassEntry.getImplementation()
Gets the actual implementation class.
|
Class<? extends Module> |
ModuleLoader.ClassEntry.getModule()
Gets the module we are implementing.
|
Class<? extends Module> |
ModuleRegistry.Entry.getModuleClass()
Returns the class of the module we're implementing.
|
Collection<Module> |
ModuleRegistry.getModules()
Gets a collection of all currently registered modules.
|
Collection<Module> |
ModuleRegistry.getModules(ModuleState state)
Gets a collection of all registered modules with the given state.
|
protected Map<Class<? extends Module>,ModuleRegistry.Entry> |
ModuleRegistry.getRegistry()
Returns the internal registry.
|
Collection<Class<? extends Module>> |
ModuleLoader.ClassEntry.getRequirements()
Gets a collection of all required modules.
|
Collection<Module> |
BaseModuleManager.loadModules(Collection<URI> uris,
String root,
Filter... filters) |
Collection<Module> |
BaseModuleManager.loadModules(File file,
Filter... filters) |
Collection<Module> |
BaseModuleManager.loadModules(String resource,
Filter... filters) |
Collection<Module> |
BaseModuleManager.loadModules(URI uri,
Filter... filters) |
Collection<Module> |
BaseModuleManager.loadModules(URI uri,
String packageName,
Filter... filters) |
| Modifier and Type | Method and Description |
|---|---|
protected void |
ModuleRegistry.addGhostModule(Class<? extends Module> moduleClass,
Module module,
ModuleInformation information)
Adds a "ghost" module which has an entry but is not added to the loaded modules list
and thus will only be visible to the injector.
|
T |
Injector.Constructor.construct(Inject annotation,
Class<? extends T> type,
Module module)
Constructs (or provides) an instance of the set type.
|
void |
Injector.inject(Module module)
Injects the given module instance with its dependencies.
|
void |
ModuleLoader.injectAndInitialize(ModuleManager manager,
Module module,
net.mountainblade.modular.impl.ModuleInformationImpl information)
Injects and initializes the given module.
|
void |
ModuleLoader.registerEntry(ModuleLoader.ClassEntry classEntry,
Module module,
net.mountainblade.modular.impl.ModuleInformationImpl information,
ModuleRegistry.Entry moduleEntry)
Registers a new class entry in the system.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
ModuleRegistry.addGhostModule(Class<? extends Module> moduleClass,
Module module,
ModuleInformation information)
Adds a "ghost" module which has an entry but is not added to the loaded modules list
and thus will only be visible to the injector.
|
protected void |
ModuleRegistry.addModule(Class<? extends Module> moduleClass,
ModuleRegistry.Entry entry,
boolean ghost)
Adds a module to the registry.
|
protected ModuleRegistry.Entry |
ModuleRegistry.createEntry(Class<? extends Module> moduleClass,
ModuleInformation information)
Creates a new registry entry for the given module.
|
ModuleLoader.ClassEntry |
ModuleLoader.getClassEntry(Class<? extends Module> implClass)
Fetches the class entry for the given module implementation class.
|
protected ModuleRegistry.Entry |
ModuleRegistry.getEntry(Class<? extends Module> moduleClass)
Gets the registry entry for the given module.
|
ModuleInformation |
ModuleRegistry.getInformation(Class<? extends Module> moduleClass)
Gets the module information for the given module.
|
com.google.common.base.Optional<ModuleInformation> |
HierarchicModuleManager.getInformation(Class<? extends Module> module) |
com.google.common.base.Optional<ModuleInformation> |
BaseModuleManager.getInformation(Class<? extends Module> module) |
boolean |
ModuleLoader.ignoreModuleClass(Class<? extends Module> ignore)
Adds the given class to the list of ignored module superclasses / -interfaces.
|
protected void |
BaseModuleManager.shutdown(Iterator<Module> iterator) |
Copyright © 2014–2015 MountainBlade. All rights reserved.