Package org.jboss.weld.bootstrap.events

Class ProcessAnnotatedTypeEventResolvable

java.lang.Object

org.jboss.weld.bootstrap.events.ProcessAnnotatedTypeEventResolvable

All Implemented Interfaces:

Resolvable

public class ProcessAnnotatedTypeEventResolvable
extends Object
implements Resolvable

For ProcessAnnotatedType we need a special Resolvable in order to support WithAnnotations properly.

Author:

Jozef Hartinger

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	ProcessAnnotatedTypeEventResolvable(Set<Type> types, SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery)

Method Summary

Modifier and Type	Method	Description
protected boolean	apply(UnbackedAnnotatedType<?> annotatedType, Class<? extends Annotation> requiredAnnotation)
protected boolean	containsAnnotation(BackedAnnotatedType<?> annotatedType, Collection<Class<? extends Annotation>> requiredAnnotations)
protected boolean	containsAnnotation(UnbackedAnnotatedType<?> annotatedType, Collection<Class<? extends Annotation>> requiredAnnotations)
boolean	containsRequiredAnnotations(Collection<Class<? extends Annotation>> requiredAnnotations)	Returns true if and only if the underlying AnnotatedType contains any of the given annotation types.
boolean	equals(Object obj)
static ProcessAnnotatedTypeEventResolvable	forProcessAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery)
static ProcessAnnotatedTypeEventResolvable	forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType, RequiredAnnotationDiscovery discovery)
Bean<?>	getDeclaringBean()	Get the declaring the injection point, or null if there is none
Class<?>	getJavaClass()	Get the underlying java class used to generate this resolvable, or null if no java class was used
Set<QualifierInstance>	getQualifiers()	Get the bindings to use for resolution.
Set<Type>	getTypes()	The types that this resolvable may be assigned to
int	hashCode()
boolean	isDelegate()	Returns true if the resolvable represents a delegate injection point, which requires specific rules (8.3.1) to be used during resolution.
static ProcessAnnotatedTypeEventResolvable	of(ProcessAnnotatedTypeImpl<?> event, RequiredAnnotationDiscovery discovery)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ProcessAnnotatedTypeEventResolvable

protected ProcessAnnotatedTypeEventResolvable(Set<Type> types,
                                              SlimAnnotatedType<?> annotatedType,
                                              RequiredAnnotationDiscovery discovery)

Method Detail

of

public static ProcessAnnotatedTypeEventResolvable of(ProcessAnnotatedTypeImpl<?> event,
                                                     RequiredAnnotationDiscovery discovery)

forProcessAnnotatedType

public static ProcessAnnotatedTypeEventResolvable forProcessAnnotatedType(SlimAnnotatedType<?> annotatedType,
                                                                          RequiredAnnotationDiscovery discovery)

forProcessSyntheticAnnotatedType

public static ProcessAnnotatedTypeEventResolvable forProcessSyntheticAnnotatedType(SlimAnnotatedType<?> annotatedType,
                                                                                   RequiredAnnotationDiscovery discovery)

getTypes

public Set<Type> getTypes()

Description copied from interface: Resolvable

The types that this resolvable may be assigned to

Specified by:

getTypes in interface Resolvable

Returns:

getQualifiers

public Set<QualifierInstance> getQualifiers()

Description copied from interface: Resolvable

Get the bindings to use for resolution. @Default will be returned if no bindings were specified

Specified by:

getQualifiers in interface Resolvable

Returns:

the bindings

containsRequiredAnnotations

public boolean containsRequiredAnnotations(Collection<Class<? extends Annotation>> requiredAnnotations)

Returns true if and only if the underlying AnnotatedType contains any of the given annotation types.

containsAnnotation

protected boolean containsAnnotation(UnbackedAnnotatedType<?> annotatedType,
                                     Collection<Class<? extends Annotation>> requiredAnnotations)

apply

protected boolean apply(UnbackedAnnotatedType<?> annotatedType,
                        Class<? extends Annotation> requiredAnnotation)

Returns:

true if predicate returns true for any annotation defined anywhere on the annotatedType

containsAnnotation

protected boolean containsAnnotation(BackedAnnotatedType<?> annotatedType,
                                     Collection<Class<? extends Annotation>> requiredAnnotations)

getJavaClass

public Class<?> getJavaClass()

Description copied from interface: Resolvable

Get the underlying java class used to generate this resolvable, or null if no java class was used

Specified by:

getJavaClass in interface Resolvable

Returns:

the java class

getDeclaringBean

public Bean<?> getDeclaringBean()

Description copied from interface: Resolvable

Get the declaring the injection point, or null if there is none

Specified by:

getDeclaringBean in interface Resolvable

Returns:

isDelegate

public boolean isDelegate()

Description copied from interface: Resolvable

Returns true if the resolvable represents a delegate injection point, which requires specific rules (8.3.1) to be used during resolution.

Specified by:

isDelegate in interface Resolvable

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object