Package com.tngtech.archunit.lang.syntax

Class ClassesThatInternal<CONJUNCTION>

java.lang.Object

com.tngtech.archunit.lang.syntax.ClassesThatInternal<CONJUNCTION>

All Implemented Interfaces:

ClassesThat<CONJUNCTION>

@Internal
public final class ClassesThatInternal<CONJUNCTION>
extends Object
implements ClassesThat<CONJUNCTION>

Constructor Summary

Constructors

Constructor	Description
ClassesThatInternal(Function<DescribedPredicate<? super JavaClass>,CONJUNCTION> addPredicate)

Method Summary

Modifier and Type	Method	Description
CONJUNCTION	areAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Matches classes annotated with a certain annotation, where matching annotations are determined by the supplied predicate.
CONJUNCTION	areAnnotatedWith(Class<? extends Annotation> annotationType)	Matches classes annotated with a certain type of annotation.
CONJUNCTION	areAnnotatedWith(String annotationTypeName)	Matches classes annotated with a certain type of annotation.
CONJUNCTION	areAnnotations()	Matches annotations.
CONJUNCTION	areAnonymousClasses()
CONJUNCTION	areAssignableFrom(DescribedPredicate<? super JavaClass> predicate)	Matches classes assignable from a certain type matching the given predicate.
CONJUNCTION	areAssignableFrom(Class<?> type)	Matches classes assignable from a certain type (compare Class.isAssignableFrom(Class) to terminology).
CONJUNCTION	areAssignableFrom(String typeName)	Matches classes assignable from a certain type with the given type name.
CONJUNCTION	areAssignableTo(DescribedPredicate<? super JavaClass> predicate)	Matches classes assignable to a certain type matching the given predicate.
CONJUNCTION	areAssignableTo(Class<?> type)	Matches classes assignable to a certain type (compare Class.isAssignableFrom(Class) to terminology).
CONJUNCTION	areAssignableTo(String typeName)	Matches classes assignable to a certain type with the given type name.
CONJUNCTION	areEnums()	Matches enums.
CONJUNCTION	areInnerClasses()
CONJUNCTION	areInterfaces()	Matches interfaces.
CONJUNCTION	areLocalClasses()
CONJUNCTION	areMemberClasses()
CONJUNCTION	areMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)	Matches classes meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate.
CONJUNCTION	areMetaAnnotatedWith(Class<? extends Annotation> annotationType)	Matches classes meta-annotated with a certain type of annotation.
CONJUNCTION	areMetaAnnotatedWith(String annotationTypeName)	Matches classes meta-annotated with a certain type of annotation.
CONJUNCTION	areNestedClasses()
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(Class<? extends Annotation> annotationType)	Matches classes not annotated with a certain type of annotation.
CONJUNCTION	areNotAnnotatedWith(String annotationTypeName)	Matches classes not annotated with a certain type of annotation.
CONJUNCTION	areNotAnnotations()	Matches everything except annotations.
CONJUNCTION	areNotAnonymousClasses()
CONJUNCTION	areNotAssignableFrom(DescribedPredicate<? super JavaClass> predicate)	Matches classes not assignable from a certain type matching the given predicate.
CONJUNCTION	areNotAssignableFrom(Class<?> type)	Matches classes not assignable from a certain type.
CONJUNCTION	areNotAssignableFrom(String typeName)	Matches classes not assignable from a certain type with the given type name.
CONJUNCTION	areNotAssignableTo(DescribedPredicate<? super JavaClass> predicate)	Matches classes not assignable to a certain type matching the given predicate.
CONJUNCTION	areNotAssignableTo(Class<?> type)	Matches classes not assignable to a certain type.
CONJUNCTION	areNotAssignableTo(String typeName)	Matches classes not assignable to a certain type with the given type name.
CONJUNCTION	areNotEnums()	Matches everything except enums.
CONJUNCTION	areNotInnerClasses()
CONJUNCTION	areNotInterfaces()	Matches everything except interfaces.
CONJUNCTION	areNotLocalClasses()
CONJUNCTION	areNotMemberClasses()
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.
CONJUNCTION	areNotMetaAnnotatedWith(Class<? extends Annotation> annotationType)	Matches classes not meta-annotated with a certain type of annotation.
CONJUNCTION	areNotMetaAnnotatedWith(String annotationTypeName)	Matches classes not meta-annotated with a certain type of annotation.
CONJUNCTION	areNotNestedClasses()
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	areNotRecords()	Matches everything except records.
CONJUNCTION	areNotTopLevelClasses()
CONJUNCTION	arePackagePrivate()	Matches package private classes.
CONJUNCTION	arePrivate()	Matches private classes.
CONJUNCTION	areProtected()	Matches protected classes.
CONJUNCTION	arePublic()	Matches public classes.
CONJUNCTION	areRecords()	Matches records.
CONJUNCTION	areTopLevelClasses()
CONJUNCTION	belongToAnyOf(Class<?>... classes)	Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested.
CONJUNCTION	containAnyCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)	Matches classes that contain any code unit matching the supplied predicate.
CONJUNCTION	containAnyConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)	Matches classes that contain any constructor matching the supplied predicate.
CONJUNCTION	containAnyFieldsThat(DescribedPredicate<? super JavaField> predicate)	Matches classes that contain any field matching the supplied predicate.
CONJUNCTION	containAnyMembersThat(DescribedPredicate<? super JavaMember> predicate)	Matches classes that contain any member matching the supplied predicate.
CONJUNCTION	containAnyMethodsThat(DescribedPredicate<? super JavaMethod> predicate)	Matches classes that contain any method matching the supplied predicate.
CONJUNCTION	containAnyStaticInitializersThat(DescribedPredicate<? super JavaStaticInitializer> predicate)	Matches classes that contain a static initializer matching the supplied predicate.
CONJUNCTION	doNotBelongToAnyOf(Class<?>... classes)	Inverted form of belongToAnyOf(Outer.class)
CONJUNCTION	doNotHaveFullyQualifiedName(String name)	Matches classes that do not have a certain fully qualified class name.
CONJUNCTION	doNotHaveModifier(JavaModifier modifier)	Matches classes not having a certain JavaModifier (e.g.
CONJUNCTION	doNotHaveSimpleName(String name)	Matches classes that do not have a certain simple class name.
CONJUNCTION	doNotImplement(DescribedPredicate<? super JavaClass> predicate)	Matches classes that do not implement a certain interface matching the given predicate.
CONJUNCTION	doNotImplement(Class<?> type)	Matches classes that do not implement a certain interface.
CONJUNCTION	doNotImplement(String typeName)	Matches classes that do not implement a certain interface with the given type name.
CONJUNCTION	haveFullyQualifiedName(String name)	Matches classes by their fully qualified class name.
CONJUNCTION	haveModifier(JavaModifier modifier)	Matches classes having a certain JavaModifier (e.g.
CONJUNCTION	haveNameMatching(String regex)	Matches classes with a fully qualified class name matching a given regular expression.
CONJUNCTION	haveNameNotMatching(String regex)	Matches classes with a fully qualified class name not matching a given regular expression.
CONJUNCTION	haveSimpleName(String name)	Matches classes by their simple class name.
CONJUNCTION	haveSimpleNameContaining(String infix)	Matches classes with a simple class name containing the specified infix.
CONJUNCTION	haveSimpleNameEndingWith(String suffix)	Matches classes with a simple class name ending with a given suffix.
CONJUNCTION	haveSimpleNameNotContaining(String infix)	Matches classes with a simple class name not containing the specified infix.
CONJUNCTION	haveSimpleNameNotEndingWith(String suffix)	Matches classes with a simple class name not ending with a given suffix.
CONJUNCTION	haveSimpleNameNotStartingWith(String prefix)	Matches classes with a simple class name not starting with a given prefix.
CONJUNCTION	haveSimpleNameStartingWith(String prefix)	Matches classes with a simple class name starting with a given prefix.
CONJUNCTION	implement(DescribedPredicate<? super JavaClass> predicate)	Matches classes that implement a certain interface matching the given predicate.
CONJUNCTION	implement(Class<?> type)	Matches classes that implement a certain interface.
CONJUNCTION	implement(String typeName)	Matches classes that implement a certain interface with the given type name.
CONJUNCTION	resideInAnyPackage(String... packageIdentifiers)	Matches classes residing in a package matching any of the supplied package identifiers.
CONJUNCTION	resideInAPackage(String packageIdentifier)	Matches classes residing in a package matching the supplied package identifier.
CONJUNCTION	resideOutsideOfPackage(String packageIdentifier)	Matches classes not residing in a package matching the supplied package identifier.
CONJUNCTION	resideOutsideOfPackages(String... packageIdentifiers)	Matches classes not residing in a package matching any of the supplied package identifiers.

Methods inherited from class java.lang.Object

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

Constructor Details

ClassesThatInternal

public ClassesThatInternal(Function<DescribedPredicate<? super JavaClass>,CONJUNCTION> addPredicate)

Method Details

resideInAPackage

public CONJUNCTION resideInAPackage(String packageIdentifier)

Description copied from interface: ClassesThat

Matches classes residing in a package matching the supplied package identifier.

Specified by:

resideInAPackage in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION resideInAnyPackage(String... packageIdentifiers)

Description copied from interface: ClassesThat

Matches classes residing in a package matching any of the supplied package identifiers.

Specified by:

resideInAnyPackage in interface ClassesThat<CONJUNCTION>

Parameters:

packageIdentifiers - Strings identifying packages, for details see PackageMatcher

Returns:

A syntax conjunction element, which can be completed to form a full rule

resideOutsideOfPackage

public CONJUNCTION resideOutsideOfPackage(String packageIdentifier)

Description copied from interface: ClassesThat

Matches classes not residing in a package matching the supplied package identifier.

Specified by:

resideOutsideOfPackage in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION resideOutsideOfPackages(String... packageIdentifiers)

Description copied from interface: ClassesThat

Matches classes not residing in a package matching any of the supplied package identifiers.

Specified by:

resideOutsideOfPackages in interface ClassesThat<CONJUNCTION>

Parameters:

packageIdentifiers - Strings identifying packages, for details see PackageMatcher

Returns:

A syntax conjunction element, which can be completed to form a full rule

areAnnotatedWith

public CONJUNCTION areAnnotatedWith(Class<? extends Annotation> annotationType)

Description copied from interface: ClassesThat

Matches classes annotated with a certain type of annotation.

Specified by:

areAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotAnnotatedWith

public CONJUNCTION areNotAnnotatedWith(Class<? extends Annotation> annotationType)

Description copied from interface: ClassesThat

Matches classes not annotated with a certain type of annotation.

Specified by:

areNotAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax conjunction element, which can be completed to form a full rule

areAnnotatedWith

public CONJUNCTION areAnnotatedWith(String annotationTypeName)

Description copied from interface: ClassesThat

Matches classes annotated with a certain type of annotation.

Specified by:

areAnnotatedWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAnnotatedWith(String annotationTypeName)

Description copied from interface: ClassesThat

Matches classes not annotated with a certain type of annotation.

Specified by:

areNotAnnotatedWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

areAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotAnnotatedWith

public CONJUNCTION areNotAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

areNotAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax conjunction element, which can be completed to form a full rule

areMetaAnnotatedWith

public CONJUNCTION areMetaAnnotatedWith(Class<? extends Annotation> annotationType)

Description copied from interface: ClassesThat

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.

Specified by:

areMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotMetaAnnotatedWith

public CONJUNCTION areNotMetaAnnotatedWith(Class<? extends Annotation> annotationType)

Description copied from interface: ClassesThat

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.

Specified by:

areNotMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

annotationType - Specific type of Annotation

Returns:

A syntax conjunction element, which can be completed to form a full rule

areMetaAnnotatedWith

public CONJUNCTION areMetaAnnotatedWith(String annotationTypeName)

Description copied from interface: ClassesThat

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.

Specified by:

areMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotMetaAnnotatedWith(String annotationTypeName)

Description copied from interface: ClassesThat

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.

Specified by:

areNotMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

areMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotMetaAnnotatedWith

public CONJUNCTION areNotMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

areNotMetaAnnotatedWith in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaAnnotations

Returns:

A syntax conjunction element, which can be completed to form a full rule

implement

public CONJUNCTION implement(Class<?> type)

Description copied from interface: ClassesThat

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 ClassesThat.areAssignableTo(Class)

Specified by:

implement in interface ClassesThat<CONJUNCTION>

Parameters:

type - An interface type matching classes must implement

Returns:

A syntax conjunction element, which can be completed to form a full rule

doNotImplement

public CONJUNCTION doNotImplement(Class<?> type)

Description copied from interface: ClassesThat

Matches classes that do not implement a certain interface. This is the negation of ClassesThat.implement(Class).

Specified by:

doNotImplement in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION implement(String typeName)

Description copied from interface: ClassesThat

Matches classes that implement a certain interface with the given type name. This is equivalent to ClassesThat.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 ClassesThat.areAssignableTo(String)

Specified by:

implement in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION doNotImplement(String typeName)

Description copied from interface: ClassesThat

Matches classes that do not implement a certain interface with the given type name. This is equivalent to ClassesThat.doNotImplement(Class), but does not depend on having a certain type on the classpath.

Specified by:

doNotImplement in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION implement(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes that implement a certain interface matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to ClassesThat.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 ClassesThat.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.

Specified by:

implement in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION doNotImplement(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes that do not implement a certain interface matching the given predicate. This is the negation of ClassesThat.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.

Specified by:

doNotImplement in interface ClassesThat<CONJUNCTION>

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

haveSimpleNameStartingWith

public CONJUNCTION haveSimpleNameStartingWith(String prefix)

Description copied from interface: ClassesThat

Matches classes with a simple class name starting with a given prefix.

Specified by:

haveSimpleNameStartingWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION haveSimpleNameNotStartingWith(String prefix)

Description copied from interface: ClassesThat

Matches classes with a simple class name not starting with a given prefix.

Specified by:

haveSimpleNameNotStartingWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION haveSimpleNameContaining(String infix)

Description copied from interface: ClassesThat

Matches classes with a simple class name containing the specified infix.

Specified by:

haveSimpleNameContaining in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION haveSimpleNameNotContaining(String infix)

Description copied from interface: ClassesThat

Matches classes with a simple class name not containing the specified infix.

Specified by:

haveSimpleNameNotContaining in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION haveSimpleNameEndingWith(String suffix)

Description copied from interface: ClassesThat

Matches classes with a simple class name ending with a given suffix.

Specified by:

haveSimpleNameEndingWith in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION haveSimpleNameNotEndingWith(String suffix)

Description copied from interface: ClassesThat

Matches classes with a simple class name not ending with a given suffix.

Specified by:

haveSimpleNameNotEndingWith in interface ClassesThat<CONJUNCTION>

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

haveNameMatching

public CONJUNCTION haveNameMatching(String regex)

Description copied from interface: ClassesThat

Matches classes with a fully qualified class name matching a given regular expression.

Specified by:

haveNameMatching in interface ClassesThat<CONJUNCTION>

Parameters:

regex - A regular expression

Returns:

A syntax conjunction element, which can be completed to form a full rule

haveNameNotMatching

public CONJUNCTION haveNameNotMatching(String regex)

Description copied from interface: ClassesThat

Matches classes with a fully qualified class name not matching a given regular expression.

Specified by:

haveNameNotMatching in interface ClassesThat<CONJUNCTION>

Parameters:

regex - A regular expression

Returns:

A syntax conjunction element, which can be completed to form a full rule

areAssignableTo

public CONJUNCTION areAssignableTo(Class<?> type)

Description copied from interface: ClassesThat

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
 

Specified by:

areAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableTo(Class<?> type)

Description copied from interface: ClassesThat

Matches classes not assignable to a certain type. This is the negation of ClassesThat.areAssignableTo(Class).

Specified by:

areNotAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAssignableTo(String typeName)

Description copied from interface: ClassesThat

Matches classes assignable to a certain type with the given type name. This is equivalent to ClassesThat.areAssignableTo(Class), but does not depend on having a certain type on the classpath.

Specified by:

areAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableTo(String typeName)

Description copied from interface: ClassesThat

Matches classes not assignable to a certain type with the given type name. This is equivalent to ClassesThat.areNotAssignableTo(Class), but does not depend on having a certain type on the classpath.

Specified by:

areNotAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAssignableTo(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes assignable to a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to ClassesThat.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.

Specified by:

areAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableTo(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes not assignable to a certain type matching the given predicate. This is the negation of ClassesThat.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.

Specified by:

areNotAssignableTo in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAssignableFrom(Class<?> type)

Description copied from interface: ClassesThat

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
 

Specified by:

areAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableFrom(Class<?> type)

Description copied from interface: ClassesThat

Matches classes not assignable from a certain type. This is the negation of ClassesThat.areAssignableFrom(Class).

Specified by:

areNotAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAssignableFrom(String typeName)

Description copied from interface: ClassesThat

Matches classes assignable from a certain type with the given type name. This is equivalent to ClassesThat.areAssignableFrom(Class), but does not depend on having a certain type on the classpath.

Specified by:

areAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableFrom(String typeName)

Description copied from interface: ClassesThat

Matches classes not assignable from a certain type with the given type name. This is equivalent to ClassesThat.areNotAssignableFrom(Class), but does not depend on having a certain type on the classpath.

Specified by:

areNotAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areAssignableFrom(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes assignable from a certain type matching the given predicate. For example, a call with HasName.Predicates.name(String) would be equivalent to ClassesThat.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.

Specified by:

areAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areNotAssignableFrom(DescribedPredicate<? super JavaClass> predicate)

Description copied from interface: ClassesThat

Matches classes not assignable from a certain type matching the given predicate. This is the negation of ClassesThat.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.

Specified by:

areNotAssignableFrom in interface ClassesThat<CONJUNCTION>

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

public CONJUNCTION areInterfaces()

Description copied from interface: ClassesThat

Matches interfaces.

Specified by:

areInterfaces in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotInterfaces

public CONJUNCTION areNotInterfaces()

Description copied from interface: ClassesThat

Matches everything except interfaces.

Specified by:

areNotInterfaces in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areEnums

public CONJUNCTION areEnums()

Description copied from interface: ClassesThat

Matches enums.

Specified by:

areEnums in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotEnums

public CONJUNCTION areNotEnums()

Description copied from interface: ClassesThat

Matches everything except enums.

Specified by:

areNotEnums in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areAnnotations

public CONJUNCTION areAnnotations()

Description copied from interface: ClassesThat

Matches annotations.

Specified by:

areAnnotations in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotAnnotations

public CONJUNCTION areNotAnnotations()

Description copied from interface: ClassesThat

Matches everything except annotations.

Specified by:

areNotAnnotations in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areRecords

public CONJUNCTION areRecords()

Description copied from interface: ClassesThat

Matches records.

Specified by:

areRecords in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

See Also:

• JavaClass.isRecord()

areNotRecords

public CONJUNCTION areNotRecords()

Description copied from interface: ClassesThat

Matches everything except records.

Specified by:

areNotRecords in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

See Also:

• JavaClass.isRecord()

areTopLevelClasses

public CONJUNCTION areTopLevelClasses()

Specified by:

areTopLevelClasses in interface ClassesThat<CONJUNCTION>

areNotTopLevelClasses

public CONJUNCTION areNotTopLevelClasses()

Specified by:

areNotTopLevelClasses in interface ClassesThat<CONJUNCTION>

areNestedClasses

public CONJUNCTION areNestedClasses()

Specified by:

areNestedClasses in interface ClassesThat<CONJUNCTION>

areNotNestedClasses

public CONJUNCTION areNotNestedClasses()

Specified by:

areNotNestedClasses in interface ClassesThat<CONJUNCTION>

areMemberClasses

public CONJUNCTION areMemberClasses()

Specified by:

areMemberClasses in interface ClassesThat<CONJUNCTION>

areNotMemberClasses

public CONJUNCTION areNotMemberClasses()

Specified by:

areNotMemberClasses in interface ClassesThat<CONJUNCTION>

areInnerClasses

public CONJUNCTION areInnerClasses()

Specified by:

areInnerClasses in interface ClassesThat<CONJUNCTION>

areNotInnerClasses

public CONJUNCTION areNotInnerClasses()

Specified by:

areNotInnerClasses in interface ClassesThat<CONJUNCTION>

areAnonymousClasses

public CONJUNCTION areAnonymousClasses()

Specified by:

areAnonymousClasses in interface ClassesThat<CONJUNCTION>

areNotAnonymousClasses

public CONJUNCTION areNotAnonymousClasses()

Specified by:

areNotAnonymousClasses in interface ClassesThat<CONJUNCTION>

areLocalClasses

public CONJUNCTION areLocalClasses()

Specified by:

areLocalClasses in interface ClassesThat<CONJUNCTION>

areNotLocalClasses

public CONJUNCTION areNotLocalClasses()

Specified by:

areNotLocalClasses in interface ClassesThat<CONJUNCTION>

belongToAnyOf

public CONJUNCTION belongToAnyOf(Class<?>... classes)

Description copied from interface: ClassesThat

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.

Specified by:

belongToAnyOf in interface ClassesThat<CONJUNCTION>

Parameters:

classes - List of Class objects.

Returns:

A syntax conjunction element, which can be completed to form a full rule

doNotBelongToAnyOf

public CONJUNCTION doNotBelongToAnyOf(Class<?>... classes)

Description copied from interface: ClassesThat

Inverted form of belongToAnyOf(Outer.class)

Specified by:

doNotBelongToAnyOf in interface ClassesThat<CONJUNCTION>

Parameters:

classes - List of Class objects.

Returns:

A syntax conjunction element, which can be completed to form a full rule

arePublic

public CONJUNCTION arePublic()

Description copied from interface: ClassesThat

Matches public classes.

Specified by:

arePublic in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotPublic

public CONJUNCTION areNotPublic()

Description copied from interface: ClassesThat

Matches non-public classes.

Specified by:

areNotPublic in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areProtected

public CONJUNCTION areProtected()

Description copied from interface: ClassesThat

Matches protected classes.

Specified by:

areProtected in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotProtected

public CONJUNCTION areNotProtected()

Description copied from interface: ClassesThat

Matches non-protected classes.

Specified by:

areNotProtected in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

arePackagePrivate

public CONJUNCTION arePackagePrivate()

Description copied from interface: ClassesThat

Matches package private classes.

Specified by:

arePackagePrivate in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotPackagePrivate

public CONJUNCTION areNotPackagePrivate()

Description copied from interface: ClassesThat

Matches non-package private classes.

Specified by:

areNotPackagePrivate in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

arePrivate

public CONJUNCTION arePrivate()

Description copied from interface: ClassesThat

Matches private classes.

Specified by:

arePrivate in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

areNotPrivate

public CONJUNCTION areNotPrivate()

Description copied from interface: ClassesThat

Matches non-private classes.

Specified by:

areNotPrivate in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

haveFullyQualifiedName

public CONJUNCTION haveFullyQualifiedName(String name)

Description copied from interface: ClassesThat

Matches classes by their fully qualified class name.

Specified by:

haveFullyQualifiedName in interface ClassesThat<CONJUNCTION>

Parameters:

name - The fully qualified class name

Returns:

A syntax conjunction element, which can be completed to form a full rule

doNotHaveFullyQualifiedName

public CONJUNCTION doNotHaveFullyQualifiedName(String name)

Description copied from interface: ClassesThat

Matches classes that do not have a certain fully qualified class name.

Specified by:

doNotHaveFullyQualifiedName in interface ClassesThat<CONJUNCTION>

Parameters:

name - The fully qualified class name

Returns:

A syntax conjunction element, which can be completed to form a full rule

haveSimpleName

public CONJUNCTION haveSimpleName(String name)

Description copied from interface: ClassesThat

Matches classes by their simple class name.

Specified by:

haveSimpleName in interface ClassesThat<CONJUNCTION>

Parameters:

name - The simple class name

Returns:

A syntax conjunction element, which can be completed to form a full rule

doNotHaveSimpleName

public CONJUNCTION doNotHaveSimpleName(String name)

Description copied from interface: ClassesThat

Matches classes that do not have a certain simple class name.

Specified by:

doNotHaveSimpleName in interface ClassesThat<CONJUNCTION>

Parameters:

name - The simple class name

Returns:

A syntax conjunction element, which can be completed to form a full rule

haveModifier

public CONJUNCTION haveModifier(JavaModifier modifier)

Description copied from interface: ClassesThat

Matches classes having a certain JavaModifier (e.g. JavaModifier.ABSTRACT).

Specified by:

haveModifier in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

doNotHaveModifier

public CONJUNCTION doNotHaveModifier(JavaModifier modifier)

Description copied from interface: ClassesThat

Matches classes not having a certain JavaModifier (e.g. JavaModifier.ABSTRACT).

Specified by:

doNotHaveModifier in interface ClassesThat<CONJUNCTION>

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyMembersThat

public CONJUNCTION containAnyMembersThat(DescribedPredicate<? super JavaMember> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyMembersThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaMembers

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyFieldsThat

public CONJUNCTION containAnyFieldsThat(DescribedPredicate<? super JavaField> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyFieldsThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaFields

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyCodeUnitsThat

public CONJUNCTION containAnyCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyCodeUnitsThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaCodeUnits

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyMethodsThat

public CONJUNCTION containAnyMethodsThat(DescribedPredicate<? super JavaMethod> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyMethodsThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaMethods

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyConstructorsThat

public CONJUNCTION containAnyConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyConstructorsThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaConstructors

Returns:

A syntax conjunction element, which can be completed to form a full rule

containAnyStaticInitializersThat

public CONJUNCTION containAnyStaticInitializersThat(DescribedPredicate<? super JavaStaticInitializer> predicate)

Description copied from interface: ClassesThat

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.

Specified by:

containAnyStaticInitializersThat in interface ClassesThat<CONJUNCTION>

Parameters:

predicate - A predicate defining matching JavaStaticInitializers

Returns:

A syntax conjunction element, which can be completed to form a full rule