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
BeanDatabaseFor 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
BeanDatabaseThis 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 pointWhen 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
All exceptions from
BeanDatabaseUpdateListener.commitDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List)
are wrapped in this exceptionThis 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
HubThis 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
annotationAn 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
DescriptorBuilderThis 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.
use
DescriptorFileFinder insteadReturns 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 systemDescribes 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
FactoryModel 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
implementationsThis 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 classloaderA 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 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() methodThis 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...)
methodAn implementation of
MethodParameter that
has immutable position and valueWraps 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
ParameterizedInterfaceModelParse 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.
use
PopulatorPostProcessor insteadClasses 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.
All exceptions from
BeanDatabaseUpdateListener.prepareDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List)
are wrapped in this exceptionInstances 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.All exceptions from
BeanDatabaseUpdateListener.rollbackDatabaseChange(BeanDatabase, BeanDatabase, Object, java.util.List)
are wrapped in this exceptionDefines a run/start level.
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
ContractsProvidedThis 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
GenerateServiceFromMethod annotationWhen 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 annotationThis 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.