Utilities (ServiceLocator Default Implementation 2.2.0 API)

java.lang.Object
- org.jvnet.hk2.internal.Utilities

```
public class Utilities
extends Object
```
This class contains a set of static utilities useful for implementing HK2

Author:

jwells

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface Utilities.Interceptors
The return type from getAllInterceptors

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Utilities.Interceptors` The return type from getAllInterceptors

Constructor Summary

Constructors
Constructor and Description

Utilities()

Constructors
Constructor and Description
`Utilities()`

Method Summary

Methods
Modifier and Type	Method and Description
`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> AutoActiveDescriptor<T>`	`createAutoDescriptor(Class<T> clazz, ServiceLocatorImpl locator)` Creates a reified automatically generated descriptor
`static <T> T`	`createService(ActiveDescriptor<T> root, Injectee injectee, ServiceLocatorImpl locator, ServiceHandle<T> handle, Class<?> requestedClass)` Creates the service (without the need for an intermediate ServiceHandle to be created)
`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 String`	`getAutoAnalyzerName(Class<?> c)` Gets the analyzer name from the Service annotation
`static ClassAnalyzer`	`getClassAnalyzer(ServiceLocatorImpl sli, String analyzerName, Collector errorCollector)` Returns the class analyzer with the given name
`static <T> Constructor<T>`	`getConstructor(Class<T> implClass, ClassAnalyzer analyzer, Collector collector)` Gets the constructor given the implClass and analyzer.
`static List<Injectee>`	`getConstructorInjectees(Constructor<?> c, ActiveDescriptor<?> injecteeDescriptor)` Returns all the injectees for a constructor
`static String`	`getDefaultNameFromMethod(Method parent, Collector collector)` Returns the default name if one can be found.
`static Type`	`getFactoryProductionType(Class<?> factoryClass)` This method returns the type produced by a factory class
`static Method`	`getFactoryProvideMethod(Class<?> clazz)` This method will retrieve the provide method from a Factory
`static List<Injectee>`	`getFieldInjectees(Field f, ActiveDescriptor<?> injecteeDescriptor)` 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 Set<Field>`	`getInitFields(Class<?> implClass, ClassAnalyzer analyzer, Collector collector)` Gets the initializer fields from the given class and analyzer.
`static Set<Method>`	`getInitMethods(Class<?> implClass, ClassAnalyzer analyzer, Collector collector)` Gets the initializer methods from the given class and analyzer.
`static InjectionResolver<?>`	`getInjectionResolver(ServiceLocatorImpl locator, AnnotatedElement annotatedGuy)` Returns an injection resolver for this AnnotatedElement.
`static InjectionResolver<?>`	`getInjectionResolver(ServiceLocatorImpl locator, Injectee injectee)` Returns an injection resolver for the injectee
`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, ActiveDescriptor<?> injecteeDescriptor)` Returns all the injectees for a constructor
`static Method`	`getPostConstruct(Class<?> implClass, ClassAnalyzer analyzer, Collector collector)` Gets the post construct from the analyzer, checking output
`static Method`	`getPreDestroy(Class<?> implClass, ClassAnalyzer analyzer, Collector collector)` Gets the preDestroy from the analyzer, checking output
`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<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 boolean`	`isUnproxiableScope(Class<? extends Annotation> scope)` Returns true if this scope is unproxiable
`static <T> T`	`justCreate(Class<T> createMe, ServiceLocatorImpl locator, String strategy)` Just creates the thing, doesn't try to do anything else
`static void`	`justInject(Object injectMe, ServiceLocatorImpl locator, String strategy)` Just creates the thing, doesn't try to do anything else
`static void`	`justPostConstruct(Object postMe, ServiceLocatorImpl locator, String strategy)` Post constructs the given object
`static void`	`justPreDestroy(Object preMe, ServiceLocatorImpl locator, String strategy)` 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 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
  - getClassAnalyzer
```
public static ClassAnalyzer getClassAnalyzer(ServiceLocatorImpl sli,
                             String analyzerName,
                             Collector errorCollector)
```
    Returns the class analyzer with the given name
    
    Parameters:
    sli - The ServiceLocator to search in. May not be null
    analyzerName - The name of the analyzer (may be null for the default analyzer)
    errorCollector - A non-null collector of exceptions
    
    Returns:
    The ClassAnalyzer corresponding to the name, or null if none was found
  - getConstructor
```
public static <T> Constructor<T> getConstructor(Class<T> implClass,
                                ClassAnalyzer analyzer,
                                Collector collector)
```
    Gets the constructor given the implClass and analyzer. Checks service output
    
    Parameters:
    implClass - The implementation class (not null)
    analyzer - The analyzer (not null)
    collector - A collector for errors (not null)
    
    Returns:
    null on failure (collector will have failures), non-null on success
  - getInitMethods
```
public static Set<Method> getInitMethods(Class<?> implClass,
                         ClassAnalyzer analyzer,
                         Collector collector)
```
    Gets the initializer methods from the given class and analyzer. Checks service output
    
    Parameters:
    implClass - the non-null impl class
    analyzer - the non-null analyzer
    collector - for gathering errors
    
    Returns:
    a non-null set (even in error cases, check the collector)
  - getInitFields
```
public static Set<Field> getInitFields(Class<?> implClass,
                       ClassAnalyzer analyzer,
                       Collector collector)
```
    Gets the initializer fields from the given class and analyzer. Checks service output
    
    Parameters:
    implClass - the non-null impl class
    analyzer - the non-null analyzer
    collector - for gathering errors
    
    Returns:
    a non-null set (even in error cases, check the collector)
  - getPostConstruct
```
public static Method getPostConstruct(Class<?> implClass,
                      ClassAnalyzer analyzer,
                      Collector collector)
```
    Gets the post construct from the analyzer, checking output
    
    Parameters:
    implClass - The non-null implementation class
    analyzer - The non-null analyzer
    collector - The non-null error collector
    
    Returns:
    The possibly null post-construct method (check the collector for errors)
  - getPreDestroy
```
public static Method getPreDestroy(Class<?> implClass,
                   ClassAnalyzer analyzer,
                   Collector collector)
```
    Gets the preDestroy from the analyzer, checking output
    
    Parameters:
    implClass - The non-null implementation class
    analyzer - The non-null analyzer
    collector - The non-null error collector
    
    Returns:
    The possibly null pre-destroy method (check the collector for errors)
  - 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
  - getFactoryProductionType
```
public static Type getFactoryProductionType(Class<?> factoryClass)
```
    This method returns the type produced by a factory class
    
    Parameters:
    factoryClass - The non-null factory class. May not be null
    
    Returns:
    the type version of what the factory produces. Will not be null
    
    Throws:
    
    MultiException - if there was an error analyzing the class
  - 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> AutoActiveDescriptor<T> createAutoDescriptor(Class<T> clazz,
                                               ServiceLocatorImpl locator)
                                                    throws MultiException,
                                                           IllegalArgumentException,
                                                           IllegalStateException
```
    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
    
    IllegalStateException - If the name could not be determined from the Named annotation
  - justPreDestroy
```
public static void justPreDestroy(Object preMe,
                  ServiceLocatorImpl locator,
                  String strategy)
```
    Pre Destroys the given object
    
    Parameters:
    preMe - pre destroys the thing
    locator - The non-null service locator associated with the operation (for finding the strategy)
    strategy - The strategy to use for analyzing the class
  - justPostConstruct
```
public static void justPostConstruct(Object postMe,
                     ServiceLocatorImpl locator,
                     String strategy)
```
    Post constructs the given object
    
    Parameters:
    postMe - post constructs the thing
    locator - The non-null service locator associated with the operation (for finding the strategy)
    strategy - The strategy to use for analyzing the class
  - justInject
```
public static void justInject(Object injectMe,
              ServiceLocatorImpl locator,
              String strategy)
```
    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
    strategy - The strategy to use for analyzing the class
  - justCreate
```
public static <T> T justCreate(Class<T> createMe,
               ServiceLocatorImpl locator,
               String strategy)
```
    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
    strategy - The strategy to use for analyzing the class
    
    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
  - isUnproxiableScope
```
public static boolean isUnproxiableScope(Class<? extends Annotation> scope)
```
    Returns true if this scope is unproxiable
    
    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<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
  - getAutoAnalyzerName
```
public static String getAutoAnalyzerName(Class<?> c)
```
    Gets the analyzer name from the Service annotation
    
    Parameters:
    c - The class to get the analyzer name from
    
    Returns:
    The name of the analyzer (null for default)
  - 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
    defaultScope - The default scope if none other can be found
    
    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
    defaultScope - The default scope if none other can be found
    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,
                                        Injectee injectee)
                                                 throws IllegalStateException
```
    Returns an injection resolver for the injectee
    
    Parameters:
    locator - The locator to use when finding the resolver
    injectee - Injectee from which the annotation should be extracted
    
    Returns:
    Injection resolver used to resolve the injection for the injectee
    
    Throws:
    
    IllegalStateException - If we could not find a valid resolver
  - getInjectionResolver
```
public static InjectionResolver<?> getInjectionResolver(ServiceLocatorImpl locator,
                                        AnnotatedElement annotatedGuy)
                                                 throws IllegalStateException
```
    Returns an injection resolver for this AnnotatedElement. The method cannot be used for constructors or methods.
    
    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
  - 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,
                                     ActiveDescriptor<?> injecteeDescriptor)
```
    Returns all the injectees for a constructor
    
    Parameters:
    c - The constructor to analyze
    injecteeDescriptor - The descriptor of the injectee
    
    Returns:
    the list (in order) of parameters to the constructor
  - getMethodInjectees
```
public static List<Injectee> getMethodInjectees(Method c,
                                ActiveDescriptor<?> injecteeDescriptor)
```
    Returns all the injectees for a constructor
    
    Parameters:
    c - The constructor to analyze
    injecteeDescriptor - The descriptor of the injectee
    
    Returns:
    the list (in order) of parameters to the constructor
  - getFieldInjectees
```
public static List<Injectee> getFieldInjectees(Field f,
                               ActiveDescriptor<?> injecteeDescriptor)
```
    Returns the injectees for a field
    
    Parameters:
    f - The field to analyze
    injecteeDescriptor - The descriptor of the injectee
    
    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
  - 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
  - createService
```
public static <T> T createService(ActiveDescriptor<T> root,
                  Injectee injectee,
                  ServiceLocatorImpl locator,
                  ServiceHandle<T> handle,
                  Class<?> requestedClass)
```
    Creates the service (without the need for an intermediate ServiceHandle to be created)
    
    Parameters:
    root - The ultimate parent of this operation
    injectee - the injectee we are creating this service for
    locator - The locator to use to find services
    handle - The ServiceHandle (or null if there is none)
    requestedClass - The class for the service we are looking for
    
    Returns:
    The created service

Class Utilities

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Utilities

Method Detail

getClassAnalyzer

getConstructor

getInitMethods

getInitFields

getPostConstruct

getPreDestroy

checkLookupType

translatePrimitiveType

handleErrors

loadClass

loadClass

getInjectionResolverType

getFactoryProductionType

checkFactoryType

createAutoDescriptor

justPreDestroy

justPostConstruct

justInject

justCreate

getInterfacesForProxy

isProxiableScope

isUnproxiableScope

getFirstThingInList

getLocatorDescriptor

getThreeThirtyDescriptor

findProducerConstructor

getFirstTypeArgument

findInitializerMethods

findInitializerFields

isPrivate

isAbstract

isFinal

getAutoAnalyzerName

getScopeAnnotationType

getScopeAnnotationType

getInjectionResolver

getInjectionResolver

getFactoryProvideMethod

getDefaultNameFromMethod

getAllQualifiers

getConstructorInjectees

getMethodInjectees

getFieldInjectees

validateSelfInjectees

findPostConstruct

findPreDestroy

fixAndCheckQualifiers

cast

createService