Interface ClassesShould
public interface ClassesShould
-
Method Summary
Modifier and Type Method Description ClassesThat<ClassesShouldConjunction>
accessClassesThat()
Asserts that all classes selected by this rule access certain classes (compareonlyAccessClassesThat()
).
NOTE: This usually makes more sense the negated way, e.g.ClassesShouldConjunction
accessClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that all classes selected by this rule access certain classes (compareonlyAccessClassesThat(DescribedPredicate)
.
NOTE: This usually makes more sense the negated way, e.g.ClassesShouldConjunction
accessField(java.lang.Class<?> owner, java.lang.String fieldName)
Matches against all accesses (setting or getting) of a specific field.ClassesShouldConjunction
accessField(java.lang.String ownerName, java.lang.String fieldName)
Matches against all accesses (setting or getting) of a specific field.ClassesShouldConjunction
accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)
Matches against accessing fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.ClassesShouldConjunction
accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate)
Matches against access of arbitrary targets (compareAccessTarget
) where origin (a method or constructor) and target (a field, method or constructor) can be freely restricted by the supplied predicate.ClassesShouldConjunction
be(java.lang.Class<?> clazz)
Asserts that the rule matches exactly the given class.ClassesShouldConjunction
be(java.lang.String className)
Asserts that the rule matches exactly the class with the given fully qualified class name.ClassesShouldConjunction
beAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
Asserts that classes are annotated with a certain annotation, where matching annotations are determined by the supplied predicate.ClassesShouldConjunction
beAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Asserts that classes are annotated with a certain type of annotation.ClassesShouldConjunction
beAnnotatedWith(java.lang.String annotationTypeName)
Asserts that classes are annotated with a certain type of annotation.ClassesShouldConjunction
beAnonymousClasses()
ClassesShouldConjunction
beAssignableFrom(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes are assignable from a certain type matching the given predicate.ClassesShouldConjunction
beAssignableFrom(java.lang.Class<?> type)
Asserts that classes are assignable from a certain type (compareClass.isAssignableFrom(Class)
to terminology).ClassesShouldConjunction
beAssignableFrom(java.lang.String typeName)
Asserts that classes are assignable from a certain type with the given type name.ClassesShouldConjunction
beAssignableTo(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes are assignable to a certain type matching the given predicate.ClassesShouldConjunction
beAssignableTo(java.lang.Class<?> type)
Asserts that classes are assignable to a certain type (compareClass.isAssignableFrom(Class)
to terminology).ClassesShouldConjunction
beAssignableTo(java.lang.String typeName)
Asserts that classes are assignable to a certain type with the given type name.ClassesShouldConjunction
beEnums()
Asserts that classes are enums.ClassesShouldConjunction
beInnerClasses()
ClassesShouldConjunction
beInterfaces()
Asserts that classes are interfaces.ClassesShouldConjunction
beLocalClasses()
ClassesShouldConjunction
beMemberClasses()
ClassesShouldConjunction
beMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
Asserts that classes are meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate.ClassesShouldConjunction
beMetaAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Asserts that classes are meta-annotated with a certain type of annotation.ClassesShouldConjunction
beMetaAnnotatedWith(java.lang.String annotationTypeName)
Asserts that classes are meta-annotated with a certain type of annotation.ClassesShouldConjunction
beNestedClasses()
ClassesShouldConjunction
bePackagePrivate()
Asserts that classes are package private.ClassesShouldConjunction
bePrivate()
Asserts that classes are private.ClassesShouldConjunction
beProtected()
Asserts that classes are protected.ClassesShouldConjunction
bePublic()
Asserts that classes are public.ClassesShouldConjunction
beRecords()
Asserts that classes are records.ClassesShouldConjunction
beTopLevelClasses()
ClassesShouldConjunction
callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate)
Matches against code unit calls (compareJavaCodeUnit
) where origin (a code unit) and target (a code unit) can be freely restricted by the supplied predicate.ClassesShouldConjunction
callConstructor(java.lang.Class<?> owner, java.lang.Class<?>... parameterTypes)
Matches against a constructor call to a specific constructor (e.g.ClassesShouldConjunction
callConstructor(java.lang.String ownerName, java.lang.String... parameterTypeNames)
Matches against constructor call to a specific constructor (e.g.ClassesShouldConjunction
callConstructorWhere(DescribedPredicate<? super JavaConstructorCall> predicate)
Matches against constructor calls where origin (a method or constructor) and target (a constructor) can be freely restricted by the supplied predicate.ClassesShouldConjunction
callMethod(java.lang.Class<?> owner, java.lang.String methodName, java.lang.Class<?>... parameterTypes)
Matches against a method call to a specific method (e.g.ClassesShouldConjunction
callMethod(java.lang.String ownerName, java.lang.String methodName, java.lang.String... parameterTypeNames)
Matches against method call to a specific method (e.g.ClassesShouldConjunction
callMethodWhere(DescribedPredicate<? super JavaMethodCall> predicate)
Matches against method calls where origin (a method or constructor) and target (a method) can be freely restricted by the supplied predicate.ClassesShouldConjunction
containNumberOfElements(DescribedPredicate<? super java.lang.Integer> predicate)
Asserts that the number of classes checked by this rule conforms to the supplied predicate.ClassesThat<ClassesShouldConjunction>
dependOnClassesThat()
Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.ClassesShouldConjunction
dependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.ClassesShouldConjunction
getField(java.lang.Class<?> owner, java.lang.String fieldName)
Matches against getting of a specific field (e.g.ClassesShouldConjunction
getField(java.lang.String ownerName, java.lang.String fieldName)
Matches against getting a specific field (e.g.ClassesShouldConjunction
getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)
Matches against getting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.ClassesShouldConjunction
haveFullyQualifiedName(java.lang.String name)
Asserts that classes have a certain fully qualified class name.ClassesShouldConjunction
haveModifier(JavaModifier modifier)
Asserts that classes have a certainJavaModifier
(e.g.ClassesShouldConjunction
haveNameMatching(java.lang.String regex)
Asserts that classes have a fully qualified class name matching a given regular expression.ClassesShouldConjunction
haveNameNotMatching(java.lang.String regex)
Asserts that classes have a fully qualified class name not matching a given regular expression.ClassesShouldConjunction
haveOnlyFinalFields()
Asserts that classes have only final fields.ClassesShouldConjunction
haveOnlyPrivateConstructors()
Asserts that classes have only private constructors.ClassesShouldConjunction
haveSimpleName(java.lang.String name)
Asserts that classes have a certain simple class name.ClassesShouldConjunction
haveSimpleNameContaining(java.lang.String infix)
Asserts that classes' simple class names contain the specified infix.ClassesShouldConjunction
haveSimpleNameEndingWith(java.lang.String suffix)
Asserts that classes' simple class names end with a given suffix.ClassesShouldConjunction
haveSimpleNameNotContaining(java.lang.String infix)
Asserts that classes' simple class names do not contain the specified infix.ClassesShouldConjunction
haveSimpleNameNotEndingWith(java.lang.String suffix)
Asserts that classes' simple class names do not end with a given suffix.ClassesShouldConjunction
haveSimpleNameNotStartingWith(java.lang.String prefix)
Asserts that classes' simple class names do not start with a given prefix.ClassesShouldConjunction
haveSimpleNameStartingWith(java.lang.String prefix)
Asserts that classes' simple class names start with a given prefix.ClassesShouldConjunction
implement(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes implement a certain interface matching the given predicate.ClassesShouldConjunction
implement(java.lang.Class<?> type)
Asserts that classes implement a certain interface.ClassesShouldConjunction
implement(java.lang.String typeName)
Asserts that classes implement a certain interface with the given type name.ClassesShouldConjunction
notBe(java.lang.Class<?> clazz)
Asserts that the rule does not match the given class.ClassesShouldConjunction
notBe(java.lang.String className)
Asserts that the rule does not match the class with the given fully qualified class name.ClassesShouldConjunction
notBeAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
Asserts that classes are not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.ClassesShouldConjunction
notBeAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Asserts that classes are not annotated with a certain type of annotation.ClassesShouldConjunction
notBeAnnotatedWith(java.lang.String annotationTypeName)
Asserts that classes are not annotated with a certain type of annotation.ClassesShouldConjunction
notBeAnonymousClasses()
ClassesShouldConjunction
notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes are not assignable from a certain type matching the given predicate.ClassesShouldConjunction
notBeAssignableFrom(java.lang.Class<?> type)
Asserts that classes are not assignable from a certain type.ClassesShouldConjunction
notBeAssignableFrom(java.lang.String typeName)
Asserts that classes are not assignable from a certain type with the given type name.ClassesShouldConjunction
notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes are not assignable to a certain type matching the given predicate.ClassesShouldConjunction
notBeAssignableTo(java.lang.Class<?> type)
Asserts that classes are not assignable to a certain type.ClassesShouldConjunction
notBeAssignableTo(java.lang.String typeName)
Asserts that classes are not assignable to a certain type with the given type name.ClassesShouldConjunction
notBeEnums()
Asserts that classes are not enums.ClassesShouldConjunction
notBeInnerClasses()
ClassesShouldConjunction
notBeInterfaces()
Asserts that classes are not interfaces.ClassesShouldConjunction
notBeLocalClasses()
ClassesShouldConjunction
notBeMemberClasses()
ClassesShouldConjunction
notBeMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)
Asserts that classes are not meta-annotated with a certain annotation, where matching meta-annotations are determined by the supplied predicate.ClassesShouldConjunction
notBeMetaAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)
Asserts that classes are not meta-annotated with a certain type of annotation.ClassesShouldConjunction
notBeMetaAnnotatedWith(java.lang.String annotationTypeName)
Asserts that classes are not meta-annotated with a certain type of annotation.ClassesShouldConjunction
notBeNestedClasses()
ClassesShouldConjunction
notBePackagePrivate()
Asserts that classes are non-package private.ClassesShouldConjunction
notBePrivate()
Asserts that classes are non-private.ClassesShouldConjunction
notBeProtected()
Asserts that classes are non-protected.ClassesShouldConjunction
notBePublic()
Asserts that classes are non-public.ClassesShouldConjunction
notBeRecords()
Asserts that classes are not records.ClassesShouldConjunction
notBeTopLevelClasses()
ClassesShouldConjunction
notHaveFullyQualifiedName(java.lang.String name)
Asserts that classes do not have a certain fully qualified class name.ClassesShouldConjunction
notHaveModifier(JavaModifier modifier)
Asserts that classes do not have a certainJavaModifier
(e.g.ClassesShouldConjunction
notHaveSimpleName(java.lang.String name)
Asserts that classes do not have a certain simple class name.ClassesShouldConjunction
notImplement(DescribedPredicate<? super JavaClass> predicate)
Asserts that classes do not implement a certain interface matching the given predicate.ClassesShouldConjunction
notImplement(java.lang.Class<?> type)
Asserts that classes do not implement a certain interface.ClassesShouldConjunction
notImplement(java.lang.String typeName)
Asserts that classes do not implement a certain interface with the given type name.ClassesThat<ClassesShouldConjunction>
onlyAccessClassesThat()
Asserts that all classes selected by this rule ONLY access certain classes (compareaccessClassesThat()
).
E.g.ClassesShouldConjunction
onlyAccessClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that all classes selected by this rule ONLY access certain classes (compareaccessClassesThat(DescribedPredicate)
).
E.g.ClassesShouldConjunction
onlyAccessFieldsThat(DescribedPredicate<? super JavaField> predicate)
Matches all field accesses against the supplied predicate.ClassesShouldConjunction
onlyAccessMembersThat(DescribedPredicate<? super JavaMember> predicate)
Matches all members calls against the supplied predicate.OnlyBeAccessedSpecification<ClassesShouldConjunction>
onlyBeAccessed()
Asserts that only certain classes access the classes selected by this rule.
E.g.ClassesShouldConjunction
onlyCallCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)
Matches all code unit calls against the supplied predicate.ClassesShouldConjunction
onlyCallConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)
Matches all constructor calls against the supplied predicate.ClassesShouldConjunction
onlyCallMethodsThat(DescribedPredicate<? super JavaMethod> predicate)
Matches all method calls against the supplied predicate.ClassesThat<ClassesShouldConjunction>
onlyDependOnClassesThat()
Asserts that all classes selected by this rule ONLY depend on certain classes (comparedependOnClassesThat()
).
E.g.ClassesShouldConjunction
onlyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that all classes selected by this rule ONLY depend on certain classes (comparedependOnClassesThat(DescribedPredicate)
).
E.g.ClassesThat<ClassesShouldConjunction>
onlyHaveDependentClassesThat()
Asserts that only certain classes depend on the classes selected by this rule.
E.g.ClassesShouldConjunction
onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that only certain classes depend on the classes selected by this rule.
E.g.ClassesShouldConjunction
resideInAnyPackage(java.lang.String... packageIdentifiers)
Asserts that classes reside in a package matching any of the supplied package identifiers.ClassesShouldConjunction
resideInAPackage(java.lang.String packageIdentifier)
Asserts that classes reside in a package matching the supplied package identifier.ClassesShouldConjunction
resideOutsideOfPackage(java.lang.String packageIdentifier)
Asserts that classes do not reside in a package matching the supplied package identifier.ClassesShouldConjunction
resideOutsideOfPackages(java.lang.String... packageIdentifiers)
Asserts that classes do not reside in a package matching any of the supplied package identifiers.ClassesShouldConjunction
setField(java.lang.Class<?> owner, java.lang.String fieldName)
Matches against setting a specific field (e.g.ClassesShouldConjunction
setField(java.lang.String ownerName, java.lang.String fieldName)
Matches against setting a specific field (e.g.ClassesShouldConjunction
setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)
Matches against setting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.ClassesThat<ClassesShouldConjunction>
transitivelyDependOnClassesThat()
Asserts that all classes selected by this rule transitively depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.ClassesShouldConjunction
transitivelyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)
Asserts that all classes selected by this rule transitively depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.
-
Method Details
-
haveFullyQualifiedName
Asserts that classes have a certain fully qualified class name.- Parameters:
name
- The fully qualified class name- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notHaveFullyQualifiedName
Asserts that classes do not have a certain fully qualified class name.- Parameters:
name
- The fully qualified class name- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleName
Asserts that classes have a certain simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notHaveSimpleName
Asserts that classes do not have a certain simple class name.- Parameters:
name
- The simple class name- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameStartingWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction haveSimpleNameStartingWith(java.lang.String prefix)Asserts that classes' simple class names start with a given prefix.- Parameters:
prefix
- A prefix the simple class name should start with- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameNotStartingWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction haveSimpleNameNotStartingWith(java.lang.String prefix)Asserts that classes' simple class names do not start with a given prefix.- Parameters:
prefix
- A prefix the simple class name should not start with- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameContaining
Asserts that classes' simple class names contain the specified infix.- Parameters:
infix
- An infix the simple class name should contain- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameNotContaining
@PublicAPI(usage=ACCESS) ClassesShouldConjunction haveSimpleNameNotContaining(java.lang.String infix)Asserts that classes' simple class names do not contain the specified infix.- Parameters:
infix
- An infix the simple class name should not contain- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameEndingWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction haveSimpleNameEndingWith(java.lang.String suffix)Asserts that classes' simple class names end with a given suffix.- Parameters:
suffix
- A suffix the simple class name should end with- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveSimpleNameNotEndingWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction haveSimpleNameNotEndingWith(java.lang.String suffix)Asserts that classes' simple class names do not end with a given suffix.- Parameters:
suffix
- A suffix the simple class name should not end with- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveNameMatching
Asserts that classes have a fully qualified class name matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveNameNotMatching
Asserts that classes have a fully qualified class name not matching a given regular expression.- Parameters:
regex
- A regular expression- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
resideInAPackage
@PublicAPI(usage=ACCESS) ClassesShouldConjunction resideInAPackage(java.lang.String packageIdentifier)Asserts that classes reside in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details seePackageMatcher
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
resideInAnyPackage
@PublicAPI(usage=ACCESS) ClassesShouldConjunction resideInAnyPackage(java.lang.String... packageIdentifiers)Asserts that classes reside in a package matching any of the supplied package identifiers.- Parameters:
packageIdentifiers
- Strings identifying packages, for details seePackageMatcher
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
resideOutsideOfPackage
@PublicAPI(usage=ACCESS) ClassesShouldConjunction resideOutsideOfPackage(java.lang.String packageIdentifier)Asserts that classes do not reside in a package matching the supplied package identifier.- Parameters:
packageIdentifier
- A string identifying packages, for details seePackageMatcher
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
resideOutsideOfPackages
@PublicAPI(usage=ACCESS) ClassesShouldConjunction resideOutsideOfPackages(java.lang.String... packageIdentifiers)Asserts that classes do not reside in a package matching any of the supplied package identifiers.- Parameters:
packageIdentifiers
- Strings identifying packages, for details seePackageMatcher
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
bePublic
Asserts that classes are public.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBePublic
Asserts that classes are non-public.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beProtected
Asserts that classes are protected.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeProtected
Asserts that classes are non-protected.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
bePackagePrivate
Asserts that classes are package private.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBePackagePrivate
Asserts that classes are non-package private.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
bePrivate
Asserts that classes are private.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBePrivate
Asserts that classes are non-private.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveOnlyFinalFields
Asserts that classes have only final fields.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveOnlyPrivateConstructors
Asserts that classes have only private constructors.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
haveModifier
Asserts that classes have a certainJavaModifier
(e.g.JavaModifier.ABSTRACT
).- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notHaveModifier
Asserts that classes do not have a certainJavaModifier
(e.g.JavaModifier.ABSTRACT
).- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)Asserts that classes are annotated with a certain type of annotation.- Parameters:
annotationType
- Specific type ofAnnotation
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)Asserts that classes are not annotated with a certain type of annotation.- Parameters:
annotationType
- Specific type ofAnnotation
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beAnnotatedWith(java.lang.String annotationTypeName)Asserts that classes are annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeAnnotatedWith(java.lang.String annotationTypeName)Asserts that classes are not annotated with a certain type of annotation.- Parameters:
annotationTypeName
- Fully qualified class name of a specific type ofAnnotation
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)Asserts that classes are annotated with a certain annotation, where matching annotations are determined by the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaAnnotations
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)Asserts that classes are not annotated with a certain annotation, where matching annotations are determined by the supplied predicate.- Parameters:
predicate
- A predicate defining matchingJavaAnnotations
- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beMetaAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeMetaAnnotatedWith(java.lang.Class<? extends java.lang.annotation.Annotation> annotationType)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
beMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beMetaAnnotatedWith(java.lang.String annotationTypeName)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeMetaAnnotatedWith(java.lang.String annotationTypeName)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
beMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeMetaAnnotatedWith
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeMetaAnnotatedWith(DescribedPredicate<? super JavaAnnotation<?>> predicate)Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
-
implement
Asserts that classes implement a certain interface. Note that this only matches non-interfaceclasses
that implement the supplied interfacetype
(compareJavaClass.Predicates.implement(Class)
. For general assignability seebeAssignableTo(Class)
- Parameters:
type
- An interface imported classes should implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.implement(Class)
-
notImplement
Asserts that classes do not implement a certain interface. This is the negation ofimplement(Class)
.- Parameters:
type
- An interface imported classes should NOT implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notImplement(Class)
-
implement
Asserts that classes 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 seebeAssignableTo(String)
- Parameters:
typeName
- Name of an interface imported classes should implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.implement(String)
-
notImplement
Asserts that classes do not implement a certain interface with the given type name. This is equivalent tonotImplement(Class)
, but does not depend on having a certain type on the classpath.- Parameters:
typeName
- Name of an interface imported classes should NOT implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notImplement(String)
-
implement
@PublicAPI(usage=ACCESS) ClassesShouldConjunction implement(DescribedPredicate<? super JavaClass> predicate)Asserts that classes 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 seebeAssignableTo(DescribedPredicate)
- Parameters:
predicate
- A predicate identifying an interface imported classes should implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.implement(DescribedPredicate)
-
notImplement
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notImplement(DescribedPredicate<? super JavaClass> predicate)Asserts that classes do not implement a certain interface matching the given predicate. This is the negation ofimplement(DescribedPredicate)
.- Parameters:
predicate
- A predicate identifying an interface imported classes should NOT implement- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notImplement(DescribedPredicate)
-
beAssignableTo
Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableTo(Class)
-
notBeAssignableTo
Asserts that classes are not assignable to a certain type. This is the negation ofbeAssignableTo(Class)
.- Parameters:
type
- An upper type bound imported classes should NOT have- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableTo(Class)
-
beAssignableTo
Asserts that classes are assignable to a certain type with the given type name. This is equivalent tobeAssignableTo(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableTo(String)
-
notBeAssignableTo
Asserts that classes are not assignable to a certain type with the given type name. This is equivalent tonotBeAssignableTo(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableTo(String)
-
beAssignableTo
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beAssignableTo(DescribedPredicate<? super JavaClass> predicate)Asserts that classes are assignable to a certain type matching the given predicate. For example, a call withHasName.Predicates.name(String)
would be equivalent tobeAssignableTo(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableTo(DescribedPredicate)
-
notBeAssignableTo
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeAssignableTo(DescribedPredicate<? super JavaClass> predicate)Asserts that classes are not assignable to a certain type matching the given predicate. This is the negation ofbeAssignableTo(DescribedPredicate)
.- Parameters:
predicate
- A predicate identifying an upper type bound imported classes should NOT have- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableTo(DescribedPredicate)
-
beAssignableFrom
Asserts that classes are 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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableFrom(Class)
-
notBeAssignableFrom
Asserts that classes are not assignable from a certain type. This is the negation ofbeAssignableFrom(Class)
.- Parameters:
type
- A lower type bound imported classes should NOT have- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableFrom(Class)
-
beAssignableFrom
Asserts that classes are assignable from a certain type with the given type name. This is equivalent tobeAssignableFrom(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableFrom(String)
-
notBeAssignableFrom
Asserts that classes are not assignable from a certain type with the given type name. This is equivalent tonotBeAssignableFrom(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableFrom(String)
-
beAssignableFrom
@PublicAPI(usage=ACCESS) ClassesShouldConjunction beAssignableFrom(DescribedPredicate<? super JavaClass> predicate)Asserts that classes are assignable from a certain type matching the given predicate. For example, a call withHasName.Predicates.name(String)
would be equivalent tobeAssignableFrom(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 element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.beAssignableFrom(DescribedPredicate)
-
notBeAssignableFrom
@PublicAPI(usage=ACCESS) ClassesShouldConjunction notBeAssignableFrom(DescribedPredicate<? super JavaClass> predicate)Asserts that classes are not assignable from a certain type matching the given predicate. This is the negation ofbeAssignableFrom(DescribedPredicate)
.- Parameters:
predicate
- A predicate identifying a lower type bound imported classes should NOT have- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
ArchConditions.notBeAssignableFrom(DescribedPredicate)
-
accessField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction accessField(java.lang.Class<?> owner, java.lang.String fieldName)Matches against all accesses (setting or getting) of a specific field.- Parameters:
owner
- The class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
accessField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction accessField(java.lang.String ownerName, java.lang.String fieldName)Matches against all accesses (setting or getting) of a specific field.- Parameters:
ownerName
- The fully qualified class name of the class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
accessFieldWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction accessFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)Matches against accessing fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaFieldAccesses
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyAccessFieldsThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyAccessFieldsThat(DescribedPredicate<? super JavaField> predicate)Matches all field accesses against the supplied predicate.- Parameters:
predicate
- Determines whichJavaFields
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
getField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction getField(java.lang.Class<?> owner, java.lang.String fieldName)Matches against getting of a specific field (e.g.return someClass.someField;
).- Parameters:
owner
- The class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
getField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction getField(java.lang.String ownerName, java.lang.String fieldName)Matches against getting a specific field (e.g.return someClass.someField;
).- Parameters:
ownerName
- The fully qualified class name of the class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
getFieldWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction getFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)Matches against getting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaFieldAccesses
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
setField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction setField(java.lang.Class<?> owner, java.lang.String fieldName)Matches against setting a specific field (e.g.someClass.someField = newValue;
).- Parameters:
owner
- The class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
setField
@PublicAPI(usage=ACCESS) ClassesShouldConjunction setField(java.lang.String ownerName, java.lang.String fieldName)Matches against setting a specific field (e.g.someClass.someField = newValue;
).- Parameters:
ownerName
- The fully qualified class name of the class declaring the fieldfieldName
- The name of the field to match- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
setFieldWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction setFieldWhere(DescribedPredicate<? super JavaFieldAccess> predicate)Matches against setting of fields, where origin (a method or constructor) and target (a field) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaFieldAccesses
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callMethod
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callMethod(java.lang.Class<?> owner, java.lang.String methodName, java.lang.Class<?>... parameterTypes)Matches against a method call to a specific method (e.g.someClass.call();
).- Parameters:
owner
- Class declaring the methodmethodName
- The method name to match againstparameterTypes
- The parameter types of the respective method- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callMethod
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callMethod(java.lang.String ownerName, java.lang.String methodName, java.lang.String... parameterTypeNames)Matches against method call to a specific method (e.g.someClass.call();
).- Parameters:
ownerName
- The fully qualified class name declaring the methodmethodName
- The method name to match againstparameterTypeNames
- The fully qualified parameter type names- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callMethodWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callMethodWhere(DescribedPredicate<? super JavaMethodCall> predicate)Matches against method calls where origin (a method or constructor) and target (a method) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaMethodCalls
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyCallMethodsThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyCallMethodsThat(DescribedPredicate<? super JavaMethod> predicate)Matches all method calls against the supplied predicate.- Parameters:
predicate
- Determines whichJavaMethods
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callConstructor
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callConstructor(java.lang.Class<?> owner, java.lang.Class<?>... parameterTypes)Matches against a constructor call to a specific constructor (e.g.new SomeClass();
).- Parameters:
owner
- Class declaring the constructorparameterTypes
- The parameter types of the respective constructor- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callConstructor
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callConstructor(java.lang.String ownerName, java.lang.String... parameterTypeNames)Matches against constructor call to a specific constructor (e.g.new SomeClass();
).- Parameters:
ownerName
- The fully qualified class name declaring the constructorparameterTypeNames
- The fully qualified parameter type names- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callConstructorWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callConstructorWhere(DescribedPredicate<? super JavaConstructorCall> predicate)Matches against constructor calls where origin (a method or constructor) and target (a constructor) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaConstructorCalls
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyCallConstructorsThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyCallConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)Matches all constructor calls against the supplied predicate.- Parameters:
predicate
- Determines whichJavaConstructors
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
accessTargetWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction accessTargetWhere(DescribedPredicate<? super JavaAccess<?>> predicate)Matches against access of arbitrary targets (compareAccessTarget
) where origin (a method or constructor) and target (a field, method or constructor) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaAccesses
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyAccessMembersThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyAccessMembersThat(DescribedPredicate<? super JavaMember> predicate)Matches all members calls against the supplied predicate.- Parameters:
predicate
- Determines whichJavaMembers
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
callCodeUnitWhere
@PublicAPI(usage=ACCESS) ClassesShouldConjunction callCodeUnitWhere(DescribedPredicate<? super JavaCall<?>> predicate)Matches against code unit calls (compareJavaCodeUnit
) where origin (a code unit) and target (a code unit) can be freely restricted by the supplied predicate.- Parameters:
predicate
- Determines whichJavaCalls
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyCallCodeUnitsThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyCallCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)Matches all code unit calls against the supplied predicate.- Parameters:
predicate
- Determines whichJavaCodeUnits
match the rule- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
accessClassesThat
Asserts that all classes selected by this rule access certain classes (compareonlyAccessClassesThat()
).
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare withnoClasses()
.should()
.accessClassesThat()
.haveFullyQualifiedName(String)
dependOnClassesThat()
that catches a wider variety of violations.- Returns:
- A syntax element that allows choosing which classes should be accessed
-
accessClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction accessClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that all classes selected by this rule access certain classes (compareonlyAccessClassesThat(DescribedPredicate)
.
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare withnoClasses()
.should()
.accessClassesThat(myPredicate)
dependOnClassesThat(DescribedPredicate)
that catches a wider variety of violations.- Parameters:
predicate
- Determines whichJavaClasses
match the access target- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyAccessClassesThat
Asserts that all classes selected by this rule ONLY access certain classes (compareaccessClassesThat()
).
E.g.
NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare withclasses()
.should()
.onlyAccessClassesThat()
.haveFullyQualifiedName(String)
onlyDependOnClassesThat()
) that catches a wider variety of violations.- Returns:
- A syntax element that allows choosing which classes should only be accessed
-
onlyAccessClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyAccessClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that all classes selected by this rule ONLY access certain classes (compareaccessClassesThat(DescribedPredicate)
).
E.g.
NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare withclasses()
.should()
.onlyAccessClassesThat(myPredicate)
onlyDependOnClassesThat(DescribedPredicate)
that catches a wider variety of violations.- Parameters:
predicate
- Determines whichJavaClasses
match the access target- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
dependOnClassesThat
Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withnoClasses()
.should()
.dependOnClassesThat()
.haveFullyQualifiedName(String)
accessClassesThat()
that catches violations only by real accesses.- Returns:
- A syntax element that allows choosing to which classes a dependency should exist
-
dependOnClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction dependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that all classes selected by this rule depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withnoClasses()
.should()
.dependOnClassesThat(myPredicate)
accessClassesThat(DescribedPredicate)
that catches violations only by real accesses.- Parameters:
predicate
- Determines whichJavaClasses
match the dependency target- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyDependOnClassesThat
Asserts that all classes selected by this rule ONLY depend on certain classes (comparedependOnClassesThat()
).
E.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withclasses()
.should()
.onlyDependOnClassesThat()
.haveFullyQualifiedName(String)
onlyAccessClassesThat()
that catches violations only by real accesses.- Returns:
- A syntax element that allows choosing to which classes a dependency should only exist
-
onlyDependOnClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that all classes selected by this rule ONLY depend on certain classes (comparedependOnClassesThat(DescribedPredicate)
).
E.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withclasses()
.should()
.onlyDependOnClassesThat(myPredicate)
onlyAccessClassesThat(DescribedPredicate)
that catches violations only by real accesses.- Parameters:
predicate
- Determines whichJavaClasses
match the dependency target- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
transitivelyDependOnClassesThat
Asserts that all classes selected by this rule transitively depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...noClasses()
.should()
.transitivelyDependOnClassesThat()
.haveFullyQualifiedName(String)
- Returns:
- A syntax element that allows choosing to which classes a transitive dependency should exist
-
transitivelyDependOnClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction transitivelyDependOnClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that all classes selected by this rule transitively depend on certain classes.
NOTE: This usually makes more sense the negated way, e.g.
NOTE: 'dependOn' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc...noClasses()
.should()
.transitivelyDependOnClassesThat(myPredicate)
- Parameters:
predicate
- Determines whichJavaClasses
match the dependency target- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
onlyBeAccessed
Asserts that only certain classes access the classes selected by this rule.
E.g.
NOTE: 'access' refers only to violations by real accesses, i.e. accessing a field, and calling a method. Compare withonlyBeAccessed()
.byAnyPackage(String...)
onlyHaveDependentClassesThat()
that catches a wider variety of violations.- Returns:
- A syntax element that allows restricting how classes should be accessed
-
onlyHaveDependentClassesThat
Asserts that only certain classes depend on the classes selected by this rule.
E.g.
NOTE: 'depends' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withclasses()
.should()
.onlyHaveDependentClassesThat()
.haveFullyQualifiedName(String)
onlyBeAccessed()
that catches violations only by real accesses.- Returns:
- A syntax element that allows choosing from which classes a dependency to these classes may exist
-
onlyHaveDependentClassesThat
@PublicAPI(usage=ACCESS) ClassesShouldConjunction onlyHaveDependentClassesThat(DescribedPredicate<? super JavaClass> predicate)Asserts that only certain classes depend on the classes selected by this rule.
E.g.
NOTE: 'depends' catches wide variety of violations, e.g. having fields of type, having method parameters of type, extending type etc... Compare withclasses()
.should()
.onlyHaveDependentClassesThat(myPredicate)
onlyBeAccessed()
.byClassesThat(DescribedPredicate)
that catches violations only by real accesses.- Parameters:
predicate
- Determines whichJavaClasses
match the dependency origin- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beInterfaces
Asserts that classes are interfaces.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeInterfaces
Asserts that classes are not interfaces.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beEnums
Asserts that classes are enums.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBeEnums
Asserts that classes are not enums.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
beRecords
Asserts that classes are records.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
JavaClass.isRecord()
-
notBeRecords
Asserts that classes are not records.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
- See Also:
JavaClass.isRecord()
-
beTopLevelClasses
-
notBeTopLevelClasses
-
beNestedClasses
-
notBeNestedClasses
-
beMemberClasses
-
notBeMemberClasses
-
beInnerClasses
-
notBeInnerClasses
-
beAnonymousClasses
-
notBeAnonymousClasses
-
beLocalClasses
-
notBeLocalClasses
-
be
Asserts that the rule matches exactly the given class.- Parameters:
clazz
- the only class the should be matched- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBe
Asserts that the rule does not match the given class.- Parameters:
clazz
- the class that should not be matched- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
be
Asserts that the rule matches exactly the class with the given fully qualified class name.- Parameters:
className
- the name of the only class that should be matched.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
notBe
Asserts that the rule does not match the class with the given fully qualified class name.- Parameters:
className
- the name of the class that should not be matched.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-
containNumberOfElements
@PublicAPI(usage=ACCESS) ClassesShouldConjunction containNumberOfElements(DescribedPredicate<? super java.lang.Integer> predicate)Asserts that the number of classes checked by this rule conforms to the supplied predicate.- Returns:
- A syntax element that can either be used as working rule, or to continue specifying a more complex rule
-