Interface ClassesThat<CONJUNCTION>
-
public interface ClassesThat<CONJUNCTION>
-
-
Method Summary
All Methods Instance Methods Abstract Methods Deprecated Methods 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
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
areInterfaces()
Matches interfaces.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
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
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
areNotInterfaces()
Matches everything except interfaces.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
areNotPackagePrivate()
Matches non-package private classes.CONJUNCTION
areNotPrivate()
Matches non-private classes.CONJUNCTION
areNotProtected()
Matches non-protected classes.CONJUNCTION
areNotPublic()
Matches non-public classes.CONJUNCTION
arePackagePrivate()
Matches package private classes.CONJUNCTION
arePrivate()
Matches private classes.CONJUNCTION
areProtected()
Matches protected classes.CONJUNCTION
arePublic()
Matches public classes.CONJUNCTION
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
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
dontHaveFullyQualifiedName(java.lang.String name)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveFullyQualifiedName(String)
CONJUNCTION
dontHaveModifier(JavaModifier modifier)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveModifier(JavaModifier)
CONJUNCTION
dontHaveSimpleName(java.lang.String name)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveSimpleName(String)
CONJUNCTION
dontImplement(DescribedPredicate<? super JavaClass> predicate)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(DescribedPredicate)
CONJUNCTION
dontImplement(java.lang.Class<?> type)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(Class)
CONJUNCTION
dontImplement(java.lang.String typeName)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(String)
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 Detail
-
haveFullyQualifiedName
@PublicAPI(usage=ACCESS) CONJUNCTION haveFullyQualifiedName(java.lang.String name)
Matches classes by their fully qualified class name.- Parameters:
name
- The fully qualified class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontHaveFullyQualifiedName
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontHaveFullyQualifiedName(java.lang.String name)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveFullyQualifiedName(String)
-
doNotHaveFullyQualifiedName
@PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveFullyQualifiedName(java.lang.String name)
Matches classes that do not have a certain fully qualified class name.- Parameters:
name
- The fully qualified class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleName
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleName(java.lang.String name)
Matches classes by their simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontHaveSimpleName
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontHaveSimpleName(java.lang.String name)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveSimpleName(String)
-
doNotHaveSimpleName
@PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveSimpleName(java.lang.String name)
Matches classes that do not have a certain simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveNameMatching
@PublicAPI(usage=ACCESS) CONJUNCTION haveNameMatching(java.lang.String regex)
Matches classes with a fully qualified class name matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveNameNotMatching
@PublicAPI(usage=ACCESS) CONJUNCTION haveNameNotMatching(java.lang.String regex)
Matches classes with a fully qualified class name not matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameStartingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameStartingWith(java.lang.String prefix)
Matches classes with a simple class name starting with a given prefix.- Parameters:
prefix
- A prefix the simple class name should start with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotStartingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotStartingWith(java.lang.String prefix)
Matches classes with a simple class name not starting with a given prefix.- Parameters:
prefix
- A prefix the simple class name should not start with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameContaining
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameContaining(java.lang.String infix)
Matches classes with a simple class name containing the specified infix.- Parameters:
infix
- An infix the simple class name should contain- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotContaining
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotContaining(java.lang.String infix)
Matches classes with a simple class name not containing the specified infix.- Parameters:
infix
- An infix the simple class name should not contain- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameEndingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameEndingWith(java.lang.String suffix)
Matches classes with a simple class name ending with a given suffix.- Parameters:
suffix
- A suffix the simple class name should end with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotEndingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotEndingWith(java.lang.String suffix)
Matches classes with a simple class name not ending with a given suffix.- Parameters:
suffix
- A suffix the simple class name should not end with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideInAPackage
@PublicAPI(usage=ACCESS) CONJUNCTION resideInAPackage(java.lang.String packageIdentifier)
Matches classes residing in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details seePackageMatcher
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideInAnyPackage
@PublicAPI(usage=ACCESS) CONJUNCTION resideInAnyPackage(java.lang.String... packageIdentifiers)
Matches classes residing in a package matching any of the supplied package identifiers.- Parameters:
packageIdentifiers
- Strings identifying packages, for details seePackageMatcher
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideOutsideOfPackage
@PublicAPI(usage=ACCESS) CONJUNCTION resideOutsideOfPackage(java.lang.String packageIdentifier)
Matches classes not residing in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details 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
@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 certainJavaModifier
(e.g.JavaModifier.ABSTRACT
).- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontHaveModifier
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontHaveModifier(JavaModifier modifier)
Deprecated.Decided to consistently never use contractions -> usedoNotHaveModifier(JavaModifier)
-
doNotHaveModifier
@PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveModifier(JavaModifier modifier)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areAnnotatedWith(java.lang.String annotationTypeName)
Matches classes annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotAnnotatedWith
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAnnotatedWith(java.lang.String annotationTypeName)
Matches classes not annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type 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
@PublicAPI(usage=ACCESS) CONJUNCTION areMetaAnnotatedWith(java.lang.String annotationTypeName)
Matches classes meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
areNotMetaAnnotatedWith
@PublicAPI(usage=ACCESS) CONJUNCTION areNotMetaAnnotatedWith(java.lang.String annotationTypeName)
Matches classes not meta-annotated with a certain type of annotation. A meta-annotation is an annotation that is declared on another annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type 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
@PublicAPI(usage=ACCESS) CONJUNCTION implement(java.lang.Class<?> type)
Matches classes that implement a certain interface.- Parameters:
type
- An interface type matching classes must implement- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontImplement
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontImplement(java.lang.Class<?> type)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(Class)
-
doNotImplement
@PublicAPI(usage=ACCESS) CONJUNCTION doNotImplement(java.lang.Class<?> type)
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
@PublicAPI(usage=ACCESS) CONJUNCTION implement(java.lang.String typeName)
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.- Parameters:
typeName
- Name of an interface type matching classes must implement- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontImplement
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontImplement(java.lang.String typeName)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(String)
-
doNotImplement
@PublicAPI(usage=ACCESS) CONJUNCTION doNotImplement(java.lang.String typeName)
Matches classes that do not implement a certain interface with the given type name. This is equivalent 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
@PublicAPI(usage=ACCESS) CONJUNCTION implement(DescribedPredicate<? super JavaClass> predicate)
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.- Parameters:
predicate
- A predicate identifying interfaces matching classes must implement- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
dontImplement
@Deprecated @PublicAPI(usage=ACCESS) CONJUNCTION dontImplement(DescribedPredicate<? super JavaClass> predicate)
Deprecated.Decided to consistently never use contractions -> usedoNotImplement(DescribedPredicate)
-
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
@PublicAPI(usage=ACCESS) CONJUNCTION areAssignableTo(java.lang.Class<?> type)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAssignableTo(java.lang.Class<?> type)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areAssignableTo(java.lang.String typeName)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAssignableTo(java.lang.String typeName)
Matches classes not assignable to a certain type with the given type name. This is equivalent 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
@PublicAPI(usage=ACCESS) CONJUNCTION areAssignableFrom(java.lang.Class<?> type)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAssignableFrom(java.lang.Class<?> type)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areAssignableFrom(java.lang.String typeName)
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
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAssignableFrom(java.lang.String typeName)
Matches classes not assignable from a certain type with the given type name. This is equivalent 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
@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
-
belongToAnyOf
@PublicAPI(usage=ACCESS) CONJUNCTION belongToAnyOf(java.lang.Class... classes)
Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested. E.g. consider
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
-
-