All Classes and Interfaces

Class
Description
This class can be used as a starting point for those writing their own ActiveDescriptor.
Common archive adapter implementation
This just makes the main-line code less messy
 
 
 
Skeleton implementation of injection binder with convenience methods for binding definitions.
Abstract binding builder implementation.
 
 
 
 
 
 
 
This is an abstract factory, the true type will comd from the concrete class
Abstract Mojo for inhabitant generator
This in only here to keep the main-line code less messy
The Modules Registry maintains the registry of all available module.
Partial implementation of Repository that statically enumerates all ModuleDefinition upfront.
This activator initializes ServiceLoader with an appropriate instance.
An ActiveDescriptor contains information about a Descriptor after it has been reified.
The active descriptor build is for building up a non-reified ActiveDescriptor.
 
 
Iterator implementation that works as a filter to another iterator.
An active descriptor class that serves as an alias for another descriptor.
An annotated element is a java declaration that can be annotated.
Keeps information about element and parameter annotations
Implementation of an annotated element
Supports inline instantiation of annotation type instances.
Models an annotation instance
Model a annotation instance
Represents an annotation
Implementation of an annotation model
This interface is implemented by all services that use the AOP Alliance Interceptor feature of HK2.
adapter for reading archive style structure
Definition of an archive entry
defines the notion of an archive entry task which is a task aimed to be run on particular archive entry.
 
An archive selector allows the user to select if an archive should be parsed by the parser engine.
API -- For now sticking with the draft1 API and behavior This class will be handy for fixing error detection of bad input as below.
 
 
 
 
A database of beans organized as types, where a type can have multiple instances of a configuration bean
 
This is a listener that is notified when changes are made to the current BeanDatabase
 
 
For JavaBean or Bean-Like-Map utilities
The binder is used in conjunction with the ServiceLocatorUtilities.bind(org.glassfish.hk2.api.ServiceLocator, Binder...) method in order to add (or remove) services to a ServiceLocator.
Base binding builder (marker) interface.
HK2 injection binding utility methods.
The class file for this must be copied into resources if this should change
Signals a fatal error in the module system launch.
This class is used to generate DescriptorBuilders to be used as a simple mechanism to create a Filter or Descriptor.
Implementation of InhabitantsDescriptor that loads the inhabitants meta-data from a byte array (usually coming from a inhabitant file).
Cache implementation that relies on FutureTask.
Should a cycle be detected during computation of a value for given key, this interface allows client code to register a callback that would get invoked in such a case.
This can be used to remove a specific cache entry from the cache, for better control of the caching release semantics
This is the cache key, which encapsulates very specific lookup queries.
This is used by the cache to remove a series of entries that match this filter
Utilities for creating caches
This represents a single change made to a BeanDatabase
 
 
 
 
This Injection point indicator can be used for services that have a hierarchical names.
 
This interface can be used in conjunction with the ChildInject annotation to get the current list of children for this injection point
 
When HK2 automatically analyzes a class to find the constructor, fields, initializer methods and postConstruct and preDestroy methods it uses this service to analyze the class.
A set of classes that should be analyzed as services, whether they declare @Service or not.
Facade for ModuleClassLoader to only expose public classes.
This is a PopulatorPostProcessor that adds an HK2Loader based on a ClassLoader.
ClassLoaderProxy capable of loading classes from itself but also from other class loaders
Model that represents a class
Created with IntelliJ IDEA.
Implementation of a class model
Implements a modules registry based on a class-path style of module description using a single class loader (capable of loading the entire class-path)
Deprecated.
Use org.glassfish.hk2.utilities.ClasspathDescriptorFileFinder
This is an implementation of DescriptorFileFinder that uses a particular classloader in order to find descriptor files.
An interface representing useful reflection utilities
 
 
 
 
 
 
 
 
 
 
 
 
 
A closeable object is one that can be closed once, and can not be opened again
This class collects errors, and can then also produce a MultiException from those errors if necessary
 
 
This one is NOT a contract
 
Not a contract
Is a contract
 
Not a contract but implements a contract
 
A factory thar produces a complex object type
 
Not annotated with @Service but is produced by a factory
We need a compound enumeration so that we can aggregate the results from various delegates.
Utility interface to capture generic computation of type V from type K.
This exception should be thrown from the Computable.compute(Object) method if the returned computation should NOT be kept in the cache.
 
The class that corresponds to the Factory provide method is not first, it is not last, it is somewhere in the middle (the Integer)
Basic interface for populating a service locator with configuration data
 
 
 
Useful utilities for using the hk2 configuration system
 
This annotation is placed on fields or on parameters of methods or constructors to indicate that these fields or parameters should come from the configuration instance of the type defined by the ConfiguredBy annotation on the class.
This annotation is put onto classes to indicate that they should be created based on the availability of instances of a specify type of configuration in the Hub
 
 
 
 
 
 
 
 
This represents the action used in order to create an object.
 
 
 
An implementation of this must be put into the system in order to create contextual instances of services.
Deprecated.
Use DuplicatePostProcessor instead
Used by several contexts for keeping the inputs of Context.findOrCreate(ActiveDescriptor, ServiceHandle).
This annotation is used by HK2 during automatic class analysis to indicate that a class or interface should be included in the list of contracts for a service
This annotation is put on annotations that are used to mark things as hk2 contracts.
An explicit list of contracts provided.
This service uses the ContractsProvided annotation
 
 
An internal interface that allows us to have the factory and class implementations
 
This exception is thrown by proceedTo if there is currently a job being run when proceedTo is called
This is the implementation of RunLevelFuture.
 
 
 
 
 
This object is used to wrap the internal CurrentTaskFuture which is a ChangeableRunLevelFuture.
This service has a custom analyzer
Indicates that a method should be customized.
Gives the type (and optional name) of a customizer service to use when an unknown method on a bean interface is encountered.
this is the default implementation of the ClassAnalyzer
A default implementation of the interception service using annotation to denote services that are to be intercepted and other annotations to match methods or constructors to interceptors
ModuleDefinition implementation that picks up most of the module properties from the manifest file of the jar, as baked in by the hk2-maven-plugin.
When using the TopicDistributionService added with ServiceLocatorUtilities.enableTopicDistribution(org.glassfish.hk2.api.ServiceLocator) if a subscriber throws an exception this service will be called.
This is the default implementation of the TopicDistributionService.
This is here to handle the case where a PerLookup Factory (or the like) could possibly return different classes every time it is looked up.
 
 
A classloader that delegates first to an optional parent and then to a delegate loader
 
Delegating XMLStreamWriter.
A Descriptor is a bean-like structure that describes a service declaration in HK2.
This is an object that uses the Builder pattern in order to generate a Descriptor (for binding) or a Filter (for searching).
This is a simple implementation of the DescriptorBuilder
 
This is a comparator making things that don't really compare, compare.
Implementations of this interface allow the customization of how hk2 inhabitant files are found.
Deprecated.
Returns information about the InputStream returned by DescriptorFileFinder.findDescriptorFiles() that can be used to give better information when one of the streams fails.
The implementation of the descriptor itself, with the bonus of being externalizable, and having writeable fields
This describes the type of descriptor
This enumeration determines how visibility of a descriptor
Directory base archive abstraction
This class is a directory based repository implementation.
Used for doubly linked lists with weak keys
This post-processor removes duplicate descriptors from the set of descriptors being added to the service registry.
Key use for implementation only (along with descriptor type, otherwise factories eliminate themselves)
The mode of the duplicate post processor
This exception is thrown when an idempotent filter of a DynamicConfiguration object matches an existing descriptor in the ServiceLocator
This class is used to add Descriptors to a ServiceLocator instance.
The system implementation of the DynamicConfiguration service
A service that listens for dynamic configuration changes.
The dynamic configuration service is the source of DynamicConfiguration instances, which can be used to bind and unbind entities into the system
 
Describes how dynamic a configured field or parameter should be
 
This module can be used to enable exceptions to be thrown from getService API when a descriptor throws an exception during reification or other errors.
This class has information in it about the error that has occurred
 
The set of actions that the system can perform when an error is detected
 
 
 
This interface should be implemented by those who wish to be notified of error conditions that occur within HK2.
 
This enumeration describes the types of errors that might occur
A set of implementations that should be excluded from being added to testLocator.
An extensible type is a type that can be subclassed like an interface or a class.
Implementation of an extensible type (Class or Interface)
These are utilities for the extra features of hk2.
This interface should be implemented in order to provide a factory for another type.
 
This is a convenience class that links together the factory descriptor as a factory for another type and the factory as a service itself.
This is an implementation of FactoryDescriptors that can be used by hk2 uses when creating descriptors that describe a Factory
 
 
 
 
 
 
Model that represent the field of a class
Implementation of a field model
This object is used to search for items in the service registry
Equivalent of FlattenIterator for enumeration
Iterator implementation that works like Lisp "flatten" function.
This class contains utilities useful for any code
 
 
An implementation of GenericArrayType for those times we need to create this on the fly
This should have the default scope of singleton (default for services with @Service anyway).
This annotation can be put on interfaces in order to provide the GreedyResolver the default implementation that should be bound when this interface is injected and there are no other implementations
This is a greedy resolve that will add in any class that has failed to be resolved.
This is a command line (or embedded) utility that will generate habitat files based on @Service annotations.
Data structure with the handle and the service
 
 
 
Base class for HK2 defined checked exceptions
 
Generates a consolidated OSGI bundle with a consolidated HK2 header
 
This is an interface that is also implemented by the MethodInvocation object passed to the invoke method of MethodInterceptor and the ConstructorInvocation object passed to the invoke method of ConstructorInterceptor.
This service must be implemented in order to specify those descriptors that might be reflected into JMX
This class is responsible for loading classes, and different implementations can be used for different descriptors.
This is an implementation of an HK2Loader that uses a given classloader
A Simple PopulatorPostProcessor that uses the given classloader to override default HK2Loader behavior
This is a utility class specific to this implementation of the hk2 API
 
This class should be extended by test classes in order to get an automatically filled in ServiceLocator.
Base class for HK2 defined runtime exceptions
 
These are other useful test utilities that can be used
This is a poor mans version of a ThreadLocal with the one major upside of a Hk2ThreadLocal.removeAll() method that can be used to remove ALL instances of all thread locals on ALL threads from any other thread.
The central repository of configuration objects in the system.
 
Represents a single hybrid cache entry.
Immediate is a scope that operates like Singleton scope, except that instances are created as soon as their corresponding Descriptors are added.
This is the Context implementation for the Immediate scope
This service is advertised when the Immediate service is put into the registry.
 
Implementations of this service will be called whenever an Immediate scoped service fails
The implementation of the immediate context.
 
 
Filter only picks up local services
This contains the local portion of the narrowed result
This module can be used to enable the Immediate scope feature.
Modules that wish to programmatically control their list of imports can implement this interface.
 
This filter can be used to limit the set of Descriptors passed to the matches method.
Implementation created by the builder
This object contains a list of values.
Allows an installer or other jar combiner to be able to scan multiple directories for HK2 services
 
Meta-annotation indicating that the annotation designates a resident service of a ServiceLocator.
A set of locator inhabitant files to search for in the classpath.
This is the builder for the Eclipse inhabitants generator project
Inhabitants Descriptor is an abstraction on how the inhabitants are represented in a module.
Generates inhabitant
InheritableThread is a scope that operates like PerThread scope, except with the caveat that InheritableThread scoped services provide inheritance of values from parent thread to child thread.
 
 
This module can be used to enable the InheritableThread scope feature.
An Injectee represents the point of injection.
This is a writeable version of the Injectee interface.
This annotation is placed on another annotation to indicate that the annotation may be used to indicate an injection point
This class allows users to provide a custom injection target for any annotation (including @Inject).
Archive adapter based on a single InputStream instance.
 
 
This object contains information about a lifecycle event.
 
This describes the type of lifecycle events that can happen in the system
This processor is called for certain events in the lifecycle of instances of services.
Contains information about the caller of a Factory.provide() method
This service is used to get information about the creation of a service from an implementation of Factory.
 
Classes annotated with this qualifier are to be intercepted with the default interception service implementation.
This annotation is placed on an annotation that can be used to indicate a binding between an interceptor (annotated with Interceptor) and a class to be intercepted (annotated with Intercepted).
This service is implemented in order to configure interceptors on methods or constructors provided by hk2 services.
This annotation is placed on an implementation of either MethodInterceptor or ConstructorInterceptor in order to signify that these services should be automatically bound with the default interception service implementation.
This service can be used to modify, add or remove interceptors to the set of interceptors that will be called on a Method or Constructor in the default implementation of the interception service.
Represents an interface declaration.
Implementation of an interface model
 
 
This object can be injected rather than Provider when it is desired to iterate over more than one returned instance of the type.
 
 
 
 
Abstraction of JarFile so that we can handle both a jar file and a directory image transparently.
 
 
Jar based archive abstraction
The JustInTimeInjectionResolver is called when an injection point cannot find anything to inject.
 
Imagine that this is an interface with a lot of methods on it
Modules that wish to invoke special logic when it is loaded, started or stopped should implement this interface.
Non locked based linked queue.
 
 
A logger for HK2.
The logging relataed methods have been refactored out of Utils class which exists in impl module.
A cache that contains a certain number of entries, and whose oldest accessed entries are removed when removal is necessary.
LRU Cache implementation that relies on entries that keep last hit (get/put) timestamp in order to be able to remove least recently accessed items when running out of cache capacity.
 
 
Hybrid cache that allows explicit removals of included entries as well as implicit removal of entries that have been least recently accessed.
 
Should a cycle be detected during computation of a value for given key, this interface allows client code to register a callback that would get invoked in such a case.
CLI entry point that will setup the module subsystem and delegate the main execution to the first archive in its import list...
This filter matches against the name, including only matching a ModuleStartup with no name if name is null (unlike a normal "null" returned from name, which acts as a wildcard for the name)
 
Constants used in the module manifest.
Implements a manifest proxying
 
A member is a field or method declared on a class or interface
 
This qualifier must be placed on any hk2 descriptor that can receive messages.
This annotation marks a method of an annotation as providing a value that should be placed into the metadata of a Descriptor.
This is the handler that runs the aopalliance method interception
 
 
Model to represent a method declaration
Implementation of a method model
This is used to describe the values to be given to the method in the ServiceLocator.assistedInject(Object, java.lang.reflect.Method, MethodParameter...) method
An implementation of MethodParameter that has immutable position and value
Wraps a java.lang.reflect.Method but has an equals and hashCode that honors the class hierarchy
Wrapper of methods with an equals and hashCode that makes methods hiding other methods be equal
 
convenient class to build model implementations
ASM class visitor, used to build to model
 
 
 
 
 
 
Objects interested in monitoring module changes events should implement this interface
ClassLoader that loads classes for a module.
A module definition contains all information about a module existence, its dependencies and its exported interfaces.
A ModuleDependency instance holds all information necessary to identify a dependency between modules.
Class representing the primary Key for a Module.
A module represents a set of resources accessible to third party modules.
Listener interface that can be registered on the registry to listen to notification of module startup and shutdown.
Holds information about /META-INF/services and /META-INF/inhabitants for a Module.
 
 
 
Interface server startup need to implement
ModuleState define the state of a Module instance.
This exception can contain multiple other exceptions.
Map from a key to multiple values.
Named service binding builder.
This is an implementation of the Named annotation.
 
Matches only things with scope ConfiguredBy and which have no name
 
 
This defines the operations that may be validated
The implementation of Context for an Operation.
 
This handle is used to associate or dis-associate threads with Operations.
 
Unique identifier for an Operation.
 
Manages HK2 operations, allowing the user to create new operations of a particular type or discover the current set of active operations or find the current operation on the current thread
 
Describes the general state of the Operation
Marker annotation indicating that an instance variable or method marked with Inject is not required to be present at run-time.
Creates a filter that matches if at least one of the sub-filters is a match.
Converts the project version into the OSGi format and set that to "project.osgi.version" property.
The list of packages (in "." format, i.e.
Denote a parameter to a method
Representation of a parameterized type
Implementation of the ParameterizedInterfaceModel
 
Parse jar files or directories and create the model for any classes found.
 
Filters the parsing activity to only deeply parse classes that are either annotated with an annotation returned by ParsingConfig.getAnnotationsOfInterest() or implements/subclass a type returned by ParsingConfig.getTypesOfInterest().
Parsing context for parsing jars and directories and getting a classmodel back
Context builder
These utilities are per service locator.
PerLookup is the scope for objects that are created every time they are looked up.
 
PerThread is a scope that operates like Singleton scope, except on a per-thread basis.
 
 
This module can be used to enable the PerThread scope feature.
Useful delegation model for starting a hk2 instance using a service based lookup
Implementations of this interface are used to populate HK2 service locators from inhabitants files
Implementation of the Populator for DynamicConfigurationService
This interface allows the customization of services read in from an external source.
Deprecated.
Classes implementing this interface register an interest in being notified when the instance has been created and the component is about to be place into commission.
A method marked with this annotation will be invoked after to dynamic change have been applied to a service.
Components implementing this interface registers an interest in being notified when they are about to be decommissioned.
A method marked with this annotation will be invoked prior to dynamic changes being applied to a service.
 
Instances of classes implementing this contract can be registered with HK2 to be informed when the system starts progressing to a new level, either upward or downward
This bean configures the PropertyFileService itself.
This handle is used to read property files and put the values into the HK2 configuration hub.
 
 
This service will read a java property file and add its contents to the HK2 configuration hub.
 
This utility should be used when initializing hk2 in order to properly add the PropertyFileService to a specific registry
Scope annotations that are also marked with this annotation are proxiable.
 
Every proxy generated by HK2 will implement this interface, which can be used to have finer control on the behavior of the proxy
This annotation is used when automatically analyzing a class or a {link Factory.provide() method to indicate that the descriptor either should or should use a proxy when being injected into a service from the same scope.
Creates a Module implementation based on a single class loader
Creates a ModuleDefinition backed up by a a single classloader.
Utilities around proxying
 
 
This annotation is used to provide the initial rank of a service marked with Service.
 
 
A Repository instance is an abstraction of a set of accessible modules.
Listener interface to listen to repository changes.
Registry for RepositoryFactory instances
Factory to create repositories.
Thrown to indicate that a module dependency could not be satisfied
This class provides helper methods to look up resources that are part of OSGi bundles, but can't be exported.
 
Interface to load .class files as resources for processing by the parser.
This is an implementation of ErrorService that simply rethrows the exception caught.
Defines a run/start level.
This is the implementation of the Context for the RunLevel scope
A RunLevelContoller controls the current state of services registered in the RunLevel scope.
These are the policies for how the RunLevelController will use threads
This is the implementation of the RunLevelController
Exception related to the operations of the RunLevelController.
This is the Future object that will be returned by the RunLevelController and it contains extra information about the job being done
Instances of classes implementing this contract can be registered with HK2 to be informed of events of RunLevelControllers.
This module can be used to enable the RunLevelService in a system not using automatic service discovery.
Utilities for using the RunLevelService
 
Scoped service binding builder.
Scoped and named service binding builder.
Data structure concerning scope annotations
 
This annotation is placed on an injection point that is to be injected with the ActiveDescriptor that was used to create the instance.
Annotation placed on classes that are to be automatically added to an hk2 ServiceLocator.
Service binding builder.
This service handle can be used to get a specific instance of a service, and can be used to destroy that service as well
 
This handle does the underlying work of getting the service.
This is a gateway to OSGi bundles as far as META-INF/services files are concerned.
 
 
 
List of ServiceLoaderImpl.ProvidersPerBundle Synchronisation is handled by outer class.
Map of service name to provider names for a particular bundle
ServiceLocator is the registry for HK2 services
This factory can be used to create new named ServiceLocators
Tells the create method what to do if an existing ServiceLocator with the given name exists
The implementation of the ServiceLocatorFactory that looks in the OSGi service registry or the META-INF/services for the implementation to use.
 
An implementation of this class can be placed in META-INF/services in order to customize the creation of the ServiceLocator
 
 
 
 
 
This is added to the ServiceLocatorFactory in order to listen on service locators coming and going.
Runtime information about the ServiceLocator.
 
The possible states in which a service locator can be in.
An ExternalResource (and a Binder) that sets up and tears down an HK2 ServiceLocator on a per-test-class or per-test-method basis.
An enum describing possible ServiceLocator isolation levels for JUnit tests.
A very, very special-purpose ClassVisitorImpl suitable only for use by the ServiceLocatorTestRule class to determine efficiently whether a given Class is annotated with Service or not.
This is a set of useful utilities for working with ServiceLocator.
 
 
 
 
 
 
The entry point for service @Service annotations
This is a comparator making things that don't really compare, compare.
 
The class file for this must be copied into resources if this should change
 
 
 
 
 
 
 
 
Signature visitor to visit parameterized declarations
This is marked with the Contract annotation but will not be added, since the service is using
invalid reference
ContractsProvided
This interface is not originally listed as a contract but it will be added to the set of contracts via ContractsProvided
This cache can be used in some circumstances when there can be only one of a service.
Normal modules registry with configuration handling backed up by a single class loader.
 
 
 
Keeps information (softly) about annotations
 
Contract for sorting descriptors for run level services.
This is a filter that matches an exact descriptor
A filter that gets everything! w00t w00t!
This class contains important information about the startup process.
Implementation of the modules registry that use a single class loader to load all available classes.
This should be the type of entity that is used in the service generated due to the
invalid reference
GenerateServiceFromMethod
annotation
When this annotation is placed on an abstract class the methods of the class that are abstract will be generated into a subclass by the hk2-metadata-generator along with an empty Service annotation
 
 
 
 
This annotation is put onto one parameter of a method to indicate that this method should be called whenever a Topic sends a message.
 
This is an implementation of Injectee that is used by the system.
Generates inhabitant
This ties the given object with the thread upon which this object is created This class can be used as the key in a hashSet if the incoming object can be used as the key in a hashSet
 
JDK5-friendly string tokenizer.
This service is used for publishing events to subscribers.
This module can be used to enable the default HK2 implementation of Topic distribution.
This service is responsible for distributing messages to Topic subscribers
 
 
hk2 and modules usage tracing utilities.
 
Nested, nested and not-nested
 
 
 
Implementations of this interface can be added to a DynamicConfiguration in order to atomically participate in the changes being made to the ServiceLocator.
 
 
A type defines java type which can be an interface or a class.
A type contains (possibly) multiple instances of a configuration bean
Plug-able interface to build type
This class contains various utilities for ensuring java type safety
Implementation of the Type abstraction.
 
Supports inline instantiation of objects that represent parameterized types with actual type parameters.
Proxy for types, used in place until the type can be properly instantiated.
 
Represents the result of a parsing activity.
contains all the parsed types references.
 
Results of a parsing activity, all java resources are inventoried in three main categories : classes, interfaces and annotations with cross references
This annotation must go on a scope annotation in order to indicate that no services from this scope may be proxied.
An injection point can be annotated with @Unqualified if it should only be injected with services that have no qualifiers at all
This is an implementation of Unqualified.
This exception will be found in a MultiException when a class has a dependency that should be satisfied but cannot be.
 
This annotation is used when automatically analyzing a class or a {link Factory.provide() method to indicate that the descriptor either should or should not use a proxy.
 
Run level service related utilities.
 
This class contains a set of static utilities useful for implementing HK2
 
 
 
 
The return type from getAllInterceptors
 
 
 
This object contains information about the validation point.
 
This service can be used to add validation points to Descriptors.
This method is called when it determined that a type that is annotated with a Validating annotation is to be injected into any other class.
 
 
This annotation is used when automatically analyzing a class or a {link Factory.provide() method to indicate that the descriptor either should or should not have LOCAL visibility.
A Marker or tag exception for services caught by a cancellation
A cache that uses the CAR algorithm to remove entries.
Implements the CAR algorithm as found here: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.105.6057
 
This is a clock (if non-empty the next verb will always return a new value in a cycle) that can also get values in O(1) complexity.
Implementation of WeakHashClock as needed by the CAR algorithm
 
An implementation of the WeakHashLRU as needed by the CAR algorithm
Finds out where a class file is loaded from.
 
A writeable version of a BeanDatabase.