All Classes and Interfaces

Class
Description
 
 
 
 
 
Abstract combination of DeferredClass and DeferredProvider.
 
 
 
Skeleton class that generates a qualified class index.
Abstract TypeConverter Module that automatically registers the converter based on the type argument.
Binding source locations can implement this interface to supply annotations to the BeanLocator.
Something that can visit annotation declarations.
A visitor to visit a Java annotation.
An AnnotationVisitor that generates a corresponding 'annotation' or 'type_annotation' structure, as defined in the Java Virtual Machine Specification (JVMS).
 
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine Specification (JVMS).
A set of attribute prototypes (attributes with the same type are considered equal).
 
 
Provides custom PropertyBinders for beans that contain one or more properties.
Atomic cache mapping Bindings to BeanEntrys; optimized for common case of single entries.
Describes Qualified bean implementations of T:

Deprecated.
MembersInjector that takes PropertyBindings and applies them to bean instances.
Represents the JSR250 lifecycle for a particular bean type.
TypeListener that listens for bean types and arranges for their properties to be injected.
Finds and tracks bean implementations annotated with Qualifier annotations.
Service that manages the lifecycle of beans.
Iterable that iterates over potential bean properties in a class hierarchy.
Represents a bean property such as a field or setter method.
BeanProperty backed by a Field.
Read-only Iterator that picks out potential bean properties from declared members.
BeanProperty backed by a single-parameter setter Method.
Supplies various bean Providers backed by dynamic bean lookups.
Common techniques for discovering bean implementations.
Deprecated.
Schedules safe activation of beans even when cyclic dependencies are involved.
Takes advantage of the new Guice ProvisionListener SPI, if available at runtime.
Listens to provisioning events in order to determine safe activation points.
Publisher of Bindings to interested BindingSubscribers.
Subscriber of Bindings from one or more BindingPublishers.
Tracker of ServiceBindings from the OSGi service registry.
 
ClassSpace backed by a strongly-referenced Bundle.
Chains a series of Enumerations together to look like a single Enumeration.
Guice module that uses classpath-scanning and auto-wiring to bind JSR330 components from OSGi bundles.
Something that can prepare BindingPublishers for component bundles.
 
A dynamically extensible vector of bytes.
 
Child WireModule that avoids wiring dependencies that already exist in a parent Injector.
 
Finds (and optionally filters) Class resources from ClassSpaces.
A parser to make a ClassVisitor visit a ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
 
Represents an abstract collection of related classes and resources.
Exception thrown when the constant pool of a class produced by a ClassWriter is too large.
A visitor to visit a Java class.
Something that can visit class definitions.
A ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
ClassSpace that can create multiple (deferred) copies of the same implementation type.
ClassLoader that can define multiple copies of the same implementation type.
 
 
 
 
 
PlexusBeanModule that binds Plexus components according to their ComponentDescriptors.
PlexusBeanSource backed by simple map of PlexusBeanMetadata.
 
Partial runtime implementation of Plexus @Component annotation, supporting the most common attributes.
 
 
 
 
 
 
 
Helper class that implements low-level Plexus configuration of composite beans.
 
 
Runtime implementation of Plexus @Configuration annotation.
 
 
 
A constant whose value is computed at runtime, with a bootstrap method.
Defines additional JVM opcodes, access flags and constants which are not part of the ASM public API.
 
 
Information about a class being parsed in a ClassReader.
 
 
 
 
Information about the input stack map frame at the "current" instruction of a method.
 
 
Iterable that iterates over declared members of a class hierarchy.
Read-only Iterator that uses rolling DeclaredMembers.Views to traverse the different members.
Enum implementation that provides different views of a class's members.
Default MutableBeanLocator that locates qualified beans across a dynamic group of BindingPublishers.
ClassFinder that finds Class resources under a given package name.
 
 
 
 
PlexusBeanLocator that locates beans of various types from zero or more Injectors.
Sequence of PlexusBeans backed by BeanEntrys.
 
PlexusContainer shim that delegates to a Plexus-aware Guice Injector.
Simple RankingFunction that partitions qualified bindings into two main groups.
Placeholder Class; postpones classloading until absolutely necessary.
Provider backed by a DeferredClass.
BindingTargetVisitor that collects the Keys of any injected dependencies.
BindingTargetVisitor that verifies any injected dependencies.
Describes a bean:

Deprecated.
Implementation of @Description that can also act as an @AnnotatedSource.
 
 
Marks dependencies that should be dynamic proxies:

Utility methods for generating dynamic Provider-based proxies.
Marks beans that should be created as soon as possible:

Deprecated.
An edge in the control flow graph of a method.
ElementVisitor that analyzes Bindings for unresolved injection dependencies.
ElementVisitor that verifies Bindings and merges any duplicates.
List backed by an Iterable sequence of map entries.
Value Iterator backed by a Key:Value Iterator.
Value ListIterator backed by a cached Key:Value Iterator.
Map backed by an Iterable sequence of map entries.
Entry Set backed by an Iterable sequence of map entries.
Set backed by an Iterable sequence of map entries.
Value Iterator backed by a Key:Value Iterator.
 
 
 
A visitor to visit a Java field.
A FieldVisitor that generates a corresponding 'field_info' structure, as defined in the Java Virtual Machine Specification (JVMS).
 
Iterator that iterates over named entries beneath a file-system directory.
TypeConverter Module that converts constants to Files.
 
The input and output stack map frames of a basic block.
Enumerates various optimized globbing strategies.
Weak cache of ClassLoaders that can generate proxy classes on-demand.
Utility methods for dealing with changes in the Guice 4.0 SPI.
A reference to a field or a method.
Information about an exception handler.
Hides a bean from being located or watched:

Implementation of @Hidden that can also act as an @AnnotatedSource.
Hint-driven sequence of PlexusBeans that uses MissingPlexusBeans to indicate missing hints.
Constants and utility methods for dealing with Plexus hints.
Annotates class hierarchies that don't want setter injection.
Utility methods for discovering the implementations behind Guice bindings.
BindingTargetVisitor that attempts to find the implementations behind bindings.
Implementations.ClassFinder that also returns Provider implementations.
Implementations.ProviderFinder that also returns servlet/filter implementations.
Source of "implicit" bindings; includes @ImplementedBy, @ProvidedBy, and concrete types.
ClassFinder that finds Class resources listed in the named index.
Generates a qualified class index for the current project and its dependencies.
 
 
Abstract TestNG/JUnit4/5 test that automatically binds and injects itself.
Deprecated.
Switch to JUnit4 or 5 with InjectedTest
Publisher of Bindings from a single Injector; ranked according to a given RankingFunction.
 
A position in the bytecode of a method.
Lazy BeanEntry backed by a qualified Binding and an assigned rank.
Implementation of @Named that can also act like @Named.
Map.Entry representing a lazy @Named Plexus bean; the bean is only retrieved when the value is requested.
Deprecated.
Limited support for migrating legacy types.
Builds BeanLifecycles by searching class hierarchies for JSR250 annotations.
BeanManager that manages JSR250 beans and schedules lifecycle events.
Allows testing if a class should be flushed from the cache
Guice Module that provides lifecycle management by following PostConstruct and PreDestroy annotations, or corresponding JSR250 PostConstruct and PreDestroy annotations.
Pseudo DeferredClass backed by an already loaded Class.
Provides a sequence of BeanEntrys by iterating over qualified Bindings.
Adds BeanLocator-backed bindings for unresolved bean dependencies.
 
 
 
Utility methods for dealing with container logging and recovery.
Logs.Sinks messages to the system console.
Logs.Sinks messages to the JDK.
Something that accepts formatted messages.
Logs.Sinks messages via SLF4J.
 
Bootstrap class that creates a static Injector by scanning the current class-path for beans.
 
Generates a qualified class index for classes compiled by the current project.
 
 
 
InjectionListener that listens for mediated watchers and registers them with the BeanLocator.
Record containing all the necessary details about a mediated watcher.
Watches for Qualified bean implementations of T:

Deprecated.
Guice Module that discards any duplicate or broken bindings.
Delegating Map that merges a series of Maps into one consistent view.
Exception thrown when the Code attribute of a method produced by a ClassWriter is too large.
A visitor to visit a Java method.
A MethodVisitor that generates a corresponding 'method_info' structure, as defined in the Java Virtual Machine Specification (JVMS).
Thread-safe Map whose keys are kept alive by soft/weak References.
Thread-safe Map whose values are kept alive by soft/weak References.
NON-thread-safe Collection of elements kept alive by soft/weak References.
Represents an element that can be indexed.
NON-thread-safe Map whose keys are kept alive by soft/weak References.
Soft key that maintains a constant hash and uses referential equality.
Weak key that maintains a constant hash and uses referential equality.
NON-thread-safe Map whose values are kept alive by soft/weak References.
Represents an inverse mapping from a value to its key.
Soft value with an MildValues.InverseMapping back to its key.
Weak value with an MildValues.InverseMapping back to its key.
Map.Entry representing a missing @Named Plexus bean.
A visitor to visit a Java module.
A ModuleVisitor that generates the corresponding Module, ModulePackages and ModuleMainClass attributes, as defined in the Java Virtual Machine Specification (JVMS).
Mutable BeanLocator that finds and tracks bindings across zero or more BindingPublishers.
 
DeferredClass representing a named class from a ClassSpace.
String mapping Iterable backed by a Named mapping Iterable.
String mapping Map.Entry backed by a Named mapping Map.Entry.
String mapping Iterator backed by a Named mapping Iterator.
Marks dependencies that can be null:

Deprecated.
 
The JVM opcodes, access flags and array type codes.
Represents a BeanProperty bound to an optional Provider.
 
Useful Keys for binding Parameters.
Qualifier of application parameters:

Deprecated.
 
TypeConverter Module that converts constants to Paths.
Provides a single bean; the name used to lookup/convert the bean is selected at runtime.
PlexusBeanModule that binds Plexus components by scanning classes for runtime annotations.
PlexusBeanSource backed by runtime annotation metadata.
Runtime PlexusBeanMetadata based on BeanProperty annotations.
Plexus bean mapping; from hint to instance.
BeanBinder that binds bean properties according to Plexus metadata.
Service that converts values into various beans by following Plexus configuration rules.
Service that locates beans of various types, using optional Plexus hints as a guide.
Supplies metadata associated with a particular Plexus bean implementation.
Module-like interface for contributing Plexus bindings with additional metadata.
Source of Plexus component beans and associated metadata.
Guice Module that supports registration, injection, and management of Plexus beans.
BundlePlan that prepares BindingPublishers for Plexus bundles.
 
 
 
Creates Providers for properties with @Configuration metadata.
Provider of Plexus configurations.
 
 
 
 
TypeConverter Module that converts Plexus formatted date strings into Dates.
BeanManager that manages Plexus components requiring lifecycle management.
invalid reference
BeanPropertyBinder
that auto-binds properties according to Plexus metadata.
Creates Providers for properties with @Requirement metadata.
Abstract Provider that locates Plexus beans on-demand.
Provider of Plexus requirement lists.
Provider of Plexus requirement maps.
Provider of a single Plexus requirement.
Provider of Plexus requirement sets.
Guice Module that provides Plexus semantics without the full-blown Plexus container.
Context backed by Sisu Parameters.
 
 
PlexusTypeListener that binds Plexus Components.
QualifiedTypeListener that also listens for Plexus components.
Enhanced Plexus component map with additional book-keeping.
SpaceVisitor that reports Plexus bean classes annotated with @Component.
AnnotationVisitor that records details of @Component annotations.
PlexusBeanConverter Module that converts Plexus XML configuration into beans.
PlexusBeanModule that binds Plexus components by scanning XML resources.
PlexusBeanSource backed by consumable XML metadata.
Consumable PlexusBeanMetadata that uses BeanProperty names as keys.
Helper class that can scan XML resources for Plexus metadata.
The PostConstruct annotation is used on a method that needs to be executed after dependency injection is done to perform any initialization.
The PreDestroy annotation is used on methods as a callback notification to signal that the instance is in the process of being removed by the container.
Defines the priority ordering of a bean, higher values have higher priority:

Implementation of @Priority that can also act as an @AnnotatedSource.
 
Provides custom PropertyBindings for bean properties such as fields or setter methods.
Represents a bean property that has been bound by a PropertyBinder.
Represents a BeanProperty bound to a Provider.
Iterable sequence of Provider entries backed by a sequence of BeanEntrys.
Provider Map.Entry backed by a BeanEntry.
Iterator of Provider Map.Entrys backed by an iterator of BeanEntrys.
Delegating PlexusContainer wrapper that doesn't require an actual container instance.
QualifiedTypeListener that installs Modules, registers Mediators, and binds types.
Listens for types annotated with Qualifier annotations.
SpaceVisitor that reports types annotated with Qualifier annotations.
Caching ClassVisitor that maintains a map of known Qualifier annotations.
Enumerates the different strategies for qualifying Bindings against requirement Keys.
Ordered sequence of Bindings of a given type; subscribes to BindingPublishers on demand.
Ordered List that arranges elements by descending rank; supports concurrent iteration and modification.
Represents an immutable snapshot of ranked elements.
Assigns each Binding a rank according to some function; higher ranks take precedence over lower ranks.
Sequence of BeanEntrys filtered according to whether they are visible from the current ClassRealm.
Manages ClassRealm associated data for the Plexus container.
A visitor to visit a record component.
 
Runtime implementation of Plexus @Requirement annotation.
Enumeration of resources found by scanning JARs and directories.
Custom URLConnection that can access JARs nested inside an arbitrary resource.
Custom URLStreamHandler that can stream JARs nested inside an arbitrary resource.
Utility methods for dealing with Plexus roles.
 
Service Binding backed by an OSGi ServiceReference.
On-demand publisher of Bindings from the OSGi service registry.
 
 
BundlePlan that prepares BindingPublishers for JSR330 bundles.
OSGi extender that uses Sisu and Guice to wire up applications from one or more component bundles.
To enable it install org.eclipse.sisu.inject.extender, or adapt the class for your own extender.
SPI mechanism for discovering Module and Strategy extensions.
Command-line utility that generates a qualified class index for a space-separated list of JARs.
Java 6 Annotation Processor that generates a qualified class index for the current build.
OSGi BundleTracker that tracks component bundles and uses BundlePlans to publish them.
Utility methods for dealing with SoftReference collections.
Utility methods for dealing with annotated sources.
Guice Module that automatically binds types annotated with Qualifier annotations.
 
Visitor strategy.
Makes a SpaceVisitor visit a ClassSpace; can be directed by an optional ClassFinder.
Something that can visit ClassSpaces.
 
 
 
Constants representing supported Plexus instantiation strategies.
Utility methods for dealing with streams.
 
 
 
Delegating Map that ignores any non-String properties.
 
An entry of the constant pool, of the BootstrapMethods attribute, or of the (ASM specific) type table of a class.
The constant pool entries, the BootstrapMethods attribute entries and the (ASM specific) type table entries of a class.
An entry of a SymbolTable.
A label corresponding to a "forward uninitialized" type in the ASM specific SymbolTable.typeTable (see Symbol.FORWARD_UNINITIALIZED_TYPE_TAG).
Supports type conversion into java.time classes.
Generates a qualified class index for test classes compiled by the current project.
Utility methods for dealing with tokens.
Iterator that lazily splits a string into tokens.
A Java field or method type.
Utility methods for dealing with generic type arguments.
Utility methods for dealing with generic type arguments.
Qualifier of bindings that should be treated as implicit.
 
Lazy cache of known TypeConverters.
Restricts the visible types of a bean:

The path to a type argument, wildcard bound, array element type, or static inner type within an enclosing type.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
 
ClassSpace backed by a strongly-referenced ClassLoader and a URL class path.
 
TypeConverter Module that converts constants to URLs.
Provides dynamic BeanEntry notifications by tracking qualified Bindings.
Utility methods for dealing with WeakReference collections.
Binding Key for implementations that act as "wild-cards", meaning they match against any assignable type.
Qualifier that captures a qualified implementation type.
Pseudo-Annotation that can wrap any implementation type as a Qualifier.
Guice Module that automatically adds BeanLocator-backed bindings for unresolved dependencies.
Wiring strategy.
Something that can supply bindings for unresolved dependency Keys.
 
Iterator that iterates over named entries inside JAR or ZIP resources.