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

Interface ClassesThat<CONJUNCTION>

public interface ClassesThat<CONJUNCTION>

  • Method Details

    • haveFullyQualifiedName

      @PublicAPI(usage=ACCESS) CONJUNCTION haveFullyQualifiedName(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(Class<? extends 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(Class<? extends 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(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(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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.
      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(Class<? extends Annotation> annotationType)
      Matches classes meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

      This also matches classes that are directly annotated with the supplied annotation type.

      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(Class<? extends 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.

      Matching classes may also not directly be annotated with the supplied annotation type.

      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(String annotationTypeName)
      Matches classes meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.

      This also matches classes that are directly annotated with the supplied annotation type.

      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(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.

      Matching classes may also not directly be annotated with the supplied annotation type.

      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.

      This also matches classes where a direct annotation matches the supplied predicate.



      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.
      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.

      Matching classes may also not be annotated with a direct annotation matching the supplied predicate.



      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaAnnotation can be found within one of the respective ancestors like HasType.Predicates.
      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(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(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(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(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)

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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).

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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(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).test(importedStringClass); // --> returns true
   assignableTo(String.class).test(importedStringClass); // --> returns true
   assignableTo(List.class).test(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(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(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(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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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).

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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(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).test(importedArrayListClass); // --> returns true
   assignableFrom(ArrayList.class).test(importedListClass); // --> returns true
   assignableFrom(ArrayList.class).test(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(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(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(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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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).

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaClass can be found within JavaClass.Predicates or one of the respective ancestors like HasName.Predicates.
      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:

    • 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:

    • 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(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(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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaMember can be found within JavaMember.Predicates or one of the respective ancestors like HasName.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaField can be found within JavaMember.Predicates or one of the respective ancestors like HasName.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaCodeUnit can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaMethod can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaConstructor can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.
      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.

      Note that many predefined predicates can be found within a subclass Predicates of the respective domain object or a common ancestor. For example, predicates targeting JavaStaticInitializer can be found within JavaCodeUnit.Predicates or one of the respective ancestors like JavaMember.Predicates.
      Parameters:
      predicate - A predicate defining matching JavaStaticInitializers
      Returns:
      A syntax conjunction element, which can be completed to form a full rule