Package com.tngtech.archunit.lang.syntax.elements

Interface ClassesThat<CONJUNCTION>

public interface ClassesThat<CONJUNCTION>

  • Method Details

    • haveFullyQualifiedName

      @PublicAPI(usage=ACCESS) 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

    • doNotHaveFullyQualifiedName

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveFullyQualifiedName​(java.lang.String name)
      Matches classes that do not 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

      @PublicAPI(usage=ACCESS) 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

    • doNotHaveSimpleName

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveSimpleName​(java.lang.String name)
      Matches classes that do not 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) CONJUNCTION arePublic()
      Matches public classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotPublic

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotPublic()
      Matches non-public classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areProtected

      @PublicAPI(usage=ACCESS) CONJUNCTION areProtected()
      Matches protected classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotProtected

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotProtected()
      Matches non-protected classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • arePackagePrivate

      @PublicAPI(usage=ACCESS) CONJUNCTION arePackagePrivate()
      Matches package private classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotPackagePrivate

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotPackagePrivate()
      Matches non-package private classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • arePrivate

      @PublicAPI(usage=ACCESS) CONJUNCTION arePrivate()
      Matches private classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotPrivate

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotPrivate()
      Matches non-private classes.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • haveModifier

      @PublicAPI(usage=ACCESS) 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

    • doNotHaveModifier

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveModifier​(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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

    • areMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areMetaAnnotatedWith​(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
      Matches classes meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.
      Parameters:
      annotationType - Specific type of Annotation
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotMetaAnnotatedWith​(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
      Matches classes not meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.
      Parameters:
      annotationType - Specific type of Annotation
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areMetaAnnotatedWith​(java.lang.String annotationTypeName)
      Matches classes meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another 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

    • areNotMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotMetaAnnotatedWith​(java.lang.String annotationTypeName)
      Matches classes not meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another 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

    • areMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areMetaAnnotatedWith​(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Matches classes meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.
      Parameters:
      predicate - A predicate defining matching JavaAnnotations
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotMetaAnnotatedWith

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotMetaAnnotatedWith​(DescribedPredicate<? super JavaAnnotation<?>> predicate)
      Matches classes not meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate. A meta-annotation is an annotation that is declared on another annotation.
      Parameters:
      predicate - A predicate defining matching JavaAnnotations
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • implement

      @PublicAPI(usage=ACCESS) CONJUNCTION implement​(java.lang.Class<?> type)
      Matches classes that implement a certain interface. Note that this only matches non-interface classes that implement the supplied interface type (compare JavaClass.Predicates.implement(Class). For general assignability see areAssignableTo(Class)
      Parameters:
      type - An interface type matching classes must implement
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • doNotImplement

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotImplement​(java.lang.Class<?> type)
      Matches classes that do not 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

      @PublicAPI(usage=ACCESS) 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 does not depend on having a certain type on the classpath. Note that this only matches non-interface classes that implement the supplied interface typeName (compare JavaClass.Predicates.implement(Class). For general assignability see areAssignableTo(String)
      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

    • doNotImplement

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotImplement​(java.lang.String typeName)
      Matches classes that do not implement a certain interface with the given type name. This is equivalent to doNotImplement(Class), but does not 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

      @PublicAPI(usage=ACCESS) 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. Note that this only matches non-interface classes that implement an interface matching the predicate (compare JavaClass.Predicates.implement(Class). For general assignability see areAssignableTo(DescribedPredicate)
      Parameters:
      predicate - A predicate identifying interfaces matching classes must implement
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • doNotImplement

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotImplement​(DescribedPredicate<? super JavaClass> predicate)
      Matches classes that do not 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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 does not 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

      @PublicAPI(usage=ACCESS) 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 does not 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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 does not 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

      @PublicAPI(usage=ACCESS) 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 does not 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) 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

      @PublicAPI(usage=ACCESS) CONJUNCTION areInterfaces()
      Matches interfaces.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotInterfaces

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotInterfaces()
      Matches everything except interfaces.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areEnums

      @PublicAPI(usage=ACCESS) CONJUNCTION areEnums()
      Matches enums.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotEnums

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotEnums()
      Matches everything except enums.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areAnnotations

      @PublicAPI(usage=ACCESS) CONJUNCTION areAnnotations()
      Matches annotations.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areNotAnnotations

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotAnnotations()
      Matches everything except annotations.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • areRecords

      @PublicAPI(usage=ACCESS) CONJUNCTION areRecords()
      Matches records.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule
      See Also:
      JavaClass.isRecord()

    • areNotRecords

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotRecords()
      Matches everything except records.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule
      See Also:
      JavaClass.isRecord()

    • areTopLevelClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areTopLevelClasses()

    • areNotTopLevelClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotTopLevelClasses()

    • areNestedClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNestedClasses()

    • areNotNestedClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotNestedClasses()

    • areMemberClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areMemberClasses()

    • areNotMemberClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotMemberClasses()

    • areInnerClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areInnerClasses()

    • areNotInnerClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotInnerClasses()

    • areAnonymousClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areAnonymousClasses()

    • areNotAnonymousClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotAnonymousClasses()

    • areLocalClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areLocalClasses()

    • areNotLocalClasses

      @PublicAPI(usage=ACCESS) CONJUNCTION areNotLocalClasses()

    • belongToAnyOf

      @PublicAPI(usage=ACCESS) CONJUNCTION belongToAnyOf​(java.lang.Class<?>... classes)
      Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested. E.g. consider 
      
 class Outer {
     class Inner {
         class EvenMoreInner {
         }
     }
 }
      Then belongToAnyOf(Outer.class) would match the JavaClass Outer but also Inner and EvenMoreInner. Likewise would hold for any anonymous inner classes.
      Parameters:
      classes - List of Class objects.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • doNotBelongToAnyOf

      @PublicAPI(usage=ACCESS) CONJUNCTION doNotBelongToAnyOf​(java.lang.Class<?>... classes)
      Inverted form of belongToAnyOf(Outer.class)
      Parameters:
      classes - List of Class objects.
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyMembersThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyMembersThat​(DescribedPredicate<? super JavaMember> predicate)
      Matches classes that contain any member matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaMembers
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyFieldsThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyFieldsThat​(DescribedPredicate<? super JavaField> predicate)
      Matches classes that contain any field matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaFields
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyCodeUnitsThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyCodeUnitsThat​(DescribedPredicate<? super JavaCodeUnit> predicate)
      Matches classes that contain any code unit matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaCodeUnits
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyMethodsThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyMethodsThat​(DescribedPredicate<? super JavaMethod> predicate)
      Matches classes that contain any method matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaMethods
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyConstructorsThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyConstructorsThat​(DescribedPredicate<? super JavaConstructor> predicate)
      Matches classes that contain any constructor matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaConstructors
      Returns:
      A syntax conjunction element, which can be completed to form a full rule

    • containAnyStaticInitializersThat

      @PublicAPI(usage=ACCESS) CONJUNCTION containAnyStaticInitializersThat​(DescribedPredicate<? super JavaStaticInitializer> predicate)
      Matches classes that contain a static initializer matching the supplied predicate.
      Parameters:
      predicate - A predicate defining matching JavaStaticInitializers
      Returns:
      A syntax conjunction element, which can be completed to form a full rule