Package com.tngtech.archunit.core.domain

Class JavaClass.Predicates

java.lang.Object

com.tngtech.archunit.core.domain.JavaClass.Predicates

Enclosing class:

JavaClass

@PublicAPI(usage=ACCESS)
public static final class JavaClass.Predicates
extends Object

Predefined predicates targeting JavaClass. Note that due to inheritance further predicates for JavaClass can be found in the following locations:

• HasName.Predicates
• HasName.AndFullName.Predicates
• HasModifiers.Predicates
• CanBeAnnotated.Predicates

Field Summary

Fields

Modifier and Type	Field	Description
static final DescribedPredicate<JavaClass>	ANNOTATIONS
static final DescribedPredicate<JavaClass>	ANONYMOUS_CLASSES
static final DescribedPredicate<JavaClass>	ENUMS
static final DescribedPredicate<JavaClass>	INNER_CLASSES
static final DescribedPredicate<JavaClass>	INTERFACES
static final DescribedPredicate<JavaClass>	LOCAL_CLASSES
static final DescribedPredicate<JavaClass>	MEMBER_CLASSES
static final DescribedPredicate<JavaClass>	NESTED_CLASSES
static final DescribedPredicate<JavaClass>	RECORDS
static final DescribedPredicate<JavaClass>	TOP_LEVEL_CLASSES

Method Summary

Modifier and Type	Method	Description
static DescribedPredicate<JavaClass>	assignableFrom(DescribedPredicate<? super JavaClass> predicate)	Same as assignableFrom(Class), but returns true whenever the tested JavaClass is assignable from a class that matches the supplied predicate. This is the opposite of assignableTo(DescribedPredicate): some class B is assignable from a class A if and only if A is assignable to A.
static DescribedPredicate<JavaClass>	assignableFrom(Class<?> type)
static DescribedPredicate<JavaClass>	assignableFrom(String typeName)	Same as assignableFrom(Class) but takes a fully qualified class name as an argument instead of a class object.
static DescribedPredicate<JavaClass>	assignableTo(DescribedPredicate<? super JavaClass> predicate)	Same as assignableTo(Class), but returns true whenever the tested JavaClass is assignable to a class that matches the supplied predicate. This is the opposite of assignableFrom(DescribedPredicate): some class A is assignable to a class B if and only if B is assignable from A.
static DescribedPredicate<JavaClass>	assignableTo(Class<?> type)
static DescribedPredicate<JavaClass>	assignableTo(String typeName)	Same as assignableTo(Class) but takes a fully qualified class name as an argument instead of a class object.
static DescribedPredicate<JavaClass>	belongTo(DescribedPredicate<? super JavaClass> predicate)	A predicate to determine if a JavaClass "belongs" to a class matching the given predicate, where "belong" means that this JavaClass is directly matching the given predicate a nested/inner/anonymous class of another JavaClass matching the predicate For example belongTo(annotatedWith(Something.class)) would apply to the following cases
static DescribedPredicate<JavaClass>	belongToAnyOf(Class<?>... classes)	A predicate to determine if a JavaClass "belongs" to one of the passed classes, where "belong" means that this JavaClass is equivalent to any of the passed classes any nested/inner/anonymous class of one of the passed classes For example belongToAnyOf(Outer.class) would apply to the following cases
static DescribedPredicate<JavaClass>	containAnyCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)	A predicate to determine if a JavaClass contains one or more code units matching the supplied predicate.
static DescribedPredicate<JavaClass>	containAnyConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)	A predicate to determine if a JavaClass contains one or more constructors matching the supplied predicate.
static DescribedPredicate<JavaClass>	containAnyFieldsThat(DescribedPredicate<? super JavaField> predicate)	A predicate to determine if a JavaClass contains one or more fields matching the supplied predicate.
static DescribedPredicate<JavaClass>	containAnyMembersThat(DescribedPredicate<? super JavaMember> predicate)	A predicate to determine if a JavaClass contains one or more members matching the supplied predicate.
static DescribedPredicate<JavaClass>	containAnyMethodsThat(DescribedPredicate<? super JavaMethod> predicate)	A predicate to determine if a JavaClass contains one or more methods matching the supplied predicate.
static DescribedPredicate<JavaClass>	containAnyStaticInitializersThat(DescribedPredicate<? super JavaStaticInitializer> predicate)	A predicate to determine if a JavaClass contains one or more static initializers matching the supplied predicate.
static DescribedPredicate<JavaClass>	equivalentTo(Class<?> clazz)
static DescribedPredicate<JavaClass>	implement(DescribedPredicate<? super JavaClass> predicate)	Same as implement(Class) but returns true whenever the tested JavaClass implements an interface that matches the supplied predicate.
static DescribedPredicate<JavaClass>	implement(Class<?> type)
static DescribedPredicate<JavaClass>	implement(String typeName)	Same as implement(Class) but takes a fully qualified class name as an argument instead of a class object.
static DescribedPredicate<JavaClass>	resideInAnyPackage(String... packageIdentifiers)
static DescribedPredicate<JavaClass>	resideInAPackage(String packageIdentifier)	Offers a syntax to identify packages similar to AspectJ.
static DescribedPredicate<JavaClass>	resideOutsideOfPackage(String packageIdentifier)
static DescribedPredicate<JavaClass>	resideOutsideOfPackages(String... packageIdentifiers)
static DescribedPredicate<JavaClass>	simpleName(String name)
static DescribedPredicate<JavaClass>	simpleNameContaining(String infix)
static DescribedPredicate<JavaClass>	simpleNameEndingWith(String suffix)
static DescribedPredicate<JavaClass>	simpleNameStartingWith(String prefix)
static DescribedPredicate<JavaClass>	type(Class<?> type)

Methods inherited from class java.lang.Object

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

Field Details

INTERFACES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> INTERFACES

ENUMS

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> ENUMS

ANNOTATIONS

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> ANNOTATIONS

RECORDS

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> RECORDS

TOP_LEVEL_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> TOP_LEVEL_CLASSES

NESTED_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> NESTED_CLASSES

MEMBER_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> MEMBER_CLASSES

INNER_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> INNER_CLASSES

LOCAL_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> LOCAL_CLASSES

ANONYMOUS_CLASSES

@PublicAPI(usage=ACCESS)
public static final DescribedPredicate<JavaClass> ANONYMOUS_CLASSES

Method Details

type

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> type(Class<?> type)

simpleName

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> simpleName(String name)

simpleNameStartingWith

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> simpleNameStartingWith(String prefix)

simpleNameContaining

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> simpleNameContaining(String infix)

simpleNameEndingWith

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> simpleNameEndingWith(String suffix)

assignableTo

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableTo(Class<?> type)

Parameters:

type - the type to check for assignability

Returns:

a DescribedPredicate that returns true, if the respective JavaClass is assignable to the supplied type. I.e. the type represented by the tested JavaClass could be casted to the supplied type.
This is the opposite of assignableFrom(Class): some class A is assignable to a class B if and only if B is assignable from A.

See Also:

• assignableTo(String)
• assignableTo(DescribedPredicate)
• assignableFrom(Class)

assignableFrom

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableFrom(Class<?> type)

Parameters:

type - the type to check for assignability

Returns:

a DescribedPredicate that returns true, if the respective JavaClass is assignable from the supplied type. I.e. the supplied type could be casted to the type represented by the tested JavaClass.
This is the opposite of assignableTo(Class): some class B is assignable from a class A if and only if A is assignable to B.

See Also:

• assignableFrom(String)
• assignableFrom(DescribedPredicate)
• assignableTo(Class)

assignableTo

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableTo(String typeName)

Same as assignableTo(Class) but takes a fully qualified class name as an argument instead of a class object.

assignableFrom

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableFrom(String typeName)

Same as assignableFrom(Class) but takes a fully qualified class name as an argument instead of a class object.

assignableTo

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableTo(DescribedPredicate<? super JavaClass> predicate)

Same as assignableTo(Class), but returns true whenever the tested JavaClass is assignable to a class that matches the supplied predicate.
This is the opposite of assignableFrom(DescribedPredicate): some class A is assignable to a class B if and only if B is assignable from A.

See Also:

• assignableTo(Class)
• assignableTo(String)
• assignableFrom(DescribedPredicate)

assignableFrom

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> assignableFrom(DescribedPredicate<? super JavaClass> predicate)

Same as assignableFrom(Class), but returns true whenever the tested JavaClass is assignable from a class that matches the supplied predicate.
This is the opposite of assignableTo(DescribedPredicate): some class B is assignable from a class A if and only if A is assignable to A.

See Also:

• assignableFrom(Class)
• assignableFrom(String)
• assignableTo(DescribedPredicate)

implement

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> implement(Class<?> type)

Parameters:

type - the interface type to check for

Returns:

a DescribedPredicate that returns true if the tested JavaClass implements the supplied interface type. I.e. the supplied type must be an interface and the tested JavaClass must be a class (it resembles delarations like class A implements B, which only works for a class A and an interface B).

Throws:

ArchUnitException.InvalidSyntaxUsageException - if type is not an interface

See Also:

• implement(String)
• implement(DescribedPredicate)
• assignableTo(Class)

implement

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> implement(String typeName)

Same as implement(Class) but takes a fully qualified class name as an argument instead of a class object.

implement

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> implement(DescribedPredicate<? super JavaClass> predicate)

Same as implement(Class) but returns true whenever the tested JavaClass implements an interface that matches the supplied predicate.

See Also:

• implement(Class)
• implement(String)
• assignableTo(DescribedPredicate)

resideInAPackage

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> resideInAPackage(String packageIdentifier)

Offers a syntax to identify packages similar to AspectJ. In particular '*' stands for any sequence of characters, '..' stands for any sequence of packages. For further details see PackageMatcher.

Parameters:

packageIdentifier - A string representing the identifier to match packages against

Returns:

A DescribedPredicate returning true if and only if the package of the tested JavaClass matches the identifier

resideInAnyPackage

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> resideInAnyPackage(String... packageIdentifiers)

See Also:

• resideInAPackage(String)

resideOutsideOfPackage

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> resideOutsideOfPackage(String packageIdentifier)

resideOutsideOfPackages

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> resideOutsideOfPackages(String... packageIdentifiers)

equivalentTo

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> equivalentTo(Class<?> clazz)

See Also:

• JavaClass.isEquivalentTo(Class)

belongToAnyOf

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> belongToAnyOf(Class<?>... classes)

A predicate to determine if a JavaClass "belongs" to one of the passed classes, where "belong" means that this JavaClass is equivalent to

• any of the passed classes
• any nested/inner/anonymous class of one of the passed classes

For example belongToAnyOf(Outer.class) would apply to the following cases

 class Outer {
     // Inner would match belongToAnyOf(Outer.class) since it is an inner class of Outer
     class Inner {}

     void call() {
         // this anonymous class would also match belongToAnyOf(Outer.class) since it is declared within Outer
         new Serializable() {}
     }
 }

 // this class would not match, since it is neither Outer itself nor nested within the class body of Outer
 class Other {}
 

Parameters:

classes - The classes to check the JavaClass and its enclosing classes against

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass is equivalent to one of the supplied classes or is a nested/inner/anonymous class of one of those classes.

See Also:

• belongTo(DescribedPredicate)

belongTo

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> belongTo(DescribedPredicate<? super JavaClass> predicate)

A predicate to determine if a JavaClass "belongs" to a class matching the given predicate, where "belong" means that this JavaClass is

• directly matching the given predicate
• a nested/inner/anonymous class of another JavaClass matching the predicate

For example belongTo(annotatedWith(Something.class)) would apply to the following cases

@Something
 class Outer {
     // Inner would match belongTo(annotatedWith(Something.class))
     class Inner {}

     void call() {
         // this anonymous class would also match belongTo(annotatedWith(Something.class))
         new Serializable() {}
     }
 }

 // this class would not match, since it does not belong to a class annotated with @Something
 class Other {}
 

Parameters:

predicate - The predicate to check the JavaClass and enclosing classes against

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass or one of its enclosing classes matches the given predicate.

containAnyMembersThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyMembersThat(DescribedPredicate<? super JavaMember> predicate)

A predicate to determine if a JavaClass contains one or more members matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' members.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one member matching the given predicate.

containAnyFieldsThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyFieldsThat(DescribedPredicate<? super JavaField> predicate)

A predicate to determine if a JavaClass contains one or more fields matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' fields.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one field matching the given predicate.

containAnyCodeUnitsThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyCodeUnitsThat(DescribedPredicate<? super JavaCodeUnit> predicate)

A predicate to determine if a JavaClass contains one or more code units matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' code units.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one code unit matching the given predicate.

containAnyMethodsThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyMethodsThat(DescribedPredicate<? super JavaMethod> predicate)

A predicate to determine if a JavaClass contains one or more methods matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' methods.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one method matching the given predicate.

containAnyConstructorsThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyConstructorsThat(DescribedPredicate<? super JavaConstructor> predicate)

A predicate to determine if a JavaClass contains one or more constructors matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' constructors.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one constructor matching the given predicate.

containAnyStaticInitializersThat

@PublicAPI(usage=ACCESS)
public static DescribedPredicate<JavaClass> containAnyStaticInitializersThat(DescribedPredicate<? super JavaStaticInitializer> predicate)

A predicate to determine if a JavaClass contains one or more static initializers matching the supplied predicate.

Parameters:

predicate - The predicate to check against the classes' static initializers.

Returns:

A DescribedPredicate returning true, if and only if the tested JavaClass contains at least one static initializer matching the given predicate.