Package com.tngtech.archunit.lang.syntax.elements

Interface ClassesThat<CONJUNCTION>

  • public interface ClassesThat<CONJUNCTION>

    • 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 see PackageMatcher
        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 see PackageMatcher
        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 see PackageMatcher
        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 see PackageMatcher
        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

      • 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 of Annotation
        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 of Annotation
        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 of Annotation
        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 of Annotation
        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 matching JavaAnnotations
        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 matching JavaAnnotations
        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 of Annotation
        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 of Annotation
        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 of Annotation
        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 of Annotation
        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 matching JavaAnnotations
        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 matching JavaAnnotations
        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 of implement(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 to implement(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 to doNotImplement(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

      • 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 of implement(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 (compare Class.isAssignableFrom(Class) to terminology). A simple example for this predicate would be 
        
   assignableTo(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 of areAssignableTo(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 to areAssignableTo(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 to areNotAssignableTo(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

      • areAssignableFrom

        @PublicAPI(usage=ACCESS)
CONJUNCTION areAssignableFrom​(java.lang.Class<?> type)
        Matches classes assignable from a certain type (compare Class.isAssignableFrom(Class) to terminology). This is roughly equivalent to the use of reflection: 
        
   someClass.class.isAssignableFrom(type);
        A simple example for this predicate would be 
        
   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 of areAssignableFrom(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 to areAssignableFrom(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 to areNotAssignableFrom(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

      • 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

      • areNotEnums

        @PublicAPI(usage=ACCESS)
CONJUNCTION areNotEnums()
        Matches everything except enums.
        Returns:
        A syntax conjunction element, which can be completed to form a full rule

      • belongToAnyOf

        @PublicAPI(usage=ACCESS)
CONJUNCTION belongToAnyOf​(java.lang.Class... classes)
        Matches every class in the supplied list and any of their named/anonymous inner classes, no matter how deeply nested. E.g. consider 
        
 class Outer {
     class Inner {
         class EvenMoreInner {
         }
     }
 }
        Then belongToAnyOf(Outer.class) would match the JavaClass Outer but also Inner and EvenMoreInner. Likewise would hold for any anonymous inner classes.
        Parameters:
        classes - List of Class objects.
        Returns:
        A syntax conjunction element, which can be completed to form a full rule