All Classes

Class	Description
AbstractActiveDescriptor<T>	This class can be used as a starting point for those writing their own ActiveDescriptor.
AbstractAdapter	Common archive adapter implementation
AbstractAnnotationVisitorImpl	This just makes the main-line code less messy
AbstractBaseService
AbstractBaseService.InnerEnum
AbstractBaseService.InnerInterface
AbstractBinder	Skeleton implementation of injection binder with convenience methods for binding definitions.
AbstractClassVisitorImpl
AbstractComplexFactory<E,F,G,H>
AbstractFactory
AbstractFactory<A,B,C,D>	This is an abstract factory, the true type will comd from the concrete class
AbstractInhabitantsGeneratorMojo	Abstract Mojo for inhabitant generator
AbstractMethodVisitorImpl	This in only here to keep the main-line code less messy
AbstractModulesRegistryImpl	The Modules Registry maintains the registry of all available module.
AbstractRepositoryImpl	Partial implementation of Repository that statically enumerates all ModuleDefinition upfront.
Activator	This activator initializes ServiceLoader with an appropriate instance.
ActiveDescriptor<T>	An ActiveDescriptor contains information about a Descriptor after it has been reified.
ActiveDescriptorBuilder	The active descriptor build is for building up a non-reified ActiveDescriptor.
ActiveDescriptorBuilderImpl
AdapterIterator<T,U>	Iterator implementation that works as a filter to another iterator.
AliasDescriptor<T>	An active descriptor class that serves as an alias for another descriptor.
AnnotatedElement	An annotated element is a java declaration that can be annotated.
AnnotatedElementImpl	Implementation of an annotated element
AnnotationLiteral<T extends Annotation>	Supports inline instantiation of annotation type instances.
AnnotationModel	Models an annotation instance
AnnotationModelImpl	Model a annotation instance
AnnotationType	Represents an annotation
AnnotationTypeImpl	Implementation of an annotation model
AOPProxyCtl	This interface is implemented by all services that use the AOP Alliance Interceptor feature of HK2.
ArchiveAdapter	adapter for reading archive style structure
ArchiveAdapter.Entry	Definition of an archive entry
ArchiveAdapter.EntryTask	defines the notion of an archive entry task which is a task aimed to be run on particular archive entry.
ArchiveAdapter.Selector
ArchiveSelector	An archive selector allows the user to select if an archive should be parsed by the parser engine.
ArgumentManager	API -- For now sticking with the draft1 API and behavior This class will be handy for fixing error detection of bad input as below.
AsyncRunLevelContext
AutoActiveDescriptor<T>
BeanDatabase	A database of beans organized as types, where a type can have multiple instances of a configuration bean
BeanDatabaseImpl
BeanDatabaseUpdateListener	This is a listener that is notified when changes are made to the current BeanDatabase
BeanInfo
BeanReflectionHelper
BeanUtilities	For JavaBean or Bean-Like-Map utilities
Binder	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.
BindingBuilder<T>	Base binding builder (marker) interface.
BindingBuilderFactory	HK2 injection binding utility methods.
Blue	The class file for this must be copied into resources if this should change
BootException	Signals a fatal error in the module system launch.
BuilderHelper	This class is used to generate DescriptorBuilders to be used as a simple mechanism to create a Filter or Descriptor.
ByteArrayInhabitantsDescriptor	Implementation of InhabitantsDescriptor that loads the inhabitants meta-data from a byte array (usually coming from a inhabitant file).
Cache<K,V>	Cache implementation that relies on FutureTask.
Cache.CycleHandler<K>	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.
CacheEntry	This can be used to remove a specific cache entry from the cache, for better control of the caching release semantics
CacheKey	This is the cache key, which encapsulates very specific lookup queries.
CacheKeyFilter<K>	This is used by the cache to remove a series of entries that match this filter
CacheUtilities	Utilities for creating caches
Change	This represents a single change made to a BeanDatabase
Change.ChangeCategory
ChangeableRunLevelFuture
ChangeImpl
ChildInject	This Injection point indicator can be used for services that have a hierarchical names.
ChildInjectResolverImpl
ChildIterable<T>	This interface can be used in conjunction with the ChildInject annotation to get the current list of children for this injection point
ChildIterableImpl<T>
ClassAnalyzer	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.
Classes	A set of classes that should be analyzed as services, whether they declare @Service or not.
ClassLoaderPostProcessor	This is a PopulatorPostProcessor that adds an HK2Loader based on a ClassLoader.
ClassLoaderProxy	ClassLoaderProxy capable of loading classes from itself but also from other class loaders
ClassModel	Model that represents a class
ClassModelActivator	Created with IntelliJ IDEA.
ClassModelImpl	Implementation of a class model
ClassPathBasedModulesRegistry	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)
ClasspathDescriptorFileFinder	Deprecated. Use org.glassfish.hk2.utilities.ClasspathDescriptorFileFinder
ClasspathDescriptorFileFinder	This is an implementation of DescriptorFileFinder that uses a particular classloader in order to find descriptor files.
ClassReflectionHelper	An interface representing useful reflection utilities
ClassReflectionHelperImpl
ClassReflectionHelperUtilities
ClassVisitorImpl
ClassVisitorImpl
ClazzCreator<T>
Closeable	A closeable object is one that can be closed once, and can not be opened again
Collector	This class collects errors, and can then also produce a MultiException from those errors if necessary
CommitFailedException	All exceptions from BeanDatabaseUpdateListener.commitDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List) are wrapped in this exception
CommonModelRegistry
ComplexA
ComplexB	This one is NOT a contract
ComplexC
ComplexD	Not a contract
ComplexDImpl	Is a contract
ComplexE
ComplexEImpl	Not a contract but implements a contract
ComplexF
ComplexFactory	A factory thar produces a complex object type
ComplexG
ComplexImpl	Not annotated with @Service but is produced by a factory
CompositeEnumeration	We need a compound enumeration so that we can aggregate the results from various delegates.
Computable<K,V>	Utility interface to capture generic computation of type V from type K.
ComputationErrorException	This exception should be thrown from the Computable.compute(Object) method if the returned computation should NOT be kept in the cache.
ConcreteComplexFactory<A,B>
ConcreteFactory<F>	The class that corresponds to the Factory provide method is not first, it is not last, it is somewhere in the middle (the Integer)
ConfigPopulator	Basic interface for populating a service locator with configuration data
ConfigurationListener
ConfigurationUtilities	Useful utilities for using the hk2 configuration system
ConfigurationValidationService
Configured	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.
ConfiguredBy	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
ConfiguredBy.CreationPolicy
ConfiguredByContext
ConfiguredByInjectionResolver
ConfiguredValidator
ConstantActiveDescriptor<T>
ConstantActiveDescriptor<T>
Constants
Constants
ConstructorAction	This represents the action used in order to create an object.
ConstructorInterceptorHandler
Context<T>	An implementation of this must be put into the system in order to create contextual instances of services.
ContextDuplicatePostProcessor	Deprecated. Use DuplicatePostProcessor instead
ContextualInput<T>	Used by several contexts for keeping the inputs of Context.findOrCreate(ActiveDescriptor, ServiceHandle).
Contract	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
ContractIndicator	This annotation is put on annotations that are used to mark things as hk2 contracts.
ContractsProvided	An explicit list of contracts provided.
ContractsProvidedService	This service uses the ContractsProvided annotation
CookedLibRepository
CookedModuleDefinition
Creator<T>	An internal interface that allows us to have the factory and class implementations
CrossOverDescriptor<T>
CurrentlyRunningException	This exception is thrown by proceedTo if there is currently a job being run when proceedTo is called
CurrentTaskFuture	This is the implementation of RunLevelFuture.
CurrentTaskFutureWrapper	This object is used to wrap the internal CurrentTaskFuture which is a ChangeableRunLevelFuture.
CustomAnalysisService	This service has a custom analyzer
Customize	Indicates that a method should be customized.
Customizer	Gives the type (and optional name) of a customizer service to use when an unknown method on a bean interface is encountered.
DefaultClassAnalyzer	this is the default implementation of the ClassAnalyzer
DefaultInterceptionService	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
DefaultModuleDefinition	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.
DefaultTopicDistributionErrorService	When using the TopicDistributionService added with ServiceLocatorUtilities.enableTopicDistribution(org.glassfish.hk2.api.ServiceLocator) if a subscriber throws an exception this service will be called.
DefaultTopicDistributionService	This is the default implementation of the TopicDistributionService.
DelegatingNamedActiveDescriptor
Descriptor	A Descriptor is a bean-like structure that describes a service declaration in HK2.
DescriptorBuilder	This is an object that uses the Builder pattern in order to generate a Descriptor (for binding) or a Filter (for searching).
DescriptorBuilderImpl	This is a simple implementation of the DescriptorBuilder
DescriptorComparator
DescriptorComparitor	This is a comparator making things that don't really compare, compare.
DescriptorFileFinder	Implementations of this interface allow the customization of how hk2 inhabitant files are found.
DescriptorFileFinder	Deprecated. use DescriptorFileFinder instead
DescriptorFileFinderInformation	Returns information about the InputStream returned by DescriptorFileFinder.findDescriptorFiles() that can be used to give better information when one of the streams fails.
DescriptorImpl	The implementation of the descriptor itself, with the bonus of being externalizable, and having writeable fields
DescriptorType	This describes the type of descriptor
DescriptorVisibility	This enumeration determines how visibility of a descriptor
DirectoryArchive	Directory base archive abstraction
DirectoryBasedRepository	This class is a directory based repository implementation.
DoubleNode<K,V>	Used for doubly linked lists with weak keys
DuplicatePostProcessor	This post-processor removes duplicate descriptors from the set of descriptors being added to the service registry.
DuplicatePostProcessorMode	The mode of the duplicate post processor
DuplicateServiceException	This exception is thrown when an idempotent filter of a DynamicConfiguration object matches an existing descriptor in the ServiceLocator
DynamicConfiguration	This class is used to add Descriptors to a ServiceLocator instance.
DynamicConfigurationImpl	The system implementation of the DynamicConfiguration service
DynamicConfigurationListener	A service that listens for dynamic configuration changes.
DynamicConfigurationService	The dynamic configuration service is the source of DynamicConfiguration instances, which can be used to bind and unbind entities into the system
DynamicConfigurationServiceImpl
Dynamicity	Describes how dynamic a configured field or parameter should be
EarlyLogHandler
EnableLookupExceptionsModule	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.
ErrorInformation	This class has information in it about the error that has occurred
ErrorInformation
ErrorInformation.ErrorAction	The set of actions that the system can perform when an error is detected
ErrorInformationImpl
ErrorInformationImpl
ErrorResults
ErrorService	This interface should be implemented by those who wish to be notified of error conditions that occur within HK2.
ErrorServiceImpl
ErrorType	This enumeration describes the types of errors that might occur
Excludes	A set of implementations that should be excluded from being added to testLocator.
ExtensibleType<T extends ExtensibleType>	An extensible type is a type that can be subclassed like an interface or a class.
ExtensibleTypeImpl<T extends ExtensibleType>	Implementation of an extensible type (Class or Interface)
ExtrasUtilities	These are utilities for the extra features of hk2.
Factory<T>	This interface should be implemented in order to provide a factory for another type.
FactoryCreator<T>
FactoryDescriptors	This is a convenience class that links together the factory descriptor as a factory for another type and the factory as a service itself.
FactoryDescriptorsImpl	This is an implementation of FactoryDescriptors that can be used by hk2 uses when creating descriptors that describe a Factory
FactoryWithDefaultProxy
FactoryWithDefaultProxyForSameScope
FactoryWithFalseProxy
FactoryWithFalseProxyForSameScope
FactoryWithRanks
FactoryWithVisibility
FieldModel	Model that represent the field of a class
FieldModelImpl	Implementation of a field model
Filter	This object is used to search for items in the service registry
FlattenEnumeration<T>	Equivalent of FlattenIterator for enumeration
FlattenIterator<T>	Iterator implementation that works like Lisp "flatten" function.
GeneralUtilities	This class contains utilities useful for any code
GenerateMethodAnnotationData
GeneratorRunner
GenericArrayTypeImpl	An implementation of GenericArrayType for those times we need to create this on the fly
GivenNameFromQualifier	This should have the default scope of singleton (default for services with @Service anyway).
GreedyDefaultImplementation	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
GreedyResolver	This is a greedy resolve that will add in any class that has failed to be resolved.
HabitatGenerator	This is a command line (or embedded) utility that will generate habitat files based on @Service annotations.
HandleAndService	Data structure with the handle and the service
Hk2BridgeImpl
HK2Exception	Base class for HK2 defined checked exceptions
HK2Factory
HK2GenerateMojo	Generates a consolidated OSGI bundle with a consolidated HK2 header
HK2InhabitantGeneratorTask
HK2Invocation	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.
HK2JmxSpecifier	This service must be implemented in order to specify those descriptors that might be reflected into JMX
HK2Loader	This class is responsible for loading classes, and different implementations can be used for different descriptors.
HK2LoaderImpl	This is an implementation of an HK2Loader that uses a given classloader
Hk2LoaderPopulatorPostProcessor	A Simple PopulatorPostProcessor that uses the given classloader to override default HK2Loader behavior
Hk2LocatorUtilities	This is a utility class specific to this implementation of the hk2 API
HK2Populator
HK2Runner	This class should be extended by test classes in order to get an automatically filled in ServiceLocator.
HK2RuntimeException	Base class for HK2 defined runtime exceptions
HK2TestModule
HK2TestUtilities	These are other useful test utilities that can be used
Hk2ThreadLocal<T>	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.
Hub	The central repository of configuration objects in the system.
HubImpl
HybridCacheEntry<V>	Represents a single hybrid cache entry.
Immediate	Immediate is a scope that operates like Singleton scope, except that instances are created as soon as their corresponding Descriptors are added.
ImmediateContext	This is the Context implementation for the Immediate scope
ImmediateController	This service is advertised when the Immediate service is put into the registry.
ImmediateController.ImmediateServiceState
ImmediateErrorHandler	Implementations of this service will be called whenever an Immediate scoped service fails
ImmediateHelper	The implementation of the immediate context.
ImmediateLocalLocatorFilter	Filter only picks up local services
ImmediateResults	This contains the local portion of the narrowed result
ImmediateScopeModule	This module can be used to enable the Immediate scope feature.
ImportPolicy	Modules that wish to programmatically control their list of imports can implement this interface.
IndentingXMLStreamWriter
IndexedFilter	This filter can be used to limit the set of Descriptors passed to the matches method.
IndexedFilterImpl	Implementation created by the builder
IndexedListData	This object contains a list of values.
InFlightGenerator	Allows an installer or other jar combiner to be able to scan multiple directories for HK2 services
InFlightGeneratorImpl
InhabitantAnnotation	Meta-annotation indicating that the annotation designates a resident service of a ServiceLocator.
InhabitantFiles	A set of locator inhabitant files to search for in the classpath.
InhabitantsBuilder	This is the builder for the Eclipse inhabitants generator project
InhabitantsDescriptor	Inhabitants Descriptor is an abstraction on how the inhabitants are represented in a module.
InhabitantsGeneratorMojo	Generates inhabitant
InheritableThread	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.
InheritableThreadContext
InheritableThreadScopeModule	This module can be used to enable the InheritableThread scope feature.
Injectee	An Injectee represents the point of injection.
InjecteeImpl	This is a writeable version of the Injectee interface.
InjectionPointIndicator	This annotation is placed on another annotation to indicate that the annotation may be used to indicate an injection point
InjectionResolver<T>	This class allows users to provide a custom injection target for any annotation (including @Inject).
InputStreamArchiveAdapter	Archive adapter based on a single InputStream instance.
Instance
InstanceImpl
InstanceLifecycleEvent	This object contains information about a lifecycle event.
InstanceLifecycleEventImpl
InstanceLifecycleEventType	This describes the type of lifecycle events that can happen in the system
InstanceLifecycleListener	This processor is called for certain events in the lifecycle of instances of services.
InstantiationData	Contains information about the caller of a Factory.provide() method
InstantiationService	This service is used to get information about the creation of a service from an implementation of Factory.
InstantiationServiceImpl
Intercepted	Classes annotated with this qualifier are to be intercepted with the default interception service implementation.
InterceptionBinder	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).
InterceptionService	This service is implemented in order to configure interceptors on methods or constructors provided by hk2 services.
Interceptor	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.
InterceptorOrderingService	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.
InterfaceModel	Represents an interface declaration.
InterfaceModelImpl	Implementation of an interface model
InterfaceWithOneType<T>
InterfaceWithTwoTypes<V,T>
IterableProvider<T>	This object can be injected rather than Provider when it is desired to iterate over more than one returned instance of the type.
IterableProviderImpl<T>
Jar	Abstraction of JarFile so that we can handle both a jar file and a directory image transparently.
JarArchive	Jar based archive abstraction
JustInTimeInjectionResolver	The JustInTimeInjectionResolver is called when an injection point cannot find anything to inject.
JustInTimeInjectionResolverImpl
LargeInterface	Imagine that this is an interface with a lot of methods on it
LifecyclePolicy	Modules that wish to invoke special logic when it is loaded, started or stopped should implement this interface.
LinkedQueue<E>	Non locked based linked queue.
LocalService
Logger	A logger for HK2.
LogHelper	The logging relataed methods have been refactored out of Utils class which exists in impl module.
LRUCache<K,V>	A cache that contains a certain number of entries, and whose oldest accessed entries are removed when removal is necessary.
LRUCacheCheapRead<K,V>	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.
LRUHybridCache<K,V>	Hybrid cache that allows explicit removals of included entries as well as implicit removal of entries that have been least recently accessed.
LRUHybridCache.CycleHandler<K>	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.
Main	CLI entry point that will setup the module subsystem and delegate the main execution to the first archive in its import list...
ManagerUtilities
ManifestConstants	Constants used in the module manifest.
ManifestProxy	Implements a manifest proxying
ManifestProxy.SeparatorMappings
Member	A member is a field or method declared on a class or interface
Member.Type
MessageReceiver	This qualifier must be placed on any hk2 descriptor that can receive messages.
Metadata	This annotation marks a method of an annotation as providing a value that should be placed into the metadata of a Descriptor.
MethodInterceptorHandler	This is the handler that runs the aopalliance method interception
MethodInterceptorImpl
MethodInterceptorInvocationHandler
MethodModel	Model to represent a method declaration
MethodModelImpl	Implementation of a method model
MethodParameter	This is used to describe the values to be given to the method in the ServiceLocator.assistedInject(Object, java.lang.reflect.Method, MethodParameter...) method
MethodParameterImpl	An implementation of MethodParameter that has immutable position and value
MethodWrapper	Wraps a java.lang.reflect.Method but has an equals and hashCode that honors the class hierarchy
MethodWrapperImpl	Wrapper of methods with an equals and hashCode that makes methods hiding other methods be equal
MiddleComplexFactory<C,D>
ModelClassVisitor	ASM class visitor, used to build to model
Module
ModuleChangeListener	Objects interested in monitoring module changes events should implement this interface
ModuleDefinition	A module definition contains all information about a module existence, its dependencies and its exported interfaces.
ModuleDependency	A ModuleDependency instance holds all information necessary to identify a dependency between modules.
ModuleId	Class representing the primary Key for a Module.
ModuleImpl	A module represents a set of resources accessible to third party modules.
ModuleLifecycleListener	Listener interface that can be registered on the registry to listen to notification of module startup and shutdown.
ModuleMetadata	Holds information about /META-INF/services and /META-INF/inhabitants for a Module.
ModuleMetadata.Entry
ModulesRegistry
ModulesRegistryImpl
ModuleStartup	Interface server startup need to implement
ModuleState	ModuleState define the state of a Module instance.
MultiException	This exception can contain multiple other exceptions.
MultiMap<K,V>	Map from a key to multiple values.
NamedBindingBuilder<T>	Named service binding builder.
NamedImpl	This is an implementation of the Named annotation.
NarrowResults
NormalService
NotUseableLargeInterface
Operation	This defines the operations that may be validated
OperationContext<T extends Annotation>	The implementation of Context for an Operation.
OperationDescriptor<T extends Annotation>
OperationHandle<T extends Annotation>	This handle is used to associate or dis-associate threads with Operations.
OperationHandleImpl<T extends Annotation>
OperationIdentifier<T extends Annotation>	Unique identifier for an Operation.
OperationIdentifierImpl<T extends Annotation>
OperationManager	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
OperationManagerImpl
OperationState	Describes the general state of the Operation
Optional	Marker annotation indicating that an instance variable or method marked with Inject is not required to be present at run-time.
OrFilter	Creates a filter that matches if at least one of the sub-filters is a match.
OsgiVersionMojo	Converts the project version into the OSGi format and set that to "project.osgi.version" property.
Packages	The list of packages (in "." format, i.e.
Parameter	Denote a parameter to a method
ParameterizedInterfaceModel	Representation of a parameterized type
ParameterizedTypeImpl
Parser	Parse jar files or directories and create the model for any classes found.
Parser.Result
ParsingConfig	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().
ParsingContext	Parsing context for parsing jars and directories and getting a classmodel back
ParsingContext.Builder	Context builder
PerLocatorUtilities	These utilities are per service locator.
PerLookup	PerLookup is the scope for objects that are created every time they are looked up.
PerLookupContext
PerThread	PerThread is a scope that operates like Singleton scope, except on a per-thread basis.
PerThreadContext
PerThreadScopeModule	This module can be used to enable the PerThread scope feature.
PlatformMain	Useful delegation model for starting a hk2 instance using a service based lookup
Populator	Implementations of this interface are used to populate HK2 service locators from inhabitants files
PopulatorImpl	Implementation of the Populator for DynamicConfigurationService
PopulatorPostProcessor	This interface allows the customization of services read in from an external source.
PopulatorPostProcessor	Deprecated. use PopulatorPostProcessor instead
PostConstruct	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.
PostDynamicChange	A method marked with this annotation will be invoked after to dynamic change have been applied to a service.
PreDestroy	Components implementing this interface registers an interest in being notified when they are about to be decommissioned.
PreDynamicChange	A method marked with this annotation will be invoked prior to dynamic changes being applied to a service.
PrepareFailedException	All exceptions from BeanDatabaseUpdateListener.prepareDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List) are wrapped in this exception
Pretty
ProgressStartedListener	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
PropertyFileBean	This bean configures the PropertyFileService itself.
PropertyFileHandle	This handle is used to read property files and put the values into the HK2 configuration hub.
PropertyFileHandleImpl
PropertyFileService	This service will read a java property file and add its contents to the HK2 configuration hub.
PropertyFileServiceImpl
PropertyFileUtilities	This utility should be used when initializing hk2 in order to properly add the PropertyFileService to a specific registry
Proxiable	Scope annotations that are also marked with this annotation are proxiable.
ProxiableScope
ProxyCtl	Every proxy generated by HK2 will implement this interface, which can be used to have finer control on the behavior of the proxy
ProxyForSameScope	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.
ProxyModule	Creates a Module implementation based on a single class loader
ProxyModuleDefinition	Creates a ModuleDefinition backed up by a a single classloader.
ProxyUtilities	Utilities around proxying
QualifierWithMetadata
RandomBean
Rank	This annotation is used to provide the initial rank of a service marked with Service.
ReflectionHelper
ReflectionUtilities
Repository	A Repository instance is an abstraction of a set of accessible modules.
RepositoryChangeListener	Listener interface to listen to repository changes.
RepositoryFactories	Registry for RepositoryFactory instances
RepositoryFactory	Factory to create repositories.
ResolveError	Thrown to indicate that a module dependency could not be satisfied
ResourceFinder	This class provides helper methods to look up resources that are part of OSGi bundles, but can't be exported.
ResourceFinderImpl
ResourceLocator	Interface to load .class files as resources for processing by the parser.
RethrowErrorService	This is an implementation of ErrorService that simply rethrows the exception caught.
RollbackFailedException	All exceptions from BeanDatabaseUpdateListener.rollbackDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List) are wrapped in this exception
RunLevel	Defines a run/start level.
RunLevelContext	This is the implementation of the Context for the RunLevel scope
RunLevelController	A RunLevelContoller controls the current state of services registered in the RunLevel scope.
RunLevelController.ThreadingPolicy	These are the policies for how the RunLevelController will use threads
RunLevelControllerImpl	This is the implementation of the RunLevelController
RunLevelException	Exception related to the operations of the RunLevelController.
RunLevelFuture	This is the Future object that will be returned by the RunLevelController and it contains extra information about the job being done
RunLevelListener	Instances of classes implementing this contract can be registered with HK2 to be informed of events of RunLevelControllers.
RunLevelServiceModule	This module can be used to enable the RunLevelService in a system not using automatic service discovery.
RunLevelServiceUtilities	Utilities for using the RunLevelService
ScopedBindingBuilder<T>	Scoped service binding builder.
ScopedNamedBindingBuilder<T>	Scoped and named service binding builder.
ScopeInfo	Data structure concerning scope annotations
ScopeWithMetadata
Self	This annotation is placed on an injection point that is to be injected with the ActiveDescriptor that was used to create the instance.
Service	Annotation placed on classes that are to be automatically added to an hk2 ServiceLocator.
ServiceBindingBuilder<T>	Service binding builder.
ServiceHandle<T>	This service handle can be used to get a specific instance of a service, and can be used to destroy that service as well
ServiceHandleComparator
ServiceHandleImpl<T>	This handle does the underlying work of getting the service.
ServiceLoader	This is a gateway to OSGi bundles as far as META-INF/services files are concerned.
ServiceLoader.ProviderFactory<T>
ServiceLoaderImpl
ServiceLocator	ServiceLocator is the registry for HK2 services
ServiceLocatorFactory	This factory can be used to create new named ServiceLocators
ServiceLocatorFactory.CreatePolicy	Tells the create method what to do if an existing ServiceLocator with the given name exists
ServiceLocatorFactoryImpl	The implementation of the ServiceLocatorFactory that looks in the OSGi service registry or the META-INF/services for the implementation to use.
ServiceLocatorGenerator	An implementation of this class can be placed in META-INF/services in order to customize the creation of the ServiceLocator
ServiceLocatorGeneratorImpl
ServiceLocatorImpl
ServiceLocatorListener	This is added to the ServiceLocatorFactory in order to listen on service locators coming and going.
ServiceLocatorRuntimeBean	Runtime information about the ServiceLocator.
ServiceLocatorRuntimeImpl
ServiceLocatorState	The possible states in which a service locator can be in.
ServiceLocatorTestRule<T>	An ExternalResource (and a Binder) that sets up and tears down an HK2 ServiceLocator on a per-test-class or per-test-method basis.
ServiceLocatorTestRule.ServiceLocatorIsolation	An enum describing possible ServiceLocator isolation levels for JUnit tests.
ServiceLocatorUtilities	This is a set of useful utilities for working with ServiceLocator.
ServiceProcessor	The entry point for service @Service annotations
ServiceUtilities
ServiceWithDefaultName	The class file for this must be copied into resources if this should change
ServiceWithDefaultProxy
ServiceWithDefaultProxyForSameScope
ServiceWithFalseProxy
ServiceWithFalseProxyForSameScope
ServiceWithMetadata
ServiceWithName
ServiceWithRank
ServiceWithTrueProxy
SignatureVisitorImpl	Signature visitor to visit parameterized declarations
SimpleContract	This is marked with the Contract annotation but will not be added, since the service is using ContractsProvided
SimpleInterface	This interface is not originally listed as a contract but it will be added to the set of contracts via ContractsProvided
SingleCache<T>	This cache can be used in some circumstances when there can be only one of a service.
SingleModulesRegistry	Normal modules registry with configuration handling backed up by a single class loader.
SingleOperationManager<T extends Annotation>
SingletonContext
SomeInterface<T>
Sorter	Contract for sorting descriptors for run level services.
SpecificFilterImpl	This is a filter that matches an exact descriptor
StarFilter	A filter that gets everything! w00t w00t!
StartupContext	This class contains important information about the startup process.
StaticModulesRegistry	Implementation of the modules registry that use a single class loader to load all available classes.
StreetAddress	This should be the type of entity that is used in the service generated due to the GenerateServiceFromMethod annotation
Stub	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
Stub.Type
StubProcessor
SubscribeTo	This annotation is put onto one parameter of a method to indicate that this method should be called whenever a Topic sends a message.
SystemDescriptor<T>
SystemInjecteeImpl	This is an implementation of Injectee that is used by the system.
TestInhabitantsGeneratorMojo	Generates inhabitant
ThreadSpecificObject<T>	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
ThreeThirtyResolver
Tokenizer	JDK5-friendly string tokenizer.
Topic<T>	This service is used for publishing events to subscribers.
TopicDistributionModule	This module can be used to enable the default HK2 implementation of Topic distribution.
TopicDistributionService	This service is responsible for distributing messages to Topic subscribers
TopicImpl<T>
Town
TracingUtilities	hk2 and modules usage tracing utilities.
TracingUtilities.Loader
TripleTroubleService	Nested, nested and not-nested
TripleTroubleService.DoubleTroubleService
TripleTroubleService.DoubleTroubleService.SingleTroubleService
TwoContractImpl
TwoPhaseResource	Implementations of this interface can be added to a DynamicConfiguration in order to atomically participate in the changes being made to the ServiceLocator.
TwoPhaseTransactionData
TwoPhaseTransactionDataImpl
Type	A type defines java type which can be an interface or a class.
Type	A type contains (possibly) multiple instances of a configuration bean
TypeBuilder	Plug-able interface to build type
TypeChecker	This class contains various utilities for ensuring java type safety
TypeImpl	Implementation of the Type abstraction.
TypeImpl
TypeLiteral<T>	Supports inline instantiation of objects that represent parameterized types with actual type parameters.
TypeProxy<T extends Type>	Proxy for types, used in place until the type can be properly instantiated.
TypeProxy.Notifier<T>
Types	Represents the result of a parsing activity.
TypesCtr	contains all the parsed types references.
TypesCtr.ProxyTask
TypesImpl	Results of a parsing activity, all java resources are inventoried in three main categories : classes, interfaces and annotations with cross references
Unproxiable	This annotation must go on a scope annotation in order to indicate that no services from this scope may be proxied.
Unqualified	An injection point can be annotated with @Unqualified if it should only be injected with services that have no qualifiers at all
UnqualifiedImpl	This is an implementation of Unqualified.
UnsatisfiedDependencyException	This exception will be found in a MultiException when a class has a dependency that should be satisfied but cannot be.
URLDescriptorFileFinder
UseProxy	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.
Utilities
Utilities	Run level service related utilities.
Utilities
Utilities	This class contains a set of static utilities useful for implementing HK2
Utilities.Interceptors	The return type from getAllInterceptors
Utils
ValidationInformation	This object contains information about the validation point.
ValidationInformationImpl
ValidationService	This service can be used to add validation points to Descriptors.
Validator	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.
Version
Version.COMPONENT
Visibility	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.
WasCancelledException	A Marker or tag exception for services caught by a cancellation
WeakCARCache<K,V>	A cache that uses the CAR algorithm to remove entries.
WeakCARCacheImpl<K,V>	Implements the CAR algorithm as found here: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.105.6057
WeakHashClock<K,V>	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.
WeakHashClockImpl<K,V>	Implementation of WeakHashClock as needed by the CAR algorithm
WeakHashLRU<K>
WeakHashLRUImpl<K>	An implementation of the WeakHashLRU as needed by the CAR algorithm
Which	Finds out where a class file is loaded from.
WouldBlockException
WriteableBeanDatabase	A writeable version of a BeanDatabase.
WriteableBeanDatabaseImpl
WriteableType
WriteableTypeImpl
ZipCode