org.jvnet.hk2.internal
Class Utilities

java.lang.Object
  extended by org.jvnet.hk2.internal.Utilities

public class Utilities
extends Object

This class contains a set of static utilities useful for implementing HK2

Author:
jwells

Constructor Summary
Utilities()
           
 
Method Summary
static
<T> T
cast(Object o)
          Casts this thing to the given type
static void checkFactoryType(Class<?> factoryClass, Collector collector)
          Checks to be sure the Factory class is ok
static void checkLookupType(Class<?> checkMe)
          Checks that the incoming lookup type is not improper in some way
static
<T> ActiveDescriptor<T>
createAutoDescriptor(Class<T> clazz, ServiceLocatorImpl locator)
          Creates a reified automatically generated descriptor
static Set<Field> findInitializerFields(Class<?> annotatedType, ServiceLocatorImpl locator, Collector errorCollector)
          Will find all the initialize fields in the class
static Set<Method> findInitializerMethods(Class<?> annotatedType, ServiceLocatorImpl locator, Collector errorCollector)
          Get all the initializer methods of the annotatedType.
static Method findPostConstruct(Class<?> clazz, Collector collector)
          Finds the post construct method on this class
static Method findPreDestroy(Class<?> clazz, Collector collector)
          Finds the pre destroy method on this class
static Constructor<?> findProducerConstructor(Class<?> annotatedType, ServiceLocatorImpl locator, Collector collector)
          Validates the constructors of the annotated type and returns the producer for the annotatedType (if there is no valid producer constructor then this method returns null)
static Set<Annotation> fixAndCheckQualifiers(Annotation[] qualifiers, String name)
          This method returns a set of qualifiers from an array of qualifiers.
static Set<Annotation> getAllQualifiers(AnnotatedElement annotatedGuy, String name, Collector collector)
          Returns the full set of qualifier annotations on this class
static List<Injectee> getConstructorInjectees(Constructor<?> c)
          Returns all the injectees for a constructor
static String getDefaultNameFromMethod(Method parent, Collector collector)
          Returns the default name if one can be found.
static Class<?> getFactoryAwareImplementationClass(ActiveDescriptor<?> descriptor)
          This utility will return the proper implementation class, taking into account that the descriptor may be a factory
static Method getFactoryProvideMethod(Class<?> clazz)
          This method will retrieve the provide method from a Factory
static List<Injectee> getFieldInjectees(Field f)
          Returns the injectees for a field
static
<T> T
getFirstThingInList(List<T> set)
          Returns the first thing found in the set
static Type getFirstTypeArgument(Type type)
          Gets the first type argument if this is a parameterized type, otherwise it returns Object.class
static InjectionResolver<?> getInjectionResolver(ServiceLocatorImpl locator, AnnotatedElement annotatedGuy)
          Returns an injection resolver for this AnnotatedElement
static Class<? extends Annotation> getInjectionResolverType(ActiveDescriptor<?> desc)
          Will return the class of the injection resolver annotation type, or null if no injection resolver annotation can be found
static Class<?>[] getInterfacesForProxy(Set<Type> contracts)
          Returns all the interfaces the proxy must implement
static ActiveDescriptor<ServiceLocator> getLocatorDescriptor(ServiceLocator locator)
          Returns a constant ActiveDescriptor for the basic ServiceLocator
static List<Injectee> getMethodInjectees(Method c)
          Returns all the injectees for a constructor
static String getNameFromAllQualifiers(Set<Annotation> qualifiers, AnnotatedElement parent)
          Gets the name from the &46;Named qualifier in this set of qualifiers
static Class<? extends Annotation> getScopeAnnotationType(AnnotatedElement annotatedGuy, Descriptor defaultScope, Collector collector)
          Returns the scope of this thing
static Class<? extends Annotation> getScopeAnnotationType(Class<?> fromThis, Descriptor defaultScope)
          Returns the scope of this thing
static ActiveDescriptor<InjectionResolver<javax.inject.Inject>> getThreeThirtyDescriptor(ServiceLocatorImpl locator)
          Creates a Three Thirty constant active descriptor
static void handleErrors(NarrowResults results, LinkedList<ErrorService> callThese)
          Calls the list of error services for the list of errors
static boolean isAbstract(Member member)
          Returns true if the underlying member is abstract
static boolean isFinal(Member member)
          Returns true if the underlying member is abstract
static boolean isPrivate(Member member)
          Returns true if the underlying member is private
static boolean isProxiableScope(Class<? extends Annotation> scope)
          Returns true if this scope is proxiable
static
<T> T
justCreate(Class<T> createMe, ServiceLocatorImpl locator)
          Just creates the thing, doesn't try to do anything else
static void justInject(Object injectMe, ServiceLocatorImpl locator)
          Just creates the thing, doesn't try to do anything else
static void justPostConstruct(Object postMe)
          Post constructs the given object
static void justPreDestroy(Object preMe)
          Pre Destroys the given object
static Class<?> loadClass(String loadMe, Descriptor fromMe, Collector collector)
          Loads the class using the loader from the given descriptor or the classloader of the utilities class otherwise
static Class<?> loadClass(String implementation, Injectee injectee)
          Load the given class for the given injectee.
static Object makeMe(Constructor<?> c, Object[] args)
          This version of invoke is CCL neutral (it will return with the same CCL as what it went in with)
static Class<?> translatePrimitiveType(Class<?> type)
          Converts the type to its java form, or returns the original
static void validateSelfInjectees(ActiveDescriptor<?> givenDescriptor, List<Injectee> injectees, Collector collector)
          This method validates a list of injectees to ensure that any self injectees have the proper set of requirements.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Utilities

public Utilities()
Method Detail

getFactoryAwareImplementationClass

public static Class<?> getFactoryAwareImplementationClass(ActiveDescriptor<?> descriptor)
This utility will return the proper implementation class, taking into account that the descriptor may be a factory

Parameters:
descriptor - The descriptor (reified and not null) that will be used to find the implementation
Returns:
The real implementation class

checkLookupType

public static void checkLookupType(Class<?> checkMe)
Checks that the incoming lookup type is not improper in some way

Parameters:
checkMe - class to check

translatePrimitiveType

public static Class<?> translatePrimitiveType(Class<?> type)
Converts the type to its java form, or returns the original

Parameters:
type - The type to convert
Returns:
The translated type or the type itself

handleErrors

public static void handleErrors(NarrowResults results,
                                LinkedList<ErrorService> callThese)
Calls the list of error services for the list of errors

Parameters:
results - the results
callThese - the services to call

loadClass

public static Class<?> loadClass(String loadMe,
                                 Descriptor fromMe,
                                 Collector collector)
Loads the class using the loader from the given descriptor or the classloader of the utilities class otherwise

Parameters:
loadMe - The fully qualified class name
fromMe - The descriptor to use for the loader
collector - The error collector to fill in if this returns null
Returns:
null on failure to load (the failure will be added to the collector)

loadClass

public static Class<?> loadClass(String implementation,
                                 Injectee injectee)
Load the given class for the given injectee.

Parameters:
implementation - the impl class name string
injectee - the injectee
Returns:
The class represented by this implementation and injectee

getInjectionResolverType

public static Class<? extends Annotation> getInjectionResolverType(ActiveDescriptor<?> desc)
Will return the class of the injection resolver annotation type, or null if no injection resolver annotation can be found

Parameters:
desc - The reified descriptor to find the injection resolution on
Returns:
The annotation type for this injection resolver

checkFactoryType

public static void checkFactoryType(Class<?> factoryClass,
                                    Collector collector)
Checks to be sure the Factory class is ok

Parameters:
factoryClass - the class to check
collector - the exception collector

createAutoDescriptor

public static <T> ActiveDescriptor<T> createAutoDescriptor(Class<T> clazz,
                                                           ServiceLocatorImpl locator)
                                                throws MultiException,
                                                       IllegalArgumentException
Creates a reified automatically generated descriptor

Parameters:
clazz - The class to create the desciptor for
locator - The service locator for whom we are creating this
Returns:
A reified active descriptor
Throws:
MultiException - if there was an error in the class
IllegalArgumentException - If the class is null

justPreDestroy

public static void justPreDestroy(Object preMe)
Pre Destroys the given object

Parameters:
preMe - pre destroys the thing

justPostConstruct

public static void justPostConstruct(Object postMe)
Post constructs the given object

Parameters:
postMe - post constructs the thing

justInject

public static void justInject(Object injectMe,
                              ServiceLocatorImpl locator)
Just creates the thing, doesn't try to do anything else

Parameters:
injectMe - The object to inject into
locator - The locator to find the injection points with

justCreate

public static <T> T justCreate(Class<T> createMe,
                               ServiceLocatorImpl locator)
Just creates the thing, doesn't try to do anything else

Parameters:
createMe - The thing to create
locator - The locator to find the injection points with
Returns:
The constructed thing, no further injection is performed

getInterfacesForProxy

public static Class<?>[] getInterfacesForProxy(Set<Type> contracts)
Returns all the interfaces the proxy must implement

Parameters:
contracts - All of the advertised contracts
Returns:
The array of contracts to add to the proxy

isProxiableScope

public static boolean isProxiableScope(Class<? extends Annotation> scope)
Returns true if this scope is proxiable

Parameters:
scope - The scope annotation to test
Returns:
true if this must be proxied

getFirstThingInList

public static <T> T getFirstThingInList(List<T> set)
Returns the first thing found in the set

Parameters:
set - The set from which to get the first element
Returns:
the first thing found in the set

getLocatorDescriptor

public static ActiveDescriptor<ServiceLocator> getLocatorDescriptor(ServiceLocator locator)
Returns a constant ActiveDescriptor for the basic ServiceLocator

Parameters:
locator - The service locator to get the ActiveDescriptor for
Returns:
An active descriptor specifically for the ServiceLocator

getThreeThirtyDescriptor

public static ActiveDescriptor<InjectionResolver<javax.inject.Inject>> getThreeThirtyDescriptor(ServiceLocatorImpl locator)
Creates a Three Thirty constant active descriptor

Parameters:
locator - The service locator to get the ActiveDescriptor for
Returns:
An active descriptor specifically for the ServiceLocator

findProducerConstructor

public static Constructor<?> findProducerConstructor(Class<?> annotatedType,
                                                     ServiceLocatorImpl locator,
                                                     Collector collector)
Validates the constructors of the annotated type and returns the producer for the annotatedType (if there is no valid producer constructor then this method returns null)

Parameters:
annotatedType - The type to find the producer constructor
locator - The service locator to use when analyzing constructors
collector - The error collector
Returns:
The producer constructor or null if the type has no valid producer constructor

getFirstTypeArgument

public static Type getFirstTypeArgument(Type type)
Gets the first type argument if this is a parameterized type, otherwise it returns Object.class

Parameters:
type - The type to find the first type argument on
Returns:
If this is a class, Object.class. If this is a parameterized type, the type of the first actual argument

findInitializerMethods

public static Set<Method> findInitializerMethods(Class<?> annotatedType,
                                                 ServiceLocatorImpl locator,
                                                 Collector errorCollector)
Get all the initializer methods of the annotatedType. If there are definitional errors they will be put into the errorCollector (so as to get all the errors at one shot)

Parameters:
annotatedType - The type to find the errors in
locator - The locator to use when analyzing methods
errorCollector - The collector to add errors to
Returns:
A possibly empty but never null set of initializer methods

findInitializerFields

public static Set<Field> findInitializerFields(Class<?> annotatedType,
                                               ServiceLocatorImpl locator,
                                               Collector errorCollector)
Will find all the initialize fields in the class

Parameters:
annotatedType - The class to search for fields
locator - The locator to use when analyzing the class
errorCollector - The error collector
Returns:
A non-null but possibly empty set of initializer fields

isPrivate

public static boolean isPrivate(Member member)
Returns true if the underlying member is private

Parameters:
member - The non-null member to test
Returns:
true if the member is private

isAbstract

public static boolean isAbstract(Member member)
Returns true if the underlying member is abstract

Parameters:
member - The non-null member to test
Returns:
true if the member is abstract

isFinal

public static boolean isFinal(Member member)
Returns true if the underlying member is abstract

Parameters:
member - The non-null member to test
Returns:
true if the member is abstract

getScopeAnnotationType

public static Class<? extends Annotation> getScopeAnnotationType(Class<?> fromThis,
                                                                 Descriptor defaultScope)
Returns the scope of this thing

Parameters:
fromThis - The annotated class or producer method
Returns:
The scope of this class or producer method. If no scope is found will return the dependent scope

getScopeAnnotationType

public static Class<? extends Annotation> getScopeAnnotationType(AnnotatedElement annotatedGuy,
                                                                 Descriptor defaultScope,
                                                                 Collector collector)
Returns the scope of this thing

Parameters:
annotatedGuy - The annotated class or producer method
collector - The error collector
Returns:
The scope of this class or producer method. If no scope is found will return the dependent scope

getInjectionResolver

public static InjectionResolver<?> getInjectionResolver(ServiceLocatorImpl locator,
                                                        AnnotatedElement annotatedGuy)
                                                 throws IllegalStateException
Returns an injection resolver for this AnnotatedElement

Parameters:
locator - The locator to use when finding the resolver
annotatedGuy - The annotated class or producer method
Returns:
The scope of this class or producer method. If no scope is found will return the dependent scope
Throws:
IllegalStateException - If we could not find a valid resolver

getFactoryProvideMethod

public static Method getFactoryProvideMethod(Class<?> clazz)
This method will retrieve the provide method from a Factory

Parameters:
clazz - This class must implement factory
Returns:
The provide method from this class

getNameFromAllQualifiers

public static String getNameFromAllQualifiers(Set<Annotation> qualifiers,
                                              AnnotatedElement parent)
Gets the name from the &46;Named qualifier in this set of qualifiers

Parameters:
qualifiers - The set of qualifiers that may or may not have Named in it
parent - The parent element for which we are searching
Returns:
null if no Named was found, or the appropriate name otherwise

getDefaultNameFromMethod

public static String getDefaultNameFromMethod(Method parent,
                                              Collector collector)
Returns the default name if one can be found. Will only work on classes and methods

Parameters:
parent - The parent annotated element
collector - For errors
Returns:
null if there is no default name (no Named)

getAllQualifiers

public static Set<Annotation> getAllQualifiers(AnnotatedElement annotatedGuy,
                                               String name,
                                               Collector collector)
Returns the full set of qualifier annotations on this class

Parameters:
annotatedGuy - The element we are searching for qualifiers
name - The name this element must have
collector - The error collector
Returns:
A non-null but possibly empty set of qualifiers

getConstructorInjectees

public static List<Injectee> getConstructorInjectees(Constructor<?> c)
Returns all the injectees for a constructor

Parameters:
c - The constructor to analyze
Returns:
the list (in order) of parameters to the constructor

getMethodInjectees

public static List<Injectee> getMethodInjectees(Method c)
Returns all the injectees for a constructor

Parameters:
c - The constructor to analyze
Returns:
the list (in order) of parameters to the constructor

getFieldInjectees

public static List<Injectee> getFieldInjectees(Field f)
Returns the injectees for a field

Parameters:
f - The field to analyze
Returns:
the list (in order) of parameters to the constructor

validateSelfInjectees

public static void validateSelfInjectees(ActiveDescriptor<?> givenDescriptor,
                                         List<Injectee> injectees,
                                         Collector collector)
This method validates a list of injectees to ensure that any self injectees have the proper set of requirements. It adds IllegalArgumentExceptions to the collector if it finds errors

Parameters:
givenDescriptor - The descriptor associated with this injectee, or null if there are none
injectees - The list of injectees to check. Only self injectees are validates
collector - The collector to add any errors to

findPostConstruct

public static Method findPostConstruct(Class<?> clazz,
                                       Collector collector)
Finds the post construct method on this class

Parameters:
clazz - The class to search for the post construct
collector - An error collector
Returns:
The post construct method or null

findPreDestroy

public static Method findPreDestroy(Class<?> clazz,
                                    Collector collector)
Finds the pre destroy method on this class

Parameters:
clazz - The class to search for the pre destroy method
collector - An error collector
Returns:
The pre destroy method or null

makeMe

public static Object makeMe(Constructor<?> c,
                            Object[] args)
                     throws Throwable
This version of invoke is CCL neutral (it will return with the same CCL as what it went in with)

Parameters:
c - the constructor to call
args - The arguments to invoke (may not be null)
Returns:
The return from the invocation
Throws:
Throwable - The unwrapped throwable thrown by the method

fixAndCheckQualifiers

public static Set<Annotation> fixAndCheckQualifiers(Annotation[] qualifiers,
                                                    String name)
This method returns a set of qualifiers from an array of qualifiers. TODO It can also do some sanity checking here (i.e., multiple qualifiers of the same type, that sort of thing)

Parameters:
qualifiers - The qualifiers to convert. May not be null, but may be zero length
name - The name this set of qualifiers must have
Returns:
The set containing all the qualifiers

cast

public static <T> T cast(Object o)
Casts this thing to the given type

Parameters:
o - The thing to cast
Returns:
A casted version of o


Copyright © 2013 Oracle Corporation. All Rights Reserved.