Class Utilities


  • public class Utilities
    extends java.lang.Object
    This class contains a set of static utilities useful for implementing HK2
    • Field Detail

      • USE_SOFT_REFERENCE_PROPERTY

        private static final java.lang.String USE_SOFT_REFERENCE_PROPERTY
        See Also:
        Constant Field Values
      • USE_SOFT_REFERENCE

        static final boolean USE_SOFT_REFERENCE
      • NOT_INTERCEPTED

        private static final java.util.HashSet<java.lang.String> NOT_INTERCEPTED
      • proxiesAvailable

        private static java.lang.Boolean proxiesAvailable
    • Constructor Detail

      • Utilities

        public Utilities()
    • Method Detail

      • getClassAnalyzer

        public static ClassAnalyzer getClassAnalyzer​(ServiceLocatorImpl sli,
                                                     java.lang.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> java.lang.reflect.Constructor<T> getConstructor​(java.lang.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 java.util.Set<java.lang.reflect.Method> getInitMethods​(java.lang.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 java.util.Set<java.lang.reflect.Field> getInitFields​(java.lang.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 java.lang.reflect.Method getPostConstruct​(java.lang.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 java.lang.reflect.Method getPreDestroy​(java.lang.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)
      • getFactoryAwareImplementationClass

        public static java.lang.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​(java.lang.Class<?> checkMe)
        Checks that the incoming lookup type is not improper in some way
        Parameters:
        checkMe - class to check
      • translatePrimitiveType

        public static java.lang.Class<?> translatePrimitiveType​(java.lang.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,
                                        java.util.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 java.lang.Class<?> loadClass​(java.lang.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 java.lang.Class<?> loadClass​(java.lang.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 java.lang.Class<? extends java.lang.annotation.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
      • getFactoryProductionClass

        private static java.lang.Class<?> getFactoryProductionClass​(ActiveDescriptor<?> descriptor)
        This method returns the class associated with the type of the factory.
        Parameters:
        descriptor - The descriptor (reified and not null) that will be used to find the implementation.
        Returns:
        the CLASS version of what the factory produces. Will not be null.
        Throws:
        MultiException - if there was an error analyzing the class.
      • getFactoryProductionType

        public static java.lang.reflect.Type getFactoryProductionType​(java.lang.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​(java.lang.Class<?> factoryClass,
                                            Collector collector)
        Checks to be sure the Factory class is ok
        Parameters:
        factoryClass - the class to check
        collector - the exception collector
      • hasContract

        private static boolean hasContract​(java.lang.Class<?> clazz)
      • getAutoAdvertisedTypes

        private static java.util.Set<java.lang.reflect.Type> getAutoAdvertisedTypes​(java.lang.reflect.Type t)
      • createAutoDescriptor

        public static <T> AutoActiveDescriptor<T> createAutoDescriptor​(java.lang.Class<T> clazz,
                                                                       ServiceLocatorImpl locator)
                                                                throws MultiException,
                                                                       java.lang.IllegalArgumentException,
                                                                       java.lang.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
        java.lang.IllegalArgumentException - If the class is null
        java.lang.IllegalStateException - If the name could not be determined from the Named annotation
      • createAutoFactoryDescriptor

        public static <T> AutoActiveDescriptor<T> createAutoFactoryDescriptor​(java.lang.Class<T> parentClazz,
                                                                              ActiveDescriptor<?> factoryDescriptor,
                                                                              ServiceLocatorImpl locator)
                                                                       throws MultiException,
                                                                              java.lang.IllegalArgumentException,
                                                                              java.lang.IllegalStateException
        Creates a reified automatically generated descriptor
        Parameters:
        parentClazz - 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
        java.lang.IllegalArgumentException - If the class is null
        java.lang.IllegalStateException - If the name could not be determined from the Named annotation
      • justPreDestroy

        public static void justPreDestroy​(java.lang.Object preMe,
                                          ServiceLocatorImpl locator,
                                          java.lang.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​(java.lang.Object postMe,
                                             ServiceLocatorImpl locator,
                                             java.lang.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
      • justAssistedInject

        public static java.lang.Object justAssistedInject​(java.lang.Object injectMe,
                                                          java.lang.reflect.Method method,
                                                          ServiceLocatorImpl locator,
                                                          ServiceHandle<?> root,
                                                          MethodParameter... givenValues)
        Just injects this one method
        Parameters:
        injectMe -
        method -
        locator -
        givenValues -
      • justInject

        public static void justInject​(java.lang.Object injectMe,
                                      ServiceLocatorImpl locator,
                                      java.lang.String strategy)
        Just injects 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​(java.lang.Class<T> createMe,
                                       ServiceLocatorImpl locator,
                                       java.lang.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 java.lang.Class<?>[] getInterfacesForProxy​(java.util.Set<java.lang.reflect.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​(java.lang.Class<? extends java.lang.annotation.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​(java.lang.Class<? extends java.lang.annotation.Annotation> scope)
        Returns true if this scope is unproxiable
        Parameters:
        scope - The scope annotation to test
        Returns:
        true if this must be proxied
      • isProxiable

        private static boolean isProxiable​(ActiveDescriptor<?> desc,
                                           Injectee injectee)
        This method determines whether or not the descriptor should be proxied. The given descriptor must be reified and valid.
        Parameters:
        desc - A non-null, reified ActiveDescriptor
        injectee - The injectee where this is being injected if known, or null if not known
        Returns:
        true if this descriptor must be proxied, false otherwise
      • getFirstThingInList

        public static <T> T getFirstThingInList​(java.util.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 java.lang.reflect.Constructor<?> findProducerConstructor​(java.lang.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
      • isProperConstructor

        private static boolean isProperConstructor​(java.lang.reflect.Constructor<?> c)
      • getAllConstructors

        private static java.util.Set<java.lang.reflect.Constructor<?>> getAllConstructors​(java.lang.Class<?> clazz)
        Gets all the constructors for a given class
        Parameters:
        clazz - The class to find the constructors of
        Returns:
        A set of Constructors for the given class
      • hasSubscribeToAnnotation

        private static boolean hasSubscribeToAnnotation​(java.lang.reflect.Method method)
      • findInitializerMethods

        public static java.util.Set<java.lang.reflect.Method> findInitializerMethods​(java.lang.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
      • findPostConstruct

        public static java.lang.reflect.Method findPostConstruct​(java.lang.Class<?> clazz,
                                                                 ServiceLocatorImpl locator,
                                                                 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 java.lang.reflect.Method findPreDestroy​(java.lang.Class<?> clazz,
                                                              ServiceLocatorImpl locator,
                                                              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
      • findInitializerFields

        public static java.util.Set<java.lang.reflect.Field> findInitializerFields​(java.lang.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
      • computeAEAI

        static AnnotatedElementAnnotationInfo computeAEAI​(java.lang.reflect.AnnotatedElement annotatedElement)
        Represents a cache miss, and will fetch all of the information needed about the AnnotatedElement in order to quickly determine what its resolver would be
        Parameters:
        annotatedElement - The raw annotated element that can be used to calculate the information needed to determine the resolver
        Returns:
        An annotated element constructed from the information in the annotatedElement
      • isProperMethod

        private static boolean isProperMethod​(java.lang.reflect.Method member)
      • isProperField

        private static boolean isProperField​(java.lang.reflect.Field field)
      • isAbstract

        public static boolean isAbstract​(java.lang.reflect.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​(java.lang.reflect.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

        private static boolean isFinal​(java.lang.Class<?> clazz)
      • getScopeInfo

        private static ScopeInfo getScopeInfo​(java.lang.reflect.AnnotatedElement annotatedGuy,
                                              Descriptor defaultScope,
                                              Collector collector)
      • getScopeAnnotationType

        public static java.lang.Class<? extends java.lang.annotation.Annotation> getScopeAnnotationType​(java.lang.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 ScopeInfo getScopeAnnotationType​(java.lang.reflect.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
      • internalGetScopeAnnotationType

        private static java.lang.annotation.Annotation internalGetScopeAnnotationType​(java.lang.reflect.AnnotatedElement annotatedGuy,
                                                                                      Collector collector)
        This returns the scope annotation on this class *itself*, and no other classes (like, not subclasses).
      • getFactoryProvideMethod

        public static java.lang.reflect.Method getFactoryProvideMethod​(java.lang.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 java.lang.String getDefaultNameFromMethod​(java.lang.reflect.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 java.util.Set<java.lang.annotation.Annotation> getAllQualifiers​(java.lang.reflect.AnnotatedElement annotatedGuy,
                                                                                      java.lang.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 java.util.List<SystemInjecteeImpl> getConstructorInjectees​(java.lang.reflect.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 java.util.List<SystemInjecteeImpl> getMethodInjectees​(java.lang.Class<?> actualClass,
                                                                            java.lang.reflect.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
      • getMethodInjectees

        public static java.util.List<SystemInjecteeImpl> getMethodInjectees​(java.lang.Class<?> actualClass,
                                                                            java.lang.reflect.Method c,
                                                                            ActiveDescriptor<?> injecteeDescriptor,
                                                                            java.util.Map<java.lang.Integer,​MethodParameter> knownValues)
        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
      • getFieldAdjustedQualifierAnnotations

        private static java.util.Set<java.lang.annotation.Annotation> getFieldAdjustedQualifierAnnotations​(java.lang.reflect.Field f,
                                                                                                           java.util.Set<java.lang.annotation.Annotation> qualifiers)
      • getFieldInjectees

        public static java.util.List<SystemInjecteeImpl> getFieldInjectees​(java.lang.Class<?> actualClass,
                                                                           java.lang.reflect.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,
                                                 java.util.List<SystemInjecteeImpl> 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
      • fixAndCheckQualifiers

        public static java.util.Set<java.lang.annotation.Annotation> fixAndCheckQualifiers​(java.lang.annotation.Annotation[] qualifiers,
                                                                                           java.lang.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
      • createService

        public static <T> T createService​(ActiveDescriptor<T> root,
                                          Injectee injectee,
                                          ServiceLocatorImpl locator,
                                          ServiceHandle<T> handle,
                                          java.lang.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
      • isTypeSafe

        public static boolean isTypeSafe​(java.lang.reflect.Type requiredType,
                                         java.lang.reflect.Type beanType)
        This code uses the TypeChecker but does some extra checking if the types are annotations
        Parameters:
        requiredType - The type this must conform to
        beanType - The type of the bean we are checking
        Returns:
        true if beanType is safely assignable to requiredType
      • proxiesAvailable

        public static boolean proxiesAvailable()
        Returns true if the system can create proxies, false otherwise
        Returns:
        true if the system can create proxies, false otherwise