Interface ClassesThat<CONJUNCTION>
-
public interface ClassesThat<CONJUNCTION>
-
-
Method Summary
All Methods Instance Methods Abstract 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
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
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
areNotTopLevelClasses()
CONJUNCTION
arePackagePrivate()
Matches package private classes.CONJUNCTION
arePrivate()
Matches private classes.CONJUNCTION
areProtected()
Matches protected classes.CONJUNCTION
arePublic()
Matches public classes.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
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 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
-
doNotHaveFullyQualifiedName
@PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveFullyQualifiedName(java.lang.String name)
Matches classes that do not have a certain fully qualified class name.- Parameters:
name
- The fully qualified class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleName
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleName(java.lang.String name)
Matches classes by their simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
doNotHaveSimpleName
@PublicAPI(usage=ACCESS) CONJUNCTION doNotHaveSimpleName(java.lang.String name)
Matches classes that do not have a certain simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveNameMatching
@PublicAPI(usage=ACCESS) CONJUNCTION haveNameMatching(java.lang.String regex)
Matches classes with a fully qualified class name matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveNameNotMatching
@PublicAPI(usage=ACCESS) CONJUNCTION haveNameNotMatching(java.lang.String regex)
Matches classes with a fully qualified class name not matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameStartingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameStartingWith(java.lang.String prefix)
Matches classes with a simple class name starting with a given prefix.- Parameters:
prefix
- A prefix the simple class name should start with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotStartingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotStartingWith(java.lang.String prefix)
Matches classes with a simple class name not starting with a given prefix.- Parameters:
prefix
- A prefix the simple class name should not start with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameContaining
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameContaining(java.lang.String infix)
Matches classes with a simple class name containing the specified infix.- Parameters:
infix
- An infix the simple class name should contain- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotContaining
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotContaining(java.lang.String infix)
Matches classes with a simple class name not containing the specified infix.- Parameters:
infix
- An infix the simple class name should not contain- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameEndingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameEndingWith(java.lang.String suffix)
Matches classes with a simple class name ending with a given suffix.- Parameters:
suffix
- A suffix the simple class name should end with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
haveSimpleNameNotEndingWith
@PublicAPI(usage=ACCESS) CONJUNCTION haveSimpleNameNotEndingWith(java.lang.String suffix)
Matches classes with a simple class name not ending with a given suffix.- Parameters:
suffix
- A suffix the simple class name should not end with- Returns:
- A syntax conjunction element, which can be completed to form a full rule
-
resideInAPackage
@PublicAPI(usage=ACCESS) CONJUNCTION resideInAPackage(java.lang.String packageIdentifier)
Matches classes residing in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details 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
-
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
-
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
-
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
-
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
-
areTopLevelClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areTopLevelClasses()
-
areNotTopLevelClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotTopLevelClasses()
-
areNestedClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNestedClasses()
-
areNotNestedClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotNestedClasses()
-
areMemberClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areMemberClasses()
-
areNotMemberClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotMemberClasses()
-
areInnerClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areInnerClasses()
-
areNotInnerClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotInnerClasses()
-
areAnonymousClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areAnonymousClasses()
-
areNotAnonymousClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotAnonymousClasses()
-
areLocalClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areLocalClasses()
-
areNotLocalClasses
@PublicAPI(usage=ACCESS) CONJUNCTION areNotLocalClasses()
-
belongToAnyOf
@PublicAPI(usage=ACCESS) CONJUNCTION belongToAnyOf(java.lang.Class<?>... classes)
Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested. E.g. consider
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
-
-