All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
| 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.
|
| AbstractBindingBuilder<T> |
Abstract binding builder implementation.
|
| AbstractBindingBuilder.ClassBasedBindingBuilder<T> |
|
| AbstractBindingBuilder.FactoryInstanceBasedBindingBuilder<T> |
|
| AbstractBindingBuilder.FactoryTypeBasedBindingBuilder<T> |
|
| AbstractBindingBuilder.InstanceBasedBindingBuilder<T> |
|
| 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 |
|
| 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 |
|
| ActiveDescriptorBuilderImpl.BuiltActiveDescriptor<T> |
|
| 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.
|
| AnnotatedElementAnnotationInfo |
Keeps information about element and parameter annotations
|
| AnnotatedElementImpl |
Implementation of an annotated element
|
| AnnotationLiteral<T extends java.lang.annotation.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 |
|
| AsyncRunLevelContext.RunLevelControllerThread |
|
| AsyncRunLevelContext.RunLevelThreadFactory |
|
| 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 |
|
| 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 |
|
| Change.ChangeCategory |
|
| ChangeableRunLevelFuture |
|
| ChangeImpl |
|
| ChildFilter |
|
| 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.
|
| ClassLoaderFacade |
|
| ClassLoaderPostProcessor |
|
| 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.
|
| 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 |
|
| ClassReflectionHelperImpl.LifecycleKey |
|
| ClassReflectionHelperUtilities |
|
| ClassVisitorImpl |
|
| ClassVisitorImpl |
|
| ClassVisitorImpl.DecorateData |
|
| ClassVisitorImpl.GeneratedNameMethodFinderVisitor |
|
| ClassVisitorImpl.MethodRankAnnotationVisitor |
|
| ClassVisitorImpl.MethodUseProxyAnnotationVisitor |
|
| ClassVisitorImpl.MethodVisibilityAnnotationVisitor |
|
| ClassVisitorImpl.NamedAnnotationVisitor |
|
| ClazzCreator<T> |
|
| ClazzCreator.ResolutionInfo |
|
| 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 |
|
| 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 |
|
| ConfigurationListener.DescriptorListener |
|
| ConfigurationListener.ModificationInformation |
|
| 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.
|
| ConstructorActionImpl<T> |
|
| ConstructorInterceptorHandler |
|
| ConstructorInterceptorHandler.ConstructorInvocationImpl |
|
| Context<T> |
An implementation of this must be put into the system in order to
create contextual instances of services.
|
| ContextDuplicatePostProcessor |
Deprecated.
|
| ContextualInput<T> |
|
| 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 |
|
| 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.
|
| CurrentTaskFuture.AllTheWay |
|
| CurrentTaskFuture.CancelTimer |
|
| CurrentTaskFuture.DownQueueRunner |
|
| CurrentTaskFuture.HardCancelDownTimer |
|
| CurrentTaskFuture.QueueRunner |
|
| 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 |
|
| DefaultTopicDistributionService |
This is the default implementation of the TopicDistributionService.
|
| DefaultTopicDistributionService.ActivatorClassKey |
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.
|
| DefaultTopicDistributionService.FireResults |
|
| DefaultTopicDistributionService.SubscriberInfo |
|
| DelegatingClassLoader |
A classloader that delegates first to an optional parent and then to a delegate loader
|
| DelegatingNamedActiveDescriptor |
|
| DelegatingXMLStreamWriter |
Delegating XMLStreamWriter.
|
| 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 |
|
| 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.
|
| DescriptorFileFinderInformation |
|
| 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.
|
| DuplicatePostProcessor.ImplOnlyKey |
Key use for implementation only (along with descriptor
type, otherwise factories eliminate themselves)
|
| 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 |
|
| 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 |
|
| Hk2BridgeImpl.NoLocalNoRemoteFilter |
|
| Hk2BridgeImpl.RemoveFilter |
|
| 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 |
|
| 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.
|
| ImmediateHelper.ImmediateThread |
|
| ImmediateHelper.ImmediateThreadFactory |
|
| 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 |
|
| InheritableThreadContext.InheritableContextThreadWrapper |
|
| InheritableThreadScopeModule |
|
| 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 |
|
| 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> |
|
| IterableProviderImpl.HandleIterable<U> |
|
| IterableProviderImpl.MyHandleIterator<U> |
|
| IterableProviderImpl.MyIterator<U> |
|
| Jar |
Abstraction of JarFile so that we can handle
both a jar file and a directory image transparently.
|
| Jar.Archive |
|
| Jar.Directory |
|
| 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.
|
| LinkedQueue.Node<E> |
|
| 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.
|
| LRUCacheCheapRead.CacheEntryImpl<K,V> |
|
| LRUCacheCheapRead.CacheEntryImplComparator |
|
| 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.CacheEntryImplComparator<K,V> |
|
| 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...
|
| Main.MainFilter |
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)
|
| 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 |
|
| MethodParameterImpl |
|
| 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> |
|
| ModelBuilder |
convenient class to build model implementations
|
| ModelClassVisitor |
ASM class visitor, used to build to model
|
| ModelClassVisitor.AnnotationVisitingContext |
|
| ModelClassVisitor.ClassVisitingContext |
|
| ModelClassVisitor.FieldVisitingContext |
|
| ModelClassVisitor.MemberVisitingContext |
|
| ModelClassVisitor.MethodVisitingContext |
|
| Module |
|
| ModuleChangeListener |
Objects interested in monitoring module changes events should implement
this interface
|
| ModuleClassLoader |
ClassLoader that loads classes for a module.
|
| 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 |
|
| NoNameTypeFilter |
Matches only things with scope ConfiguredBy and which have no name
|
| NormalService |
|
| NotUseableLargeInterface |
|
| Operation |
This defines the operations that may be validated
|
| OperationContext<T extends java.lang.annotation.Annotation> |
The implementation of Context for an Operation. |
| OperationDescriptor<T extends java.lang.annotation.Annotation> |
|
| OperationHandle<T extends java.lang.annotation.Annotation> |
This handle is used to associate or dis-associate threads with
Operations.
|
| OperationHandleImpl<T extends java.lang.annotation.Annotation> |
|
| OperationIdentifier<T extends java.lang.annotation.Annotation> |
Unique identifier for an Operation.
|
| OperationIdentifierImpl<T extends java.lang.annotation.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
|
| ParameterizedInterfaceModelImpl |
|
| ParameterizedTypeImpl |
|
| Parser |
Parse jar files or directories and create the model for any classes found.
|
| Parser.Result |
|
| ParsingConfig |
|
| 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 |
|
| PerThreadContext.PerContextThreadWrapper |
|
| 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.
|
| 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 |
|
| 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 |
|
| PropertyFileHandleImpl.TypeData |
|
| 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 |
|
| RunLevel |
Defines a run/start level.
|
| RunLevelContext |
|
| 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 |
|
| 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
|
| RunLevelServiceUtilities.RunLevelImpl |
|
| 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 |
|
| ServiceLoaderImpl.DefaultFactory<T> |
|
| ServiceLoaderImpl.ProvidersList |
|
| ServiceLoaderImpl.ProvidersPerBundle |
Map of service name to provider names for a particular bundle
|
| 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. |
| ServiceLocatorFactoryImpl.DefaultGeneratorInitializer |
|
| ServiceLocatorGenerator |
An implementation of this class can be placed in META-INF/services
in order to customize the creation of the ServiceLocator
|
| ServiceLocatorGeneratorImpl |
|
| ServiceLocatorImpl |
|
| ServiceLocatorImpl.CheckConfigurationData |
|
| ServiceLocatorImpl.IgdCacheKey |
|
| ServiceLocatorImpl.UnqualifiedIndexedFilter |
|
| ServiceLocatorListener |
|
| 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. |
| ServiceLocatorTestRule.Visitor |
|
| ServiceLocatorUtilities |
|
| ServiceLocatorUtilities.AliasFilter |
|
| ServiceLocatorUtilities.ImmediateImpl |
|
| ServiceLocatorUtilities.InheritableThreadImpl |
|
| ServiceLocatorUtilities.PerLookupImpl |
|
| ServiceLocatorUtilities.PerThreadImpl |
|
| ServiceLocatorUtilities.SingletonImpl |
|
| ServiceProcessor |
The entry point for service @Service annotations
|
| ServiceProcessor.DescriptorComparitor |
This is a comparator making things that don't really compare, compare.
|
| 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 java.lang.annotation.Annotation> |
|
| SingletonContext |
|
| SingletonContext.GenerationComparator |
|
| SoftAnnotatedElementAnnotationInfo |
Keeps information (softly) about annotations
|
| 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 |
|
| StubProcessor.ExecutableElementDuplicateFinder |
|
| StubProcessor.TypeMirrorOutputs |
|
| 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 |
|
| 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 |
|
| 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.AnnotationInformation |
|
| Utilities.ContractMethodVisitor |
|
| Utilities.GenerateServiceFromMethodVisitor |
|
| Utilities.GeneratorNameFinderMethodVisitor |
|
| Utilities.Interceptors |
The return type from getAllInterceptors
|
| Utilities.KnownClassData |
|
| Utilities.MetadataAnnotationVisitor |
|
| 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
|
| WeakCARCacheImpl.CarValue<V> |
|
| 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 |
|
| WriteableBeanDatabaseImpl |
|
| WriteableType |
|
| WriteableTypeImpl |
|
| ZipCode |
|