Field Analysis

/**
 * Tests if field has public modifier
 * @return DescribedPredicate that returns true if field is public
 */
public static DescribedPredicate<JavaField> isPublic();

/**
 * Tests if field has static modifier
 * @return DescribedPredicate that returns true if field is static
 */
public static DescribedPredicate<JavaField> isStatic();

/**
 * Tests if field does not have static modifier
 * @return DescribedPredicate that returns true if field is not static (instance field)
 */
public static DescribedPredicate<JavaField> isNotStatic();

/**
 * Tests if field has final modifier
 * @return DescribedPredicate that returns true if field is final
 */
public static DescribedPredicate<JavaField> isFinal();

import static org.apache.flink.architecture.common.JavaFieldPredicates.*;

// Test for public instance fields (usually discouraged)
DescribedPredicate<JavaField> publicInstanceField = isPublic().and(isNotStatic());

// Test for mutable static fields (potential concurrency issues)
DescribedPredicate<JavaField> mutableStaticField = isStatic().and(isFinal().negate());

// Validate constants are properly declared
DescribedPredicate<JavaField> properConstant = isPublic().and(isStatic()).and(isFinal());

ArchRule noPublicInstanceFields = GivenJavaClasses.javaClassesThat()
    .containAnyFieldsThat(publicInstanceField)
    .should()
    .haveSimpleNameEndingWith("DTO");

/**
 * Tests if field has the specified type using Class object
 * @param clazz Class type to match exactly
 * @return DescribedPredicate that returns true if field type matches clazz
 */
public static DescribedPredicate<JavaField> ofType(Class<?> clazz);

/**
 * Tests if field has the specified fully qualified type name
 * @param fqClassName Fully qualified class name to match
 * @return DescribedPredicate that returns true if field type name matches fqClassName
 */
public static DescribedPredicate<JavaField> ofType(String fqClassName);

/**
 * Tests if field type is assignable to the given class
 * @param clazz Class type to check assignability against
 * @return DescribedPredicate that returns true if field type is assignable to clazz
 */
public static DescribedPredicate<JavaField> isAssignableTo(Class<?> clazz);

// Check for specific logger type
DescribedPredicate<JavaField> isSlf4jLogger = ofType("org.slf4j.Logger");

// Check for any collection type
DescribedPredicate<JavaField> isCollection = isAssignableTo(java.util.Collection.class);

// Check for String fields specifically
DescribedPredicate<JavaField> isStringField = ofType(String.class);

// Validate logger fields are static final
ArchRule loggerFieldsRule = GivenJavaClasses.javaClassesThat()
    .containAnyFieldsThat(isSlf4jLogger)
    .should()
    .onlyHaveFieldsThat(isSlf4jLogger.implies(isStatic().and(isFinal())));

/**
 * Tests if field is annotated with the specified annotation type
 * @param annotationType Annotation class to check for
 * @return DescribedPredicate that returns true if field has the annotation
 */
public static DescribedPredicate<JavaField> annotatedWith(
    Class<? extends Annotation> annotationType);

/**
 * Tests if field is annotated with annotation specified by fully qualified name
 * @param fqAnnotationTypeName Fully qualified annotation class name
 * @return DescribedPredicate that returns true if field has the annotation
 */
public static DescribedPredicate<JavaField> annotatedWith(String fqAnnotationTypeName);

import javax.annotation.Nullable;
import com.fasterxml.jackson.annotation.JsonProperty;

// Check for nullable fields
DescribedPredicate<JavaField> isNullable = annotatedWith(Nullable.class);

// Check for JSON property fields by fully qualified name
DescribedPredicate<JavaField> isJsonProperty = 
    annotatedWith("com.fasterxml.jackson.annotation.JsonProperty");

// Ensure nullable fields are not primitives
ArchRule nullableFieldsRule = GivenJavaClasses.javaClassesThat()
    .containAnyFieldsThat(isNullable)
    .should()
    .onlyHaveFieldsThat(
        isNullable.implies(
            ofType("int").negate()
            .and(ofType("boolean").negate())
            .and(ofType("double").negate())
            // ... other primitives
        )
    );

// Validate configuration constants
DescribedPredicate<JavaField> isConfigConstant = 
    isPublic()
    .and(isStatic())
    .and(isFinal())
    .and(ofType(String.class))
    .and(annotatedWith("org.apache.flink.annotation.PublicEvolving"));

// Validate dependency injection fields
DescribedPredicate<JavaField> isInjectedField = 
    isNotStatic()
    .and(annotatedWith("javax.inject.Inject"))
    .and(isAssignableTo(Object.class));

// Validate serialization fields
DescribedPredicate<JavaField> isSerialVersionUID = 
    isStatic()
    .and(isFinal())
    .and(ofType("long"))
    .and(field -> field.getName().equals("serialVersionUID"));

ArchRule configConstantsRule = GivenJavaClasses.javaClassesThat()
    .haveSimpleNameEndingWith("Config")
    .should()
    .onlyHaveFieldsThat(
        isConfigConstant.or(isSerialVersionUID)
    );

// Logger field validation
DescribedPredicate<JavaField> isProperLogger = 
    ofType("org.slf4j.Logger")
    .and(isStatic())
    .and(isFinal())
    .and(field -> field.getName().equals("LOG") || field.getName().equals("LOGGER"));

// Constant field validation
DescribedPredicate<JavaField> isProperConstant = 
    isPublic()
    .and(isStatic())
    .and(isFinal())
    .and(field -> field.getName().equals(field.getName().toUpperCase()));

// Configuration field validation
DescribedPredicate<JavaField> isConfigurationField = 
    isAssignableTo(org.apache.flink.configuration.ConfigOption.class)
    .and(isStatic())
    .and(isFinal());

// Service field validation (dependency injection)
DescribedPredicate<JavaField> isServiceField = 
    annotatedWith("org.springframework.beans.factory.annotation.Autowired")
    .and(isNotStatic())
    .and(field -> !field.getModifiers().contains(JavaModifier.FINAL));