ClassesThat (archunit 0.5.0 API)

All Known Subinterfaces:

ClassesShouldThat, GivenClassesThat
```
public interface ClassesThat<CONJUNCTION>
```

Method Summary

Methods
Modifier and Type	Method and Description
`CONJUNCTION`	`areAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Matches classes annotated with a certain type of annotation.
`CONJUNCTION`	`areAnnotatedWith(DescribedPredicate<? super JavaAnnotation> predicate)` Matches classes annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
`CONJUNCTION`	`areAnnotatedWith(java.lang.String annotationTypeName)` Matches classes annotated with a certain type of annotation.
`CONJUNCTION`	`areAssignableFrom(java.lang.Class<?> type)` Matches classes assignable from a certain type (compare `Class.isAssignableFrom(Class)` to terminology).
`CONJUNCTION`	`areAssignableFrom(DescribedPredicate<? super JavaClass> predicate)` Matches classes assignable from a certain type matching the given predicate.
`CONJUNCTION`	`areAssignableFrom(java.lang.String typeName)` Matches classes assignable from a certain type with the given type name.
`CONJUNCTION`	`areAssignableTo(java.lang.Class<?> type)` Matches classes assignable to a certain type (compare `Class.isAssignableFrom(Class)` to terminology).
`CONJUNCTION`	`areAssignableTo(DescribedPredicate<? super JavaClass> predicate)` Matches classes assignable to a certain type matching the given predicate.
`CONJUNCTION`	`areAssignableTo(java.lang.String typeName)` Matches classes assignable to a certain type with the given type name.
`CONJUNCTION`	`areInterfaces()` Matches interfaces.
`CONJUNCTION`	`areNotAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)` Matches classes not annotated with a certain type of annotation.
`CONJUNCTION`	`areNotAnnotatedWith(DescribedPredicate<? super JavaAnnotation> predicate)` Matches classes not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
`CONJUNCTION`	`areNotAnnotatedWith(java.lang.String annotationTypeName)` Matches classes not annotated with a certain type of annotation.
`CONJUNCTION`	`areNotAssignableFrom(java.lang.Class<?> type)` Matches classes not assignable from a certain type.
`CONJUNCTION`	`areNotAssignableFrom(DescribedPredicate<? super JavaClass> predicate)` Matches classes not assignable from a certain type matching the given predicate.
`CONJUNCTION`	`areNotAssignableFrom(java.lang.String typeName)` Matches classes not assignable from a certain type with the given type name.
`CONJUNCTION`	`areNotAssignableTo(java.lang.Class<?> type)` Matches classes not assignable to a certain type.
`CONJUNCTION`	`areNotAssignableTo(DescribedPredicate<? super JavaClass> predicate)` Matches classes not assignable to a certain type matching the given predicate.
`CONJUNCTION`	`areNotAssignableTo(java.lang.String typeName)` Matches classes not assignable to a certain type with the given type name.
`CONJUNCTION`	`areNotInterfaces()` Matches everything except interfaces.
`CONJUNCTION`	`areNotPackagePrivate()` Matches non-package private classes.
`CONJUNCTION`	`areNotPrivate()` Matches non-private classes.
`CONJUNCTION`	`areNotProtected()` Matches non-protected classes.
`CONJUNCTION`	`areNotPublic()` Matches non-public classes.
`CONJUNCTION`	`arePackagePrivate()` Matches package private classes.
`CONJUNCTION`	`arePrivate()` Matches private classes.
`CONJUNCTION`	`areProtected()` Matches protected classes.
`CONJUNCTION`	`arePublic()` Matches public classes.
`CONJUNCTION`	`dontHaveFullyQualifiedName(java.lang.String name)` Matches classes that don't have a certain fully qualified class name.
`CONJUNCTION`	`dontHaveModifier(JavaModifier modifier)` Matches classes not having a certain `JavaModifier` (e.g.
`CONJUNCTION`	`dontHaveSimpleName(java.lang.String name)` Matches classes that don't have a certain simple class name.
`CONJUNCTION`	`dontImplement(java.lang.Class<?> type)` Matches classes that don't implement a certain interface.
`CONJUNCTION`	`dontImplement(DescribedPredicate<? super JavaClass> predicate)` Matches classes that don't implement a certain interface matching the given predicate.
`CONJUNCTION`	`dontImplement(java.lang.String typeName)` Matches classes that don't implement a certain interface with the given type name.
`CONJUNCTION`	`haveFullyQualifiedName(java.lang.String name)` Matches classes by their fully qualified class name.
`CONJUNCTION`	`haveModifier(JavaModifier modifier)` Matches classes having a certain `JavaModifier` (e.g.
`CONJUNCTION`	`haveNameMatching(java.lang.String regex)` Matches classes with a fully qualified class name matching a given regular expression.
`CONJUNCTION`	`haveNameNotMatching(java.lang.String regex)` Matches classes with a fully qualified class name not matching a given regular expression.
`CONJUNCTION`	`haveSimpleName(java.lang.String name)` Matches classes by their simple class name.
`CONJUNCTION`	`haveSimpleNameContaining(java.lang.String infix)` Matches classes with a simple class name containing the specified infix.
`CONJUNCTION`	`haveSimpleNameEndingWith(java.lang.String suffix)` Matches classes with a simple class name ending with a given suffix.
`CONJUNCTION`	`haveSimpleNameNotContaining(java.lang.String infix)` Matches classes with a simple class name not containing the specified infix.
`CONJUNCTION`	`haveSimpleNameNotEndingWith(java.lang.String suffix)` Matches classes with a simple class name not ending with a given suffix.
`CONJUNCTION`	`haveSimpleNameNotStartingWith(java.lang.String prefix)` Matches classes with a simple class name not starting with a given prefix.
`CONJUNCTION`	`haveSimpleNameStartingWith(java.lang.String prefix)` Matches classes with a simple class name starting with a given prefix.
`CONJUNCTION`	`implement(java.lang.Class<?> type)` Matches classes that implement a certain interface.
`CONJUNCTION`	`implement(DescribedPredicate<? super JavaClass> predicate)` Matches classes that implement a certain interface matching the given predicate.
`CONJUNCTION`	`implement(java.lang.String typeName)` Matches classes that implement a certain interface with the given type name.
`CONJUNCTION`	`resideInAnyPackage(java.lang.String... packageIdentifiers)` Matches classes residing in a package matching any of the supplied package identifiers.
`CONJUNCTION`	`resideInAPackage(java.lang.String packageIdentifier)` Matches classes residing in a package matching the supplied package identifier.
`CONJUNCTION`	`resideOutsideOfPackage(java.lang.String packageIdentifier)` Matches classes not residing in a package matching the supplied package identifier.
`CONJUNCTION`	`resideOutsideOfPackages(java.lang.String... packageIdentifiers)` Matches classes not residing in a package matching any of the supplied package identifiers.

- Method Detail
  - haveFullyQualifiedName
```
CONJUNCTION haveFullyQualifiedName(java.lang.String name)
```
    Matches classes by their fully qualified class name.
    
    Parameters:
    name - The fully qualified class name
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontHaveFullyQualifiedName
```
CONJUNCTION dontHaveFullyQualifiedName(java.lang.String name)
```
    Matches classes that don't have a certain fully qualified class name.
    
    Parameters:
    name - The fully qualified class name
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleName
```
CONJUNCTION haveSimpleName(java.lang.String name)
```
    Matches classes by their simple class name.
    
    Parameters:
    name - The simple class name
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontHaveSimpleName
```
CONJUNCTION dontHaveSimpleName(java.lang.String name)
```
    Matches classes that don't have a certain simple class name.
    
    Parameters:
    name - The simple class name
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveNameMatching
```
CONJUNCTION haveNameMatching(java.lang.String regex)
```
    Matches classes with a fully qualified class name matching a given regular expression.
    
    Parameters:
    regex - A regular expression
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveNameNotMatching
```
CONJUNCTION haveNameNotMatching(java.lang.String regex)
```
    Matches classes with a fully qualified class name not matching a given regular expression.
    
    Parameters:
    regex - A regular expression
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameStartingWith
```
CONJUNCTION haveSimpleNameStartingWith(java.lang.String prefix)
```
    Matches classes with a simple class name starting with a given prefix.
    
    Parameters:
    prefix - A prefix the simple class name should start with
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameNotStartingWith
```
CONJUNCTION haveSimpleNameNotStartingWith(java.lang.String prefix)
```
    Matches classes with a simple class name not starting with a given prefix.
    
    Parameters:
    prefix - A prefix the simple class name should not start with
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameContaining
```
CONJUNCTION haveSimpleNameContaining(java.lang.String infix)
```
    Matches classes with a simple class name containing the specified infix.
    
    Parameters:
    infix - An infix the simple class name should contain
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameNotContaining
```
CONJUNCTION haveSimpleNameNotContaining(java.lang.String infix)
```
    Matches classes with a simple class name not containing the specified infix.
    
    Parameters:
    infix - An infix the simple class name should not contain
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameEndingWith
```
CONJUNCTION haveSimpleNameEndingWith(java.lang.String suffix)
```
    Matches classes with a simple class name ending with a given suffix.
    
    Parameters:
    suffix - A suffix the simple class name should end with
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveSimpleNameNotEndingWith
```
CONJUNCTION haveSimpleNameNotEndingWith(java.lang.String suffix)
```
    Matches classes with a simple class name not ending with a given suffix.
    
    Parameters:
    suffix - A suffix the simple class name should not end with
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - resideInAPackage
```
CONJUNCTION resideInAPackage(java.lang.String packageIdentifier)
```
    Matches classes residing in a package matching the supplied package identifier.
    
    Parameters:
    packageIdentifier - A string identifying packages, for details see PackageMatcher
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - resideInAnyPackage
```
CONJUNCTION resideInAnyPackage(java.lang.String... packageIdentifiers)
```
    Matches classes residing in a package matching any of the supplied package identifiers.
    
    Parameters:
    packageIdentifiers - Strings identifying packages, for details see PackageMatcher
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - resideOutsideOfPackage
```
CONJUNCTION resideOutsideOfPackage(java.lang.String packageIdentifier)
```
    Matches classes not residing in a package matching the supplied package identifier.
    
    Parameters:
    packageIdentifier - A string identifying packages, for details see PackageMatcher
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - resideOutsideOfPackages
```
CONJUNCTION resideOutsideOfPackages(java.lang.String... packageIdentifiers)
```
    Matches classes not residing in a package matching any of the supplied package identifiers.
    
    Parameters:
    packageIdentifiers - Strings identifying packages, for details see PackageMatcher
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - arePublic
```
CONJUNCTION arePublic()
```
    Matches public classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotPublic
```
CONJUNCTION areNotPublic()
```
    Matches non-public classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areProtected
```
CONJUNCTION areProtected()
```
    Matches protected classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotProtected
```
CONJUNCTION areNotProtected()
```
    Matches non-protected classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - arePackagePrivate
```
CONJUNCTION arePackagePrivate()
```
    Matches package private classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotPackagePrivate
```
CONJUNCTION areNotPackagePrivate()
```
    Matches non-package private classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - arePrivate
```
CONJUNCTION arePrivate()
```
    Matches private classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotPrivate
```
CONJUNCTION areNotPrivate()
```
    Matches non-private classes.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - haveModifier
```
CONJUNCTION haveModifier(JavaModifier modifier)
```
    Matches classes having a certain JavaModifier (e.g. JavaModifier.ABSTRACT).
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontHaveModifier
```
CONJUNCTION dontHaveModifier(JavaModifier modifier)
```
    Matches classes not having a certain JavaModifier (e.g. JavaModifier.ABSTRACT).
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAnnotatedWith
```
CONJUNCTION areAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Matches classes annotated with a certain type of annotation.
    
    Parameters:
    annotationType - Specific type of Annotation
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAnnotatedWith
```
CONJUNCTION areNotAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
```
    Matches classes not annotated with a certain type of annotation.
    
    Parameters:
    annotationType - Specific type of Annotation
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAnnotatedWith
```
CONJUNCTION areAnnotatedWith(java.lang.String annotationTypeName)
```
    Matches classes annotated with a certain type of annotation.
    
    Parameters:
    annotationTypeName - Fully qualified class name of a specific type of Annotation
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAnnotatedWith
```
CONJUNCTION areNotAnnotatedWith(java.lang.String annotationTypeName)
```
    Matches classes not annotated with a certain type of annotation.
    
    Parameters:
    annotationTypeName - Fully qualified class name of a specific type of Annotation
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAnnotatedWith
```
CONJUNCTION areAnnotatedWith(DescribedPredicate<? super JavaAnnotation> predicate)
```
    Matches classes annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
    
    Parameters:
    predicate - A predicate defining matching JavaAnnotations
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAnnotatedWith
```
CONJUNCTION areNotAnnotatedWith(DescribedPredicate<? super JavaAnnotation> predicate)
```
    Matches classes not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
    
    Parameters:
    predicate - A predicate defining matching JavaAnnotations
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - implement
```
CONJUNCTION implement(java.lang.Class<?> type)
```
    Matches classes that implement a certain interface.
    
    Parameters:
    type - An interface type matching classes must implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontImplement
```
CONJUNCTION dontImplement(java.lang.Class<?> type)
```
    Matches classes that don't implement a certain interface. This is the negation of implement(Class).
    
    Parameters:
    type - An interface type matching classes must not implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - implement
```
CONJUNCTION implement(java.lang.String typeName)
```
    Matches classes that implement a certain interface with the given type name. This is equivalent to implement(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of an interface type matching classes must implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontImplement
```
CONJUNCTION dontImplement(java.lang.String typeName)
```
    Matches classes that don't implement a certain interface with the given type name. This is equivalent to dontImplement(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of an interface type matching classes must not implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - implement
```
CONJUNCTION implement(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes that implement a certain interface matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to implement(String), but the approach is a lot more generic.
    
    Parameters:
    predicate - A predicate identifying interfaces matching classes must implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - dontImplement
```
CONJUNCTION dontImplement(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes that don't implement a certain interface matching the given predicate. This is the negation of implement(DescribedPredicate).
    
    Parameters:
    predicate - A predicate identifying interfaces matching classes must not implement
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableTo
```
CONJUNCTION areAssignableTo(java.lang.Class<?> type)
```
    Matches classes assignable to a certain type (compare Class.isAssignableFrom(Class) to terminology). A simple example for this predicate would be
```
   assignableTo(Object.class).apply(importedStringClass); // --> returns true
   assignableTo(String.class).apply(importedStringClass); // --> returns true
   assignableTo(List.class).apply(importedStringClass); // --> returns false
 
```
    Parameters:
    type - An upper type bound to match imported classes against (imported subtypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableTo
```
CONJUNCTION areNotAssignableTo(java.lang.Class<?> type)
```
    Matches classes not assignable to a certain type. This is the negation of areAssignableTo(Class).
    
    Parameters:
    type - An upper type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableTo
```
CONJUNCTION areAssignableTo(java.lang.String typeName)
```
    Matches classes assignable to a certain type with the given type name. This is equivalent to areAssignableTo(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of an upper type bound to match imported classes against (imported subtypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableTo
```
CONJUNCTION areNotAssignableTo(java.lang.String typeName)
```
    Matches classes not assignable to a certain type with the given type name. This is equivalent to areNotAssignableTo(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of an upper type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableTo
```
CONJUNCTION areAssignableTo(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes assignable to a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to areAssignableTo(String), but the approach is a lot more generic.
    
    Parameters:
    predicate - A predicate identifying an upper type bound to match imported classes against (imported subtypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableTo
```
CONJUNCTION areNotAssignableTo(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes not assignable to a certain type matching the given predicate. This is the negation of areAssignableTo(DescribedPredicate).
    
    Parameters:
    predicate - A predicate identifying an upper type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableFrom
```
CONJUNCTION areAssignableFrom(java.lang.Class<?> type)
```
    Matches classes assignable from a certain type (compare Class.isAssignableFrom(Class) to terminology). This is roughly equivalent to the use of reflection:
```
   someClass.class.isAssignableFrom(type);
 
```
    A simple example for this predicate would be
```
   assignableFrom(ArrayList.class).apply(importedArrayListClass); // --> returns true
   assignableFrom(ArrayList.class).apply(importedListClass); // --> returns true
   assignableFrom(ArrayList.class).apply(importedStringClass); // --> returns false
 
```
    Parameters:
    type - A lower type bound to match imported classes against (imported supertypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableFrom
```
CONJUNCTION areNotAssignableFrom(java.lang.Class<?> type)
```
    Matches classes not assignable from a certain type. This is the negation of areAssignableFrom(Class).
    
    Parameters:
    type - A lower type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableFrom
```
CONJUNCTION areAssignableFrom(java.lang.String typeName)
```
    Matches classes assignable from a certain type with the given type name. This is equivalent to areAssignableFrom(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of a lower type bound to match imported classes against (imported supertypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableFrom
```
CONJUNCTION areNotAssignableFrom(java.lang.String typeName)
```
    Matches classes not assignable from a certain type with the given type name. This is equivalent to areNotAssignableFrom(Class), but doesn't depend on having a certain type on the classpath.
    
    Parameters:
    typeName - Name of a lower type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areAssignableFrom
```
CONJUNCTION areAssignableFrom(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes assignable from a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to areAssignableFrom(String), but the approach is a lot more generic.
    
    Parameters:
    predicate - A predicate identifying a lower type bound to match imported classes against (imported supertypes will match)
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotAssignableFrom
```
CONJUNCTION areNotAssignableFrom(DescribedPredicate<? super JavaClass> predicate)
```
    Matches classes not assignable from a certain type matching the given predicate. This is the negation of areAssignableFrom(DescribedPredicate).
    
    Parameters:
    predicate - A predicate identifying a lower type bound imported classes should NOT have
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areInterfaces
```
CONJUNCTION areInterfaces()
```
    Matches interfaces.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule
  - areNotInterfaces
```
CONJUNCTION areNotInterfaces()
```
    Matches everything except interfaces.
    
    Returns:
    A syntax conjunction element, which can be completed to form a full rule

Interface ClassesThat<CONJUNCTION>

Method Summary

Method Detail

haveFullyQualifiedName

dontHaveFullyQualifiedName

haveSimpleName

dontHaveSimpleName

haveNameMatching

haveNameNotMatching

haveSimpleNameStartingWith

haveSimpleNameNotStartingWith

haveSimpleNameContaining

haveSimpleNameNotContaining

haveSimpleNameEndingWith

haveSimpleNameNotEndingWith

resideInAPackage

resideInAnyPackage

resideOutsideOfPackage

resideOutsideOfPackages

arePublic

areNotPublic

areProtected

areNotProtected

arePackagePrivate

areNotPackagePrivate

arePrivate

areNotPrivate

haveModifier

dontHaveModifier

areAnnotatedWith

areNotAnnotatedWith

areAnnotatedWith

areNotAnnotatedWith

areAnnotatedWith

areNotAnnotatedWith

implement

dontImplement

implement

dontImplement

implement

dontImplement

areAssignableTo

areNotAssignableTo

areAssignableTo

areNotAssignableTo

areAssignableTo

areNotAssignableTo

areAssignableFrom

areNotAssignableFrom

areAssignableFrom

areNotAssignableFrom

areAssignableFrom

areNotAssignableFrom

areInterfaces

areNotInterfaces