ElementMatchers (Byte Buddy (without dependencies) 1.3.3 API)

java.lang.Object
- net.bytebuddy.matcher.ElementMatchers

```
public final class ElementMatchers
extends Object
```
A utility class that contains a human-readable language for creating ElementMatchers.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> ElementMatcher.Junction<T>`	`any()` Creates a matcher that always returns `true`.
`static <T extends AnnotationDescription> ElementMatcher.Junction<T>`	`anyOf(Annotation... value)` Creates a matcher that matches any of the given annotations as `AnnotationDescription`s by the `Object.equals(Object)` method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`anyOf(Constructor<?>... value)` Creates a matcher that matches any of the given constructors as `MethodDescription`s by the `Object.equals(Object)` method.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`anyOf(Field... value)` Creates a matcher that matches any of the given fields as `FieldDescription`s by the `Object.equals(Object)` method.
`static <T> ElementMatcher.Junction<T>`	`anyOf(Iterable<?> values)` Creates a matcher that matches any of the given objects by the `Object.equals(Object)` method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`anyOf(Method... value)` Creates a matcher that matches any of the given methods as `MethodDescription`s by the `Object.equals(Object)` method.
`static <T> ElementMatcher.Junction<T>`	`anyOf(Object... value)` Creates a matcher that matches any of the given objects by the `Object.equals(Object)` method.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`anyOf(Type... value)` Creates a matcher that matches any of the given types as `TypeDescription`s by the `Object.equals(Object)` method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`canThrow(Class<? extends Throwable> exceptionType)` Matches a `MethodDescription` by its capability to throw a given checked exception.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`canThrow(TypeDescription exceptionType)` Matches a `MethodDescription` by its capability to throw a given checked exception.
`static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T>`	`declaresAnnotation(ElementMatcher<? super AnnotationDescription> matcher)` Matches an `AnnotatedCodeElement` to declare any annotation that matches the given matcher.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`declaresException(Class<? extends Throwable> exceptionType)` Matches a method that declares the given generic exception type as a (erased) exception type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`declaresException(TypeDescription exceptionType)` Matches a method that declares the given generic exception type as a (erased) exception type.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`declaresField(ElementMatcher<? super FieldDescription> fieldMatcher)` Matches a type by a another matcher that is applied on any of its declared fields.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`declaresGenericException(ElementMatcher<? super Iterable<? extends TypeDescription.Generic>> exceptionMatcher)` Matches a method's generic exception types against the provided matcher.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`declaresGenericException(Type exceptionType)` Matches a method that declares the given generic exception type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`declaresGenericException(TypeDescription.Generic exceptionType)` Matches a method that declares the given generic exception type.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`declaresMethod(ElementMatcher<? super MethodDescription> methodMatcher)` Matches a type by a another matcher that is applied on any of its declared methods.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`definedField(ElementMatcher<? super FieldDescription.InDefinedShape> matcher)` Matches a field in its defined shape.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`definedMethod(ElementMatcher<? super MethodDescription.InDefinedShape> matcher)` Matches a method in its defined shape.
`static <T extends ParameterDescription> ElementMatcher.Junction<T>`	`definedParameter(ElementMatcher<? super ParameterDescription.InDefinedShape> matcher)` Matches a parameter in its defined shape.
`static <T> ElementMatcher.Junction<T>`	`failSafe(ElementMatcher<? super T> matcher)` Wraps another matcher to assure that an element is not matched in case that the matching causes an `Exception`.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`fieldType(Class<?> fieldType)` Matches a field's raw type against the provided matcher.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`fieldType(ElementMatcher<? super TypeDescription> matcher)` Matches a field's raw type against the provided matcher.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`fieldType(TypeDescription fieldType)` Matches a field's raw type against the provided matcher.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`genericFieldType(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches a field's generic type against the provided matcher.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`genericFieldType(Type fieldType)` Matches a field's generic type against the provided matcher.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`genericFieldType(TypeDescription.Generic fieldType)` Matches a field's generic type against the provided matcher.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`hasAnnotation(ElementMatcher<? super AnnotationDescription> matcher)` Matches a list of annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
`static <T extends ClassLoader> ElementMatcher<T>`	`hasChild(ElementMatcher<? super ClassLoader> matcher)` Matches all class loaders in the hierarchy of the matched class loader against a given matcher.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`hasDescriptor(String descriptor)` Matches a `ByteCodeElement`'s descriptor against a given value.
`static <T extends ParameterDescription> ElementMatcher.Junction<T>`	`hasGenericType(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches a method parameter by its generic type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`hasMethodName(String internalName)` Matches a method against its internal name such that constructors and type initializers are matched appropriately.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`hasParameters(ElementMatcher<? super Iterable<? extends ParameterDescription>> matcher)` Matches a `MethodDescription` by validating that its parameters fulfill a given constraint.
`static <T extends ParameterDescription> ElementMatcher.Junction<T>`	`hasType(ElementMatcher<? super TypeDescription> matcher)` Matches a parameter's type by the given matcher.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`inheritsAnnotation(Class<?> type)` Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`inheritsAnnotation(ElementMatcher<? super TypeDescription> matcher)` Matches any annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`inheritsAnnotation(TypeDescription type)` Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
`static <T extends AnnotationDescription> ElementMatcher.Junction<T>`	`is(Annotation annotation)` Exactly matches a given annotation as an `AnnotationDescription`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`is(Constructor<?> constructor)` Exactly matches a given constructor as a `MethodDescription`.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`is(Field field)` Exactly matches a given field as a `FieldDescription`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`is(Method method)` Exactly matches a given method as a `MethodDescription`.
`static <T> ElementMatcher.Junction<T>`	`is(Object value)` Matches the given value which can also be `null` by the `Object.equals(Object)` method or by a null-check.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`is(Type type)` Exactly matches a given type as a `TypeDescription`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isAbstract()` Matches a `ModifierReviewable` that is `abstract`.
`static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T>`	`isAnnotatedWith(Class<? extends Annotation> type)` Matches an `AnnotatedCodeElement` for declared annotations.
`static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T>`	`isAnnotatedWith(ElementMatcher<? super TypeDescription> matcher)` Matches an `AnnotatedCodeElement` for declared annotations.
`static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T>`	`isAnnotatedWith(TypeDescription type)` Matches an `AnnotatedCodeElement` for declared annotations.
`static <T extends ClassLoader> ElementMatcher<T>`	`isBootstrapClassLoader()` Matches exactly the bootstrap `ClassLoader` .
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isBridge()` Matches a `MethodDescription` that is a bridge.
`static <T extends ClassLoader> ElementMatcher<T>`	`isChildOf(ClassLoader classLoader)` Matches any class loader that is either the given class loader or a child of the given class loader.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isClone()` Only matches the `Object.clone()` method, also if it was overridden.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isConstructor()` Only matches method descriptions that represent a `Constructor`.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredBy(Class<?> type)` Matches a `ByteCodeElement` for being declared by a given `Class`.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredBy(ElementMatcher<? super TypeDescription> matcher)` Matches a `ByteCodeElement` for being declared by a `TypeDescription` that is matched by the given matcher.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredBy(TypeDescription type)` Matches a `ByteCodeElement` for being declared by a given `TypeDescription`.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredByGeneric(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches a `ByteCodeElement` for being declared by a `TypeDescription.Generic` that is matched by the given matcher.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredByGeneric(Type type)` Matches a `ByteCodeElement` for being declared by a given generic `Type`.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isDeclaredByGeneric(TypeDescription.Generic type)` Matches a `ByteCodeElement` for being declared by a given `TypeDescription.Generic`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isDefaultConstructor()` Matches a default constructor, i.e. a constructor without arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isDefaultFinalizer()` Only matches the `Object.finalize()` method if it was not overridden.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isDefaultMethod()` Only matches Java 8 default methods.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isEquals()` Only matches the `Object.equals(Object)` method, also if it was overridden.
`static <T extends ClassLoader> ElementMatcher<T>`	`isExtensionClassLoader()` Matches exactly the extension `ClassLoader`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isFinal()` Matches a `ModifierReviewable` that is `final`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isFinalizer()` Only matches the `Object.finalize()` method, even if it was overridden.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isGetter()` Matches any Java bean getter method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isGetter(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches any Java bean getter method which returns an value with a type matches the supplied matcher.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isGetter(Type type)` Matches any Java bean getter method which returns the given type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isGetter(TypeDescription.Generic type)` Matches any Java bean getter method which returns the given type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isHashCode()` Only matches the `Object.toString()` method, also if it was overridden.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`isInterface()` Matches a `TypeDescription` that is an interface.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isMethod()` Only matches method descriptions that represent a `Method`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isNative()` Matches a `MethodDescription` that is `native`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isPackagePrivate()` Matches a `ModifierReviewable` that is package-private.
`static <T extends ClassLoader> ElementMatcher<T>`	`isParentOf(ClassLoader classLoader)` Matches any class loader that is either the given class loader or a parent of the given class loader.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isPrivate()` Matches a `ModifierReviewable` that is `private`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isProtected()` Matches a `ModifierReviewable` that is `protected`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isPublic()` Matches a `ModifierReviewable` that is `public`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isSetter()` Matches any Java bean setter method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isSetter(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches any Java bean setter method which takes an argument that matches the supplied matcher.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isSetter(Type type)` Matches any Java bean setter method which takes an argument the given type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isSetter(TypeDescription.Generic type)` Matches any Java bean setter method which takes an argument the given type.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isStatic()` Matches a `ModifierReviewable` that is `static`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isStrict()` Matches a `MethodDescription` that is `strictfp`.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`isSubTypeOf(Class<?> type)` Matches any type description that is a subtype of the given type.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`isSubTypeOf(TypeDescription type)` Matches any type description that is a subtype of the given type.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`isSuperTypeOf(Class<?> type)` Matches any type description that is a super type of the given type.
`static <T extends TypeDescription> ElementMatcher.Junction<T>`	`isSuperTypeOf(TypeDescription type)` Matches any type description that is a super type of the given type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isSynchronized()` Matches a `MethodDescription` that is `synchronized`.
`static <T extends ModifierReviewable> ElementMatcher.Junction<T>`	`isSynthetic()` Matches a `ModifierReviewable` that is synthetic.
`static <T extends ClassLoader> ElementMatcher<T>`	`isSystemClassLoader()` Matches exactly the system `ClassLoader`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isToString()` Only matches the `Object.toString()` method, also if it was overridden.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isTypeInitializer()` Only matches method descriptions that represent a `Class` type initializer.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isVarArgs()` Matches a `MethodDescription` that is a var-args.
`static <T extends TypeDefinition> ElementMatcher<T>`	`isVariable(ElementMatcher<? super NamedElement> matcher)` Matches a type variable with the given name.
`static <T extends TypeDefinition> ElementMatcher<T>`	`isVariable(String symbol)` Matches a type variable with the given name.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`isVirtual()` Matches any method that is virtual, i.e. non-constructors that are non-static and non-private.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isVisibleTo(Class<?> type)` Matches a `ByteCodeElement` that is visible to a given `Class`.
`static <T extends ByteCodeElement> ElementMatcher.Junction<T>`	`isVisibleTo(TypeDescription type)` Matches a `ByteCodeElement` that is visible to a given `TypeDescription`.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameContains(String infix)` Matches a `NamedElement` for an infix of its name.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameContainsIgnoreCase(String infix)` Matches a `NamedElement` for an infix of its name.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`named(String name)` Matches a `NamedElement` for its exact name.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`namedIgnoreCase(String name)` Matches a `NamedElement` for its name.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameEndsWith(String suffix)` Matches a `NamedElement` for its name's suffix.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameEndsWithIgnoreCase(String suffix)` Matches a `NamedElement` for its name's suffix.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameMatches(String regex)` Matches a `NamedElement` name against a regular expression.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameStartsWith(String prefix)` Matches a `NamedElement` for its name's prefix.
`static <T extends NamedElement> ElementMatcher.Junction<T>`	`nameStartsWithIgnoreCase(String prefix)` Matches a `NamedElement` for its name's prefix.
`static <T> ElementMatcher.Junction<T>`	`none()` Creates a matcher that always returns `false`.
`static <T extends AnnotationDescription> ElementMatcher.Junction<T>`	`noneOf(Annotation... value)` Creates a matcher that matches none of the given annotations as `AnnotationDescription`s by the `Object.equals(Object)` method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`noneOf(Constructor<?>... value)` Creates a matcher that matches none of the given constructors as `MethodDescription`s by the `Object.equals(Object)` method.
`static <T extends FieldDescription> ElementMatcher.Junction<T>`	`noneOf(Field... value)` Creates a matcher that matches none of the given methods as `FieldDescription`s by the `Object.equals(Object)` method.
`static <T> ElementMatcher.Junction<T>`	`noneOf(Iterable<?> values)` Creates a matcher that matches none of the given objects by the `Object.equals(Object)` method.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`noneOf(Method... value)` Creates a matcher that matches none of the given methods as `MethodDescription`s by the `Object.equals(Object)` method.
`static <T> ElementMatcher.Junction<T>`	`noneOf(Object... value)` Creates a matcher that matches none of the given objects by the `Object.equals(Object)` method.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`noneOf(Type... value)` Creates a matcher that matches none of the given types as `TypeDescription`s by the `Object.equals(Object)` method.
`static <T> ElementMatcher.Junction<T>`	`not(ElementMatcher<? super T> matcher)` Inverts another matcher.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`ofSort(ElementMatcher<? super TypeDefinition.Sort> matcher)` Matches generic type descriptions of the given sort.
`static <T extends TypeDefinition> ElementMatcher.Junction<T>`	`ofSort(TypeDefinition.Sort sort)` Matches generic type descriptions of the given sort.
`static <T extends TypeDescription.Generic> ElementMatcher.Junction<T>`	`rawType(Class<?> type)` Matches a generic type's raw type against the provided raw type.
`static <T extends TypeDescription.Generic> ElementMatcher.Junction<T>`	`rawType(ElementMatcher<? super TypeDescription> matcher)` Converts a matcher for a type description into a matcher for a raw type of the matched generic type against the given matcher.
`static <T extends TypeDescription.Generic> ElementMatcher.Junction<T>`	`rawType(TypeDescription type)` Matches a generic type's raw type against the provided raw type.
`static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>`	`rawTypes(Class<?>... type)` Matches an iteration of generic types' erasures against the provided raw types.
`static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>`	`rawTypes(ElementMatcher<? super Iterable<? extends TypeDescription>> matcher)` Applies the provided matcher to an iteration og generic types' generic types.
`static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>`	`rawTypes(Iterable<? extends TypeDescription> types)` Matches an iteration of generic types' erasures against the provided raw types.
`static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T>`	`rawTypes(TypeDescription... type)` Matches an iteration of generic types' erasures against the provided raw types.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returns(Class<?> type)` Matches `MethodDescription`s that return a given erasure type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returns(ElementMatcher<? super TypeDescription> matcher)` Matches a method's return type's erasure by the given matcher.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returns(TypeDescription type)` Matches `MethodDescription`s that return a given erasure type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returnsGeneric(ElementMatcher<? super TypeDescription.Generic> matcher)` Matches `MethodDescription`s that match a matched method's return type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returnsGeneric(Type type)` Matches `MethodDescription`s that return a given generic type.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`returnsGeneric(TypeDescription.Generic type)` Matches `MethodDescription`s that returns a given `TypeDescription`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArgument(int index, Class<?> type)` Matches `MethodDescription`s that define a given generic type as a parameter at the given index.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArgument(int index, TypeDescription type)` Matches `MethodDescription`s that define a given generic type as a parameter at the given index.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArguments(Class<?>... type)` Matches a method description that takes the provided raw arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArguments(int length)` Matches a `MethodDescription` by the number of its parameters.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArguments(Iterable<? extends TypeDescription> types)` Matches a method description that takes the provided raw arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesArguments(TypeDescription... type)` Matches a method description that takes the provided raw arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArgument(int index, ElementMatcher<? super TypeDescription.Generic> matcher)` Matches `MethodDescription`s that define a given generic type as a parameter at the given index.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArgument(int index, Type type)` Matches `MethodDescription`s that define a given generic type as a parameter at the given index.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArgument(int index, TypeDescription.Generic type)` Matches `MethodDescription`s that define a given generic type as a parameter at the given index.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArguments(ElementMatcher<? super Iterable<? extends TypeDescription.Generic>> matchers)` Matches a `MethodDescription` by applying an iterable collection of element matcher on any parameter's `TypeDescription`.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArguments(List<? extends TypeDefinition> types)` Matches a method description that takes the provided generic arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArguments(Type... type)` Matches a method description that takes the provided generic arguments.
`static <T extends MethodDescription> ElementMatcher.Junction<T>`	`takesGenericArguments(TypeDefinition... type)` Matches a method description that takes the provided generic arguments.
`static <T> ElementMatcher.Junction<Iterable<? extends T>>`	`whereAny(ElementMatcher<? super T> matcher)` Matches an iterable by assuring that at least one element of the iterable collection matches the provided matcher.
`static <T> ElementMatcher.Junction<Iterable<? extends T>>`	`whereNone(ElementMatcher<? super T> matcher)` Matches an iterable by assuring that no element of the iterable collection matches the provided matcher.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - failSafe
```
public static <T> ElementMatcher.Junction<T> failSafe(ElementMatcher<? super T> matcher)
```
    Wraps another matcher to assure that an element is not matched in case that the matching causes an Exception.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The element matcher that potentially throws an exception.
    
    Returns:
    
    A matcher that returns false in case that the given matcher throws an exception.
  - is
```
public static <T> ElementMatcher.Junction<T> is(Object value)
```
    Matches the given value which can also be null by the Object.equals(Object) method or by a null-check.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The value that is to be matched.
    
    Returns:
    
    A matcher that matches an exact value.
  - is
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> is(Field field)
```
    Exactly matches a given field as a FieldDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    field - The field to match by its description
    
    Returns:
    
    An element matcher that exactly matches the given field.
  - definedField
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> definedField(ElementMatcher<? super FieldDescription.InDefinedShape> matcher)
```
    Matches a field in its defined shape.
    
    Type Parameters:
    
    T - The matched object's type.
    
    Parameters:
    
    matcher - The matcher to apply to the matched field's defined shape.
    
    Returns:
    
    A matcher that matches a matched field's defined shape.
  - is
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> is(Method method)
```
    Exactly matches a given method as a MethodDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    method - The method to match by its description
    
    Returns:
    
    An element matcher that exactly matches the given method.
  - is
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> is(Constructor<?> constructor)
```
    Exactly matches a given constructor as a MethodDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    constructor - The constructor to match by its description
    
    Returns:
    
    An element matcher that exactly matches the given constructor.
  - definedMethod
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> definedMethod(ElementMatcher<? super MethodDescription.InDefinedShape> matcher)
```
    Matches a method in its defined shape.
    
    Type Parameters:
    
    T - The matched object's type.
    
    Parameters:
    
    matcher - The matcher to apply to the matched method's defined shape.
    
    Returns:
    
    A matcher that matches a matched method's defined shape.
  - definedParameter
```
public static <T extends ParameterDescription> ElementMatcher.Junction<T> definedParameter(ElementMatcher<? super ParameterDescription.InDefinedShape> matcher)
```
    Matches a parameter in its defined shape.
    
    Type Parameters:
    
    T - The matched object's type.
    
    Parameters:
    
    matcher - The matcher to apply to the matched parameter's defined shape.
    
    Returns:
    
    A matcher that matches a matched parameter's defined shape.
  - hasType
```
public static <T extends ParameterDescription> ElementMatcher.Junction<T> hasType(ElementMatcher<? super TypeDescription> matcher)
```
    Matches a parameter's type by the given matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to the parameter's type.
    
    Returns:
    
    A matcher that matches a parameter's type by the given matcher.
  - hasGenericType
```
public static <T extends ParameterDescription> ElementMatcher.Junction<T> hasGenericType(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches a method parameter by its generic type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to a parameter's generic type.
    
    Returns:
    
    A matcher that matches the matched parameter's generic type.
  - is
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> is(Type type)
```
    Exactly matches a given type as a TypeDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to match by its description
    
    Returns:
    
    An element matcher that exactly matches the given type.
  - is
```
public static <T extends AnnotationDescription> ElementMatcher.Junction<T> is(Annotation annotation)
```
    Exactly matches a given annotation as an AnnotationDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    annotation - The annotation to match by its description.
    
    Returns:
    
    An element matcher that exactly matches the given annotation.
  - not
```
public static <T> ElementMatcher.Junction<T> not(ElementMatcher<? super T> matcher)
```
    Inverts another matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to invert.
    
    Returns:
    
    An inverted version of the given matcher.
  - any
```
public static <T> ElementMatcher.Junction<T> any()
```
    Creates a matcher that always returns true.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that matches anything.
  - none
```
public static <T> ElementMatcher.Junction<T> none()
```
    Creates a matcher that always returns false.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that matches nothing.
  - anyOf
```
public static <T> ElementMatcher.Junction<T> anyOf(Object... value)
```
    Creates a matcher that matches any of the given objects by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T> ElementMatcher.Junction<T> anyOf(Iterable<?> values)
```
    Creates a matcher that matches any of the given objects by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    values - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> anyOf(Type... value)
```
    Creates a matcher that matches any of the given types as TypeDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> anyOf(Constructor<?>... value)
```
    Creates a matcher that matches any of the given constructors as MethodDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> anyOf(Method... value)
```
    Creates a matcher that matches any of the given methods as MethodDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> anyOf(Field... value)
```
    Creates a matcher that matches any of the given fields as FieldDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - anyOf
```
public static <T extends AnnotationDescription> ElementMatcher.Junction<T> anyOf(Annotation... value)
```
    Creates a matcher that matches any of the given annotations as AnnotationDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - noneOf
```
public static <T> ElementMatcher.Junction<T> noneOf(Object... value)
```
    Creates a matcher that matches none of the given objects by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T> ElementMatcher.Junction<T> noneOf(Iterable<?> values)
```
    Creates a matcher that matches none of the given objects by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    values - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> noneOf(Type... value)
```
    Creates a matcher that matches none of the given types as TypeDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> noneOf(Constructor<?>... value)
```
    Creates a matcher that matches none of the given constructors as MethodDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> noneOf(Method... value)
```
    Creates a matcher that matches none of the given methods as MethodDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> noneOf(Field... value)
```
    Creates a matcher that matches none of the given methods as FieldDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with none of the given objects.
  - noneOf
```
public static <T extends AnnotationDescription> ElementMatcher.Junction<T> noneOf(Annotation... value)
```
    Creates a matcher that matches none of the given annotations as AnnotationDescriptions by the Object.equals(Object) method. None of the values must be null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    value - The input values to be compared against.
    
    Returns:
    
    A matcher that checks for the equality with any of the given objects.
  - whereAny
```
public static <T> ElementMatcher.Junction<Iterable<? extends T>> whereAny(ElementMatcher<? super T> matcher)
```
    Matches an iterable by assuring that at least one element of the iterable collection matches the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to each element.
    
    Returns:
    
    A matcher that matches an iterable if at least one element matches the provided matcher.
  - whereNone
```
public static <T> ElementMatcher.Junction<Iterable<? extends T>> whereNone(ElementMatcher<? super T> matcher)
```
    Matches an iterable by assuring that no element of the iterable collection matches the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to each element.
    
    Returns:
    
    A matcher that matches an iterable if no element matches the provided matcher.
  - rawType
```
public static <T extends TypeDescription.Generic> ElementMatcher.Junction<T> rawType(Class<?> type)
```
    Matches a generic type's raw type against the provided raw type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to match a generic type's erasure against.
    
    Returns:
    
    A matcher that matches a generic type's raw type against the provided non-generic type.
  - rawType
```
public static <T extends TypeDescription.Generic> ElementMatcher.Junction<T> rawType(TypeDescription type)
```
    Matches a generic type's raw type against the provided raw type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to match a generic type's erasure against.
    
    Returns:
    
    A matcher that matches a generic type's raw type against the provided non-generic type.
  - rawType
```
public static <T extends TypeDescription.Generic> ElementMatcher.Junction<T> rawType(ElementMatcher<? super TypeDescription> matcher)
```
    Converts a matcher for a type description into a matcher for a raw type of the matched generic type against the given matcher. A wildcard type which does not define a raw type results in a negative match.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to match the matched object's raw type against.
    
    Returns:
    
    A type matcher for a generic type that matches the matched type's raw type against the given type description matcher.
  - rawTypes
```
public static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T> rawTypes(Class<?>... type)
```
    Matches an iteration of generic types' erasures against the provided raw types.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The types to match.
    
    Returns:
    
    A matcher that matches an iteration of generic types' raw types against the provided non-generic types.
  - rawTypes
```
public static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T> rawTypes(TypeDescription... type)
```
    Matches an iteration of generic types' erasures against the provided raw types.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The types to match.
    
    Returns:
    
    A matcher that matches an iteration of generic types' raw types against the provided non-generic types.
  - rawTypes
```
public static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T> rawTypes(Iterable<? extends TypeDescription> types)
```
    Matches an iteration of generic types' erasures against the provided raw types.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    types - The types to match.
    
    Returns:
    
    A matcher that matches an iteration of generic types' raw types against the provided non-generic types.
  - rawTypes
```
public static <T extends Iterable<? extends TypeDescription.Generic>> ElementMatcher.Junction<T> rawTypes(ElementMatcher<? super Iterable<? extends TypeDescription>> matcher)
```
    Applies the provided matcher to an iteration og generic types' generic types.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply at the erased types.
    
    Returns:
    
    A matcher that matches an iteration of generic types' raw types against the provided matcher.
  - isVariable
```
public static <T extends TypeDefinition> ElementMatcher<T> isVariable(String symbol)
```
    Matches a type variable with the given name.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    symbol - The name of the type variable to be match.
    
    Returns:
    
    A matcher that matches type variables with the given name.
  - isVariable
```
public static <T extends TypeDefinition> ElementMatcher<T> isVariable(ElementMatcher<? super NamedElement> matcher)
```
    Matches a type variable with the given name.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher for the type variable's name.
    
    Returns:
    
    A matcher that matches type variables with the given name.
  - named
```
public static <T extends NamedElement> ElementMatcher.Junction<T> named(String name)
```
    Matches a NamedElement for its exact name.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    name - The expected name.
    
    Returns:
    
    An element matcher for a named element's exact name.
  - namedIgnoreCase
```
public static <T extends NamedElement> ElementMatcher.Junction<T> namedIgnoreCase(String name)
```
    Matches a NamedElement for its name. The name's capitalization is ignored.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    name - The expected name.
    
    Returns:
    
    An element matcher for a named element's name.
  - nameStartsWith
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameStartsWith(String prefix)
```
    Matches a NamedElement for its name's prefix.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    prefix - The expected name's prefix.
    
    Returns:
    
    An element matcher for a named element's name's prefix.
  - nameStartsWithIgnoreCase
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameStartsWithIgnoreCase(String prefix)
```
    Matches a NamedElement for its name's prefix. The name's capitalization is ignored.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    prefix - The expected name's prefix.
    
    Returns:
    
    An element matcher for a named element's name's prefix.
  - nameEndsWith
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameEndsWith(String suffix)
```
    Matches a NamedElement for its name's suffix.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    suffix - The expected name's suffix.
    
    Returns:
    
    An element matcher for a named element's name's suffix.
  - nameEndsWithIgnoreCase
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameEndsWithIgnoreCase(String suffix)
```
    Matches a NamedElement for its name's suffix. The name's capitalization is ignored.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    suffix - The expected name's suffix.
    
    Returns:
    
    An element matcher for a named element's name's suffix.
  - nameContains
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameContains(String infix)
```
    Matches a NamedElement for an infix of its name.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    infix - The expected infix of the name.
    
    Returns:
    
    An element matcher for a named element's name's infix.
  - nameContainsIgnoreCase
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameContainsIgnoreCase(String infix)
```
    Matches a NamedElement for an infix of its name. The name's capitalization is ignored.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    infix - The expected infix of the name.
    
    Returns:
    
    An element matcher for a named element's name's infix.
  - nameMatches
```
public static <T extends NamedElement> ElementMatcher.Junction<T> nameMatches(String regex)
```
    Matches a NamedElement name against a regular expression.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    regex - The regular expression to match the name against.
    
    Returns:
    
    An element matcher for a named element's name's against the given regular expression.
  - hasDescriptor
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> hasDescriptor(String descriptor)
```
    Matches a ByteCodeElement's descriptor against a given value.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    descriptor - The expected descriptor.
    
    Returns:
    
    A matcher for the given descriptor.
  - isDeclaredBy
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredBy(Class<?> type)
```
    Matches a ByteCodeElement for being declared by a given Class. This matcher matches a declared element's raw declaring type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that is expected to declare the matched byte code element.
    
    Returns:
    
    A matcher for byte code elements being declared by the given type.
  - isDeclaredBy
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredBy(TypeDescription type)
```
    Matches a ByteCodeElement for being declared by a given TypeDescription. This matcher matches a declared element's raw declaring type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that is expected to declare the matched byte code element.
    
    Returns:
    
    A matcher for byte code elements being declared by the given type.
  - isDeclaredBy
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredBy(ElementMatcher<? super TypeDescription> matcher)
```
    Matches a ByteCodeElement for being declared by a TypeDescription that is matched by the given matcher. This matcher matches a declared element's raw declaring type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher for the declaring type of the matched byte code element as long as it is not null.
    
    Returns:
    
    A matcher for byte code elements being declared by a type matched by the given matcher.
  - isDeclaredByGeneric
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredByGeneric(Type type)
```
    Matches a ByteCodeElement for being declared by a given generic Type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that is expected to declare the matched byte code element.
    
    Returns:
    
    A matcher for byte code elements being declared by the given type.
  - isDeclaredByGeneric
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredByGeneric(TypeDescription.Generic type)
```
    Matches a ByteCodeElement for being declared by a given TypeDescription.Generic.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that is expected to declare the matched byte code element.
    
    Returns:
    
    A matcher for byte code elements being declared by the given type.
  - isDeclaredByGeneric
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isDeclaredByGeneric(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches a ByteCodeElement for being declared by a TypeDescription.Generic that is matched by the given matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher for the declaring type of the matched byte code element as long as it is not null.
    
    Returns:
    
    A matcher for byte code elements being declared by a type matched by the given matcher.
  - isVisibleTo
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isVisibleTo(Class<?> type)
```
    Matches a ByteCodeElement that is visible to a given Class.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that a matched byte code element is expected to be visible to.
    
    Returns:
    
    A matcher for a byte code element to be visible to a given type.
  - isVisibleTo
```
public static <T extends ByteCodeElement> ElementMatcher.Junction<T> isVisibleTo(TypeDescription type)
```
    Matches a ByteCodeElement that is visible to a given TypeDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type that a matched byte code element is expected to be visible to.
    
    Returns:
    
    A matcher for a byte code element to be visible to a given type.
  - isAbstract
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isAbstract()
```
    Matches a ModifierReviewable that is abstract.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a abstract modifier reviewable.
  - isAnnotatedWith
```
public static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T> isAnnotatedWith(Class<? extends Annotation> type)
```
    Matches an AnnotatedCodeElement for declared annotations. This matcher does not match inherited annotations which only exist for classes. Use inheritsAnnotation(Class) for matching inherited annotations.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The annotation type to match against.
    
    Returns:
    
    A matcher that validates that an annotated element is annotated with an annotation of type.
  - isAnnotatedWith
```
public static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T> isAnnotatedWith(TypeDescription type)
```
    Matches an AnnotatedCodeElement for declared annotations. This matcher does not match inherited annotations which only exist for classes. Use inheritsAnnotation(TypeDescription) for matching inherited annotations.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The annotation type to match against.
    
    Returns:
    
    A matcher that validates that an annotated element is annotated with an annotation of type.
  - isAnnotatedWith
```
public static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T> isAnnotatedWith(ElementMatcher<? super TypeDescription> matcher)
```
    Matches an AnnotatedCodeElement for declared annotations. This matcher does not match inherited annotations which only exist for classes. Use inheritsAnnotation(net.bytebuddy.matcher.ElementMatcher) for matching inherited annotations.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to any annotation's type found on the matched annotated element.
    
    Returns:
    
    A matcher that validates that an annotated element is annotated with an annotation of a type that matches the given matcher.
  - declaresAnnotation
```
public static <T extends AnnotatedCodeElement> ElementMatcher.Junction<T> declaresAnnotation(ElementMatcher<? super AnnotationDescription> matcher)
```
    Matches an AnnotatedCodeElement to declare any annotation that matches the given matcher. Note that this matcher does not match inherited annotations that only exist for types. Use inheritsAnnotation(net.bytebuddy.matcher.ElementMatcher) for matching inherited annotations.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to apply on any declared annotation of the matched annotated element.
    
    Returns:
    
    A matcher that validates that an annotated element is annotated with an annotation that matches the given matcher.
  - isPublic
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isPublic()
```
    Matches a ModifierReviewable that is public.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a public modifier reviewable.
  - isProtected
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isProtected()
```
    Matches a ModifierReviewable that is protected.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a protected modifier reviewable.
  - isPackagePrivate
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isPackagePrivate()
```
    Matches a ModifierReviewable that is package-private.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a package-private modifier reviewable.
  - isPrivate
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isPrivate()
```
    Matches a ModifierReviewable that is private.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a private modifier reviewable.
  - isFinal
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isFinal()
```
    Matches a ModifierReviewable that is final.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a final modifier reviewable.
  - isStatic
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isStatic()
```
    Matches a ModifierReviewable that is static.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a static modifier reviewable.
  - isSynthetic
```
public static <T extends ModifierReviewable> ElementMatcher.Junction<T> isSynthetic()
```
    Matches a ModifierReviewable that is synthetic.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a synthetic modifier reviewable.
  - isSynchronized
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSynchronized()
```
    Matches a MethodDescription that is synchronized.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a synchronized method description.
  - isNative
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isNative()
```
    Matches a MethodDescription that is native.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a native method description.
  - isStrict
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isStrict()
```
    Matches a MethodDescription that is strictfp.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a strictfp method description.
  - isVarArgs
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isVarArgs()
```
    Matches a MethodDescription that is a var-args.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a var-args method description.
  - isBridge
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isBridge()
```
    Matches a MethodDescription that is a bridge.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for a bridge method.
  - returnsGeneric
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returnsGeneric(Type type)
```
    Matches MethodDescriptions that return a given generic type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The generic type the matched method is expected to return.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - returnsGeneric
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returnsGeneric(TypeDescription.Generic type)
```
    Matches MethodDescriptions that returns a given TypeDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type the matched method is expected to return.
    
    Returns:
    
    An element matcher that matches a given return type for a method description.
  - returns
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returns(Class<?> type)
```
    Matches MethodDescriptions that return a given erasure type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The raw type the matched method is expected to return.
    
    Returns:
    
    An element matcher that matches a given return type for a method description.
  - returns
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returns(TypeDescription type)
```
    Matches MethodDescriptions that return a given erasure type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The raw type the matched method is expected to return.
    
    Returns:
    
    An element matcher that matches a given return type for a method description.
  - returns
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returns(ElementMatcher<? super TypeDescription> matcher)
```
    Matches a method's return type's erasure by the given matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to a method's return type's erasure.
    
    Returns:
    
    A matcher that matches the matched method's return type's erasure.
  - returnsGeneric
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> returnsGeneric(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches MethodDescriptions that match a matched method's return type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to apply onto a matched method's return type.
    
    Returns:
    
    An element matcher that matches a given return type against another matcher.
  - takesGenericArgument
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArgument(int index,
                                                                                            Type type)
```
    Matches MethodDescriptions that define a given generic type as a parameter at the given index.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    index - The index of the parameter.
    
    type - The generic type the matched method is expected to define as a parameter type.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - takesGenericArgument
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArgument(int index,
                                                                                            TypeDescription.Generic type)
```
    Matches MethodDescriptions that define a given generic type as a parameter at the given index.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    index - The index of the parameter.
    
    type - The generic type the matched method is expected to define as a parameter type.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - takesGenericArgument
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArgument(int index,
                                                                                            ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches MethodDescriptions that define a given generic type as a parameter at the given index.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    index - The index of the parameter.
    
    matcher - A matcher for the generic type the matched method is expected to define as a parameter type.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - takesGenericArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArguments(Type... type)
```
    Matches a method description that takes the provided generic arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's generic parameter types against the supplied arguments.
  - takesGenericArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArguments(TypeDefinition... type)
```
    Matches a method description that takes the provided generic arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's generic parameter types against the supplied arguments.
  - takesGenericArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArguments(List<? extends TypeDefinition> types)
```
    Matches a method description that takes the provided generic arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    types - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's generic parameter types against the supplied arguments.
  - takesGenericArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesGenericArguments(ElementMatcher<? super Iterable<? extends TypeDescription.Generic>> matchers)
```
    Matches a MethodDescription by applying an iterable collection of element matcher on any parameter's TypeDescription.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matchers - The matcher that are applied onto the parameter types of the matched method description.
    
    Returns:
    
    A matcher that matches a method description by applying another element matcher onto each parameter's type.
  - takesArgument
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArgument(int index,
                                                                                     Class<?> type)
```
    Matches MethodDescriptions that define a given generic type as a parameter at the given index.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    index - The index of the parameter.
    
    type - The erasure of the type the matched method is expected to define as a parameter type.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - takesArgument
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArgument(int index,
                                                                                     TypeDescription type)
```
    Matches MethodDescriptions that define a given generic type as a parameter at the given index.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    index - The index of the parameter.
    
    type - The erasure of the type the matched method is expected to define as a parameter type.
    
    Returns:
    
    An element matcher that matches a given generic return type for a method description.
  - takesArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArguments(Class<?>... type)
```
    Matches a method description that takes the provided raw arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's raw parameter types against the supplied arguments.
  - takesArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArguments(TypeDescription... type)
```
    Matches a method description that takes the provided raw arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's raw parameter types against the supplied arguments.
  - takesArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArguments(Iterable<? extends TypeDescription> types)
```
    Matches a method description that takes the provided raw arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    types - The arguments to match against the matched method.
    
    Returns:
    
    A method matcher that matches a method's raw parameter types against the supplied arguments.
  - takesArguments
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> takesArguments(int length)
```
    Matches a MethodDescription by the number of its parameters.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    length - The expected length.
    
    Returns:
    
    A matcher that matches a method description by the number of its parameters.
  - hasParameters
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> hasParameters(ElementMatcher<? super Iterable<? extends ParameterDescription>> matcher)
```
    Matches a MethodDescription by validating that its parameters fulfill a given constraint.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply for validating the parameters.
    
    Returns:
    
    A matcher that matches a method description's parameters against the given constraint.
  - canThrow
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> canThrow(Class<? extends Throwable> exceptionType)
```
    Matches a MethodDescription by its capability to throw a given checked exception. For specifying a non-checked exception, any method is matched.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The type of the exception that should be declared by the method to be matched.
    
    Returns:
    
    A matcher that matches a method description by its declaration of throwing a checked exception.
  - canThrow
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> canThrow(TypeDescription exceptionType)
```
    Matches a MethodDescription by its capability to throw a given checked exception. For specifying a non-checked exception, any method is matched.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The type of the exception that should be declared by the method to be matched.
    
    Returns:
    
    A matcher that matches a method description by its declaration of throwing a checked exception.
  - declaresGenericException
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> declaresGenericException(Type exceptionType)
```
    Matches a method that declares the given generic exception type. For non-generic type, this matcher behaves identically to declaresException(Class). For exceptions that are expressed as type variables, only exceptions that are represented as this type variable are matched.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The generic exception type that is matched exactly.
    
    Returns:
    
    A matcher that matches any method that exactly matches the provided generic exception.
  - declaresGenericException
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> declaresGenericException(TypeDescription.Generic exceptionType)
```
    Matches a method that declares the given generic exception type. For non-generic type, this matcher behaves identically to declaresException(TypeDescription). For exceptions that are expressed as type variables, only exceptions that are represented as this type variable are matched.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The generic exception type that is matched exactly.
    
    Returns:
    
    A matcher that matches any method that exactly matches the provided generic exception.
  - declaresException
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> declaresException(Class<? extends Throwable> exceptionType)
```
    Matches a method that declares the given generic exception type as a (erased) exception type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The exception type that is matched.
    
    Returns:
    
    A matcher that matches any method that exactly matches the provided exception.
  - declaresException
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> declaresException(TypeDescription exceptionType)
```
    Matches a method that declares the given generic exception type as a (erased) exception type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionType - The exception type that is matched.
    
    Returns:
    
    A matcher that matches any method that exactly matches the provided exception.
  - declaresGenericException
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> declaresGenericException(ElementMatcher<? super Iterable<? extends TypeDescription.Generic>> exceptionMatcher)
```
    Matches a method's generic exception types against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    exceptionMatcher - The exception matcher to apply onto the matched method's generic exceptions.
    
    Returns:
    
    A matcher that applies the provided matcher to a method's generic exception types.
  - isInterface
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> isInterface()
```
    Matches a TypeDescription that is an interface.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for an interface.
  - isMethod
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isMethod()
```
    Only matches method descriptions that represent a Method.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches method descriptions that represent a Java method.
  - isConstructor
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isConstructor()
```
    Only matches method descriptions that represent a Constructor.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches method descriptions that represent a Java constructor.
  - isTypeInitializer
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isTypeInitializer()
```
    Only matches method descriptions that represent a Class type initializer.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches method descriptions that represent the type initializer.
  - isVirtual
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isVirtual()
```
    Matches any method that is virtual, i.e. non-constructors that are non-static and non-private.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher for virtual methods.
  - isDefaultMethod
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isDefaultMethod()
```
    Only matches Java 8 default methods.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches Java 8 default methods.
  - isDefaultConstructor
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isDefaultConstructor()
```
    Matches a default constructor, i.e. a constructor without arguments.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that matches a default constructor.
  - isDefaultFinalizer
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isDefaultFinalizer()
```
    Only matches the Object.finalize() method if it was not overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches a non-overridden Object.finalize() method.
  - isFinalizer
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isFinalizer()
```
    Only matches the Object.finalize() method, even if it was overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the Object.finalize() method.
  - isHashCode
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isHashCode()
```
    Only matches the Object.toString() method, also if it was overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the Object.toString() method.
  - isEquals
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isEquals()
```
    Only matches the Object.equals(Object) method, also if it was overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the Object.equals(Object) method.
  - isClone
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isClone()
```
    Only matches the Object.clone() method, also if it was overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the Object.clone() method.
  - isToString
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isToString()
```
    Only matches the Object.toString() method, also if it was overridden.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the Object.toString() method.
  - isSetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter()
```
    Matches any Java bean setter method.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that matches any setter method.
  - isSetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter(Type type)
```
    Matches any Java bean setter method which takes an argument the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The required setter type.
    
    Returns:
    
    A matcher that matches any setter method.
  - isSetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter(TypeDescription.Generic type)
```
    Matches any Java bean setter method which takes an argument the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The required setter type.
    
    Returns:
    
    A matcher that matches a setter method with the specified argument type.
  - isSetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isSetter(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches any Java bean setter method which takes an argument that matches the supplied matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to be allied to a setter method's argument type.
    
    Returns:
    
    A matcher that matches a setter method with an argument type that matches the supplied matcher.
  - isGetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isGetter()
```
    Matches any Java bean getter method.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that matches any getter method.
  - isGetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isGetter(Type type)
```
    Matches any Java bean getter method which returns the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The required getter type.
    
    Returns:
    
    A matcher that matches a getter method with the given type.
  - isGetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isGetter(TypeDescription.Generic type)
```
    Matches any Java bean getter method which returns the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The required getter type.
    
    Returns:
    
    A matcher that matches a getter method with the given type.
  - isGetter
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> isGetter(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches any Java bean getter method which returns an value with a type matches the supplied matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to be allied to a getter method's argument type.
    
    Returns:
    
    A matcher that matches a getter method with a return type that matches the supplied matcher.
  - hasMethodName
```
public static <T extends MethodDescription> ElementMatcher.Junction<T> hasMethodName(String internalName)
```
    Matches a method against its internal name such that constructors and type initializers are matched appropriately.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    internalName - The internal name of the method.
    
    Returns:
    
    A matcher for a method with the provided internal name.
  - isSubTypeOf
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> isSubTypeOf(Class<?> type)
```
    Matches any type description that is a subtype of the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to be checked being a super type of the matched type.
    
    Returns:
    
    A matcher that matches any type description that represents a sub type of the given type.
  - isSubTypeOf
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> isSubTypeOf(TypeDescription type)
```
    Matches any type description that is a subtype of the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to be checked being a super type of the matched type.
    
    Returns:
    
    A matcher that matches any type description that represents a sub type of the given type.
  - isSuperTypeOf
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> isSuperTypeOf(Class<?> type)
```
    Matches any type description that is a super type of the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to be checked being a subtype of the matched type.
    
    Returns:
    
    A matcher that matches any type description that represents a super type of the given type.
  - isSuperTypeOf
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> isSuperTypeOf(TypeDescription type)
```
    Matches any type description that is a super type of the given type.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The type to be checked being a subtype of the matched type.
    
    Returns:
    
    A matcher that matches any type description that represents a super type of the given type.
  - inheritsAnnotation
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> inheritsAnnotation(Class<?> type)
```
    Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The annotation type to be matched.
    
    Returns:
    
    A matcher that matches any inherited annotation by their type.
  - inheritsAnnotation
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> inheritsAnnotation(TypeDescription type)
```
    Matches any annotations by their type on a type that declared these annotations or inherited them from its super classes.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    type - The annotation type to be matched.
    
    Returns:
    
    A matcher that matches any inherited annotation by their type.
  - inheritsAnnotation
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> inheritsAnnotation(ElementMatcher<? super TypeDescription> matcher)
```
    Matches any annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to apply onto the inherited annotations.
    
    Returns:
    
    A matcher that matches any inherited annotation by a given matcher.
  - hasAnnotation
```
public static <T extends TypeDescription> ElementMatcher.Junction<T> hasAnnotation(ElementMatcher<? super AnnotationDescription> matcher)
```
    Matches a list of annotations by a given matcher on a type that declared these annotations or inherited them from its super classes.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher to apply onto a list of inherited annotations.
    
    Returns:
    
    A matcher that matches a list of inherited annotation by a given matcher.
  - declaresField
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> declaresField(ElementMatcher<? super FieldDescription> fieldMatcher)
```
    Matches a type by a another matcher that is applied on any of its declared fields.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    fieldMatcher - The matcher that is applied onto each declared field.
    
    Returns:
    
    A matcher that matches any type where another matcher is matched positively on at least on declared field.
  - declaresMethod
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> declaresMethod(ElementMatcher<? super MethodDescription> methodMatcher)
```
    Matches a type by a another matcher that is applied on any of its declared methods.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    methodMatcher - The matcher that is applied onto each declared method.
    
    Returns:
    
    A matcher that matches any type where another matcher is matched positively on at least on declared methods.
  - ofSort
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> ofSort(TypeDefinition.Sort sort)
```
    Matches generic type descriptions of the given sort.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    sort - The generic type sort to match.
    
    Returns:
    
    A matcher that matches generic types of the given sort.
  - ofSort
```
public static <T extends TypeDefinition> ElementMatcher.Junction<T> ofSort(ElementMatcher<? super TypeDefinition.Sort> matcher)
```
    Matches generic type descriptions of the given sort.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - A matcher for a generic type's sort.
    
    Returns:
    
    A matcher that matches generic types of the given sort.
  - genericFieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> genericFieldType(Type fieldType)
```
    Matches a field's generic type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    fieldType - The field type to match.
    
    Returns:
    
    A matcher matching the provided field type.
  - genericFieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> genericFieldType(TypeDescription.Generic fieldType)
```
    Matches a field's generic type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    fieldType - The field type to match.
    
    Returns:
    
    A matcher matching the provided field type.
  - genericFieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> genericFieldType(ElementMatcher<? super TypeDescription.Generic> matcher)
```
    Matches a field's generic type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to the field's type.
    
    Returns:
    
    A matcher matching the provided field type.
  - fieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> fieldType(Class<?> fieldType)
```
    Matches a field's raw type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    fieldType - The field type to match.
    
    Returns:
    
    A matcher matching the provided field type.
  - fieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> fieldType(TypeDescription fieldType)
```
    Matches a field's raw type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    fieldType - The field type to match.
    
    Returns:
    
    A matcher matching the provided field type.
  - fieldType
```
public static <T extends FieldDescription> ElementMatcher.Junction<T> fieldType(ElementMatcher<? super TypeDescription> matcher)
```
    Matches a field's raw type against the provided matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to the field's type.
    
    Returns:
    
    A matcher matching the provided field type.
  - isBootstrapClassLoader
```
public static <T extends ClassLoader> ElementMatcher<T> isBootstrapClassLoader()
```
    Matches exactly the bootstrap ClassLoader . The returned matcher is a synonym to a matcher matching null.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the bootstrap class loader.
  - isSystemClassLoader
```
public static <T extends ClassLoader> ElementMatcher<T> isSystemClassLoader()
```
    Matches exactly the system ClassLoader. The returned matcher is a synonym to a matcher matching ClassLoader.gerSystemClassLoader().
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the system class loader.
  - isExtensionClassLoader
```
public static <T extends ClassLoader> ElementMatcher<T> isExtensionClassLoader()
```
    Matches exactly the extension ClassLoader. The returned matcher is a synonym to a matcher matching ClassLoader.gerSystemClassLoader().getParent().
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Returns:
    
    A matcher that only matches the extension class loader.
  - isChildOf
```
public static <T extends ClassLoader> ElementMatcher<T> isChildOf(ClassLoader classLoader)
```
    Matches any class loader that is either the given class loader or a child of the given class loader.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    classLoader - The class loader of which child class loaders are matched.
    
    Returns:
    
    A matcher that matches the given class loader and any class loader that is a child of the given class loader.
  - hasChild
```
public static <T extends ClassLoader> ElementMatcher<T> hasChild(ElementMatcher<? super ClassLoader> matcher)
```
    Matches all class loaders in the hierarchy of the matched class loader against a given matcher.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    matcher - The matcher to apply to all class loaders in the hierarchy of the matched class loader.
    
    Returns:
    
    A matcher that matches all class loaders in the hierarchy of the matched class loader.
  - isParentOf
```
public static <T extends ClassLoader> ElementMatcher<T> isParentOf(ClassLoader classLoader)
```
    Matches any class loader that is either the given class loader or a parent of the given class loader.
    
    Type Parameters:
    
    T - The type of the matched object.
    
    Parameters:
    
    classLoader - The class loader of which parent class loaders are matched.
    
    Returns:
    
    A matcher that matches the given class loader and any class loader that is a parent of the given class loader.

Class ElementMatchers

Method Summary

Methods inherited from class java.lang.Object

Method Detail

failSafe

is

is

definedField

is

is

definedMethod

definedParameter

hasType

hasGenericType

is

is

not

any

none

anyOf

anyOf

anyOf

anyOf

anyOf

anyOf

anyOf

noneOf

noneOf

noneOf

noneOf

noneOf

noneOf

noneOf

whereAny

whereNone

rawType

rawType

rawType

rawTypes

rawTypes

rawTypes

rawTypes

isVariable

isVariable

named

namedIgnoreCase

nameStartsWith

nameStartsWithIgnoreCase

nameEndsWith

nameEndsWithIgnoreCase

nameContains

nameContainsIgnoreCase

nameMatches

hasDescriptor

isDeclaredBy

isDeclaredBy

isDeclaredBy

isDeclaredByGeneric

isDeclaredByGeneric

isDeclaredByGeneric

isVisibleTo

isVisibleTo

isAbstract

isAnnotatedWith

isAnnotatedWith

isAnnotatedWith

declaresAnnotation

isPublic

isProtected

isPackagePrivate

isPrivate

isFinal

isStatic

isSynthetic

isSynchronized

isNative

isStrict

isVarArgs

isBridge

returnsGeneric