FieldDetails.java

package org.springframework.roo.classpath.details;

import static org.springframework.roo.model.JpaJavaType.COLUMN;
import static org.springframework.roo.model.Jsr303JavaType.NOT_NULL;
import static org.springframework.roo.model.Jsr303JavaType.NULL;
import static org.springframework.roo.model.SpringJavaType.VALUE;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.springframework.roo.classpath.PhysicalTypeIdentifier;
import org.springframework.roo.classpath.details.annotations.AnnotationAttributeValue;
import org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder;
import org.springframework.roo.classpath.details.annotations.BooleanAttributeValue;
import org.springframework.roo.classpath.details.annotations.StringAttributeValue;
import org.springframework.roo.model.JavaSymbolName;
import org.springframework.roo.model.JavaType;

/**
 * Base class containing common JSR 303 and JSR 220 properties that can be
 * auto-generated.
 * 
 * @author Ben Alex
 * @since 1.0
 */
public class FieldDetails {

  /** The JPA @Column value */
  private String column;

  /** Any JavaDoc comments (reserved for future expansion) */
  protected String comment;

  /** The name of the field to be added */
  private final JavaSymbolName fieldName;

  /** The type of field to be added */
  private final JavaType fieldType;

  /** Whether the JSR 303 @NotNull annotation will be added */
  private boolean notNull;

  /** Whether the JSR 303 @Null annotation will be added */
  private boolean nullRequired;

  /** The type that will receive the field */
  private final String physicalTypeIdentifier;

  /** Whether unique = true is added to the @Column annotation */
  private boolean unique;

  /** The Spring @Value value **/
  private String value;

  /** Field Modifiers (e.g. private, transient) */
  private int modifiers;

  /** Contains field annotations */
  private List<AnnotationMetadataBuilder> annotations;

  /**
   * Constructor
   * 
   * @param physicalTypeIdentifier
   * @param fieldType
   * @param fieldName
   */
  public FieldDetails(final String physicalTypeIdentifier, final JavaType fieldType,
      final JavaSymbolName fieldName) {
    Validate.isTrue(PhysicalTypeIdentifier.isValid(physicalTypeIdentifier),
        "Destination physical type identifier is invalid");
    Validate.notNull(fieldType, "Field type required");
    Validate.notNull(fieldName, "Field name required");
    this.physicalTypeIdentifier = physicalTypeIdentifier;
    this.fieldType = fieldType;
    this.fieldName = fieldName;
  }

  public void decorateAnnotationsList(final List<AnnotationMetadataBuilder> annotations) {
    Validate.notNull(annotations);

    if (notNull) {
      annotations.add(new AnnotationMetadataBuilder(NOT_NULL));
    }

    if (nullRequired) {
      annotations.add(new AnnotationMetadataBuilder(NULL));
    }

    AnnotationMetadataBuilder columnBuilder = null;
    if (column != null) {
      final List<AnnotationAttributeValue<?>> attrs = new ArrayList<AnnotationAttributeValue<?>>();
      attrs.add(new StringAttributeValue(new JavaSymbolName("name"), column));
      columnBuilder = new AnnotationMetadataBuilder(COLUMN, attrs);
    }
    if (unique) {
      if (columnBuilder != null) {
        columnBuilder.addBooleanAttribute("unique", true);
      } else {
        final List<AnnotationAttributeValue<?>> attrs =
            new ArrayList<AnnotationAttributeValue<?>>();
        attrs.add(new BooleanAttributeValue(new JavaSymbolName("unique"), true));
        columnBuilder = new AnnotationMetadataBuilder(COLUMN, attrs);
      }
    }
    if (value != null) {
      final List<AnnotationAttributeValue<?>> attrs = new ArrayList<AnnotationAttributeValue<?>>();
      attrs.add(new StringAttributeValue(new JavaSymbolName("value"), value));
      annotations.add(new AnnotationMetadataBuilder(VALUE, attrs));
    }
    if (fieldName.getSymbolName().equals("created")) {
      if (columnBuilder == null) {
        columnBuilder = new AnnotationMetadataBuilder(COLUMN);
      }
      columnBuilder.addBooleanAttribute("updatable", false);
    }

    if (columnBuilder != null) {
      annotations.add(columnBuilder);
    }
  }

  public String getColumn() {
    return column;
  }

  public String getComment() {
    return comment;
  }

  public JavaSymbolName getFieldName() {
    return fieldName;
  }

  public JavaType getFieldType() {
    return fieldType;
  }

  public String getPhysicalTypeIdentifier() {
    return physicalTypeIdentifier;
  }

  public String getValue() {
    return value;
  }

  public boolean isNotNull() {
    return notNull;
  }

  public boolean isNullRequired() {
    return nullRequired;
  }

  public boolean isUnique() {
    return unique;
  }

  public int getModifiers() {
    return modifiers;
  }

  public List<AnnotationMetadataBuilder> getAnnotations() {
    return annotations;
  }

  public List<AnnotationMetadataBuilder> getInitedAnnotations() {
    if (annotations == null) {
      annotations = new ArrayList<AnnotationMetadataBuilder>();
    }
    return annotations;
  }

  public void setColumn(final String column) {
    this.column = column;
  }

  public void setComment(final String comment) {
    if (StringUtils.isNotBlank(comment)) {
      this.comment = comment;
    }
  }

  public void setNotNull(final boolean notNull) {
    this.notNull = notNull;
  }

  public void setNullRequired(final boolean nullRequired) {
    this.nullRequired = nullRequired;
  }

  public void setUnique(final boolean unique) {
    this.unique = unique;
  }

  public void setValue(final String value) {
    this.value = value;
  }

  public void setModifiers(int modifiers) {
    this.modifiers = modifiers;
  }

  public void setAnnotations(List<AnnotationMetadataBuilder> annotations) {
    this.annotations = annotations;
  }

  public void addAnnotations(List<AnnotationMetadataBuilder> annotations) {
    if (annotations == null || annotations.isEmpty()) {
      return;
    }

    // Initialize annotations if needed
    if (this.annotations == null) {
      this.annotations = new ArrayList<AnnotationMetadataBuilder>();
    }
    this.annotations.addAll(annotations);
  }
}