Interface ClassesThat<CONJUNCTION>
public interface ClassesThat<CONJUNCTION>
-
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(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Matches classes annotated with a certain type of annotation.CONJUNCTION
areAnnotatedWith(java.lang.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(java.lang.Class<?> type)
Matches classes assignable from a certain type (compareClass.isAssignableFrom(Class)
to terminology).CONJUNCTION
areAssignableFrom(java.lang.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(java.lang.Class<?> type)
Matches classes assignable to a certain type (compareClass.isAssignableFrom(Class)
to terminology).CONJUNCTION
areAssignableTo(java.lang.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(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Matches classes meta-annotated with a certain type of annotation.CONJUNCTION
areMetaAnnotatedWith(java.lang.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(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Matches classes not annotated with a certain type of annotation.CONJUNCTION
areNotAnnotatedWith(java.lang.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(java.lang.Class<?> type)
Matches classes not assignable from a certain type.CONJUNCTION
areNotAssignableFrom(java.lang.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(java.lang.Class<?> type)
Matches classes not assignable to a certain type.CONJUNCTION
areNotAssignableTo(java.lang.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(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Matches classes not meta-annotated with a certain type of annotation.CONJUNCTION
areNotMetaAnnotatedWith(java.lang.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(java.lang.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 anycode unit
matching the supplied predicate.CONJUNCTION
containAnyConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)
Matches classes that contain anyconstructor
matching the supplied predicate.CONJUNCTION
containAnyFieldsThat(DescribedPredicate<? super JavaField> predicate)
Matches classes that contain anyfield
matching the supplied predicate.CONJUNCTION
containAnyMembersThat(DescribedPredicate<? super JavaMember> predicate)
Matches classes that contain anymember
matching the supplied predicate.CONJUNCTION
containAnyMethodsThat(DescribedPredicate<? super JavaMethod> predicate)
Matches classes that contain anymethod
matching the supplied predicate.CONJUNCTION
containAnyStaticInitializersThat(DescribedPredicate<? super JavaStaticInitializer> predicate)
Matches classes that contain astatic initializer
matching the supplied predicate.CONJUNCTION
doNotBelongToAnyOf(java.lang.Class<?>... classes)
Inverted form ofbelongToAnyOf(Outer.class)
CONJUNCTION
doNotHaveFullyQualifiedName(java.lang.String name)
Matches classes that do not have a certain fully qualified class name.CONJUNCTION
doNotHaveModifier(JavaModifier modifier)
Matches classes not having a certainJavaModifier
(e.g.CONJUNCTION
doNotHaveSimpleName(java.lang.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(java.lang.Class<?> type)
Matches classes that do not implement a certain interface.CONJUNCTION
doNotImplement(java.lang.String typeName)
Matches classes that do not implement a certain interface with the given type name.CONJUNCTION
haveFullyQualifiedName(java.lang.String name)
Matches classes by their fully qualified class name.CONJUNCTION
haveModifier(JavaModifier modifier)
Matches classes having a certainJavaModifier
(e.g.CONJUNCTION
haveNameMatching(java.lang.String regex)
Matches classes with a fully qualified class name matching a given regular expression.CONJUNCTION
haveNameNotMatching(java.lang.String regex)
Matches classes with a fully qualified class name not matching a given regular expression.CONJUNCTION
haveSimpleName(java.lang.String name)
Matches classes by their simple class name.CONJUNCTION
haveSimpleNameContaining(java.lang.String infix)
Matches classes with a simple class name containing the specified infix.CONJUNCTION
haveSimpleNameEndingWith(java.lang.String suffix)
Matches classes with a simple class name ending with a given suffix.CONJUNCTION
haveSimpleNameNotContaining(java.lang.String infix)
Matches classes with a simple class name not containing the specified infix.CONJUNCTION
haveSimpleNameNotEndingWith(java.lang.String suffix)
Matches classes with a simple class name not ending with a given suffix.CONJUNCTION
haveSimpleNameNotStartingWith(java.lang.String prefix)
Matches classes with a simple class name not starting with a given prefix.CONJUNCTION
haveSimpleNameStartingWith(java.lang.String prefix)
Matches classes with a simple class name starting with a given prefix.CONJUNCTION
implement(DescribedPredicate<? super JavaClass> predicate)
Matches classes that implement a certain interface matching the given predicate.CONJUNCTION
implement(java.lang.Class<?> type)
Matches classes that implement a certain interface.CONJUNCTION
implement(java.lang.String typeName)
Matches classes that implement a certain interface with the given type name.CONJUNCTION
resideInAnyPackage(java.lang.String... packageIdentifiers)
Matches classes residing in a package matching any of the supplied package identifiers.CONJUNCTION
resideInAPackage(java.lang.String packageIdentifier)
Matches classes residing in a package matching the supplied package identifier.CONJUNCTION
resideOutsideOfPackage(java.lang.String packageIdentifier)
Matches classes not residing in a package matching the supplied package identifier.CONJUNCTION
resideOutsideOfPackages(java.lang.String... packageIdentifiers)
Matches classes not residing in a package matching any of the supplied package identifiers.
-
Method Details
-
haveFullyQualifiedName
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
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
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
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
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
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
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
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
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
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
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
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
Matches classes residing in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details seePackageMatcher
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideInAnyPackage
Matches classes residing in a package matching any of the supplied package identifiers.- Parameters:
packageIdentifiers
- Strings identifying packages, for details seePackageMatcher
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideOutsideOfPackage
Matches classes not residing in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details seePackageMatcher
- 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 seePackageMatcher
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
arePublic
Matches public classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotPublic
Matches non-public classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areProtected
Matches protected classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotProtected
Matches non-protected classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
arePackagePrivate
Matches package private classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotPackagePrivate
Matches non-package private classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
arePrivate
Matches private classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotPrivate
Matches non-private classes.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveModifier
Matches classes having a certainJavaModifier
(e.g.JavaModifier.ABSTRACT
).- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
doNotHaveModifier
Matches classes not having a certainJavaModifier
(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 ofAnnotation
- 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 ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areAnnotatedWith
Matches classes annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotAnnotatedWith
Matches classes not annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- 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 matchingJavaAnnotations
- 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 matchingJavaAnnotations
- 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 ofAnnotation
- 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 ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areMetaAnnotatedWith
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 ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotMetaAnnotatedWith
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 ofAnnotation
- 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 matchingJavaAnnotations
- 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 matchingJavaAnnotations
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
implement
Matches classes that implement a certain interface. Note that this only matches non-interfaceclasses
that implement the supplied interfacetype
(compareJavaClass.Predicates.implement(Class)
. For general assignability seeareAssignableTo(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
Matches classes that do not implement a certain interface. This is the negation ofimplement(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
Matches classes that implement a certain interface with the given type name. This is equivalent toimplement(Class)
, but does not depend on having a certain type on the classpath. Note that this only matches non-interfaceclasses
that implement the supplied interfacetypeName
(compareJavaClass.Predicates.implement(Class)
. For general assignability seeareAssignableTo(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
Matches classes that do not implement a certain interface with the given type name. This is equivalent todoNotImplement(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
Matches classes that implement a certain interface matching the given predicate. For example, a call withHasName.Predicates.name(String)
would be equivalent toimplement(String)
, but the approach is a lot more generic. Note that this only matches non-interfaceclasses
that implement an interface matching thepredicate
(compareJavaClass.Predicates.implement(Class)
. For general assignability seeareAssignableTo(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 ofimplement(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
Matches classes assignable to a certain type (compareClass.isAssignableFrom(Class)
to terminology). A simple example for this predicate would beassignableTo(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
Matches classes not assignable to a certain type. This is the negation ofareAssignableTo(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
Matches classes assignable to a certain type with the given type name. This is equivalent toareAssignableTo(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
Matches classes not assignable to a certain type with the given type name. This is equivalent toareNotAssignableTo(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 withHasName.Predicates.name(String)
would be equivalent toareAssignableTo(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 ofareAssignableTo(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
Matches classes assignable from a certain type (compareClass.isAssignableFrom(Class)
to terminology). This is roughly equivalent to the use of reflection:
A simple example for this predicate would besomeClass.class.isAssignableFrom(type);
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
Matches classes not assignable from a certain type. This is the negation ofareAssignableFrom(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
Matches classes assignable from a certain type with the given type name. This is equivalent toareAssignableFrom(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
Matches classes not assignable from a certain type with the given type name. This is equivalent toareNotAssignableFrom(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 withHasName.Predicates.name(String)
would be equivalent toareAssignableFrom(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 ofareAssignableFrom(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
Matches interfaces.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotInterfaces
Matches everything except interfaces.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areEnums
Matches enums.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotEnums
Matches everything except enums.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areAnnotations
Matches annotations.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotAnnotations
Matches everything except annotations.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areRecords
Matches records.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
- See Also:
JavaClass.isRecord()
-
areNotRecords
Matches everything except records.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
- See Also:
JavaClass.isRecord()
-
areTopLevelClasses
-
areNotTopLevelClasses
-
areNestedClasses
-
areNotNestedClasses
-
areMemberClasses
-
areNotMemberClasses
-
areInnerClasses
-
areNotInnerClasses
-
areAnonymousClasses
-
areNotAnonymousClasses
-
areLocalClasses
-
areNotLocalClasses
-
belongToAnyOf
Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested. E.g. consider
Thenclass Outer { class Inner { class EvenMoreInner { } } }
belongToAnyOf(Outer.class)
would match theJavaClass
Outer
but alsoInner
andEvenMoreInner
. Likewise would hold for any anonymous inner classes.- Parameters:
classes
- List ofClass
objects.- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
doNotBelongToAnyOf
Inverted form ofbelongToAnyOf(Outer.class)
- Parameters:
classes
- List ofClass
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 anymember
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaMembers
- 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 anyfield
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaFields
- 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 anycode unit
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaCodeUnits
- 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 anymethod
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaMethods
- 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 anyconstructor
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaConstructors
- 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 astatic initializer
matching the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaStaticInitializers
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-