AbstractIdentifiableAnnotatedJavaStructureBuilder.java

package org.springframework.roo.classpath.details;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang3.Validate;
import org.springframework.roo.classpath.details.annotations.AnnotationAttributeValue;
import org.springframework.roo.classpath.details.annotations.AnnotationMetadata;
import org.springframework.roo.classpath.details.annotations.AnnotationMetadataBuilder;
import org.springframework.roo.model.Builder;
import org.springframework.roo.model.JavaSymbolName;
import org.springframework.roo.model.JavaType;

/**
 * Assists in the creation of a {@link Builder} for types that eventually
 * implement {@link IdentifiableAnnotatedJavaStructure}.
 * 
 * @author Ben Alex
 * @since 1.1
 */
public abstract class AbstractIdentifiableAnnotatedJavaStructureBuilder<T extends IdentifiableAnnotatedJavaStructure>
    extends AbstractIdentifiableJavaStructureBuilder<T> {
  private List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();

  protected AbstractIdentifiableAnnotatedJavaStructureBuilder(
      final IdentifiableAnnotatedJavaStructure existing) {
    super(existing);
    init(existing);
  }

  protected AbstractIdentifiableAnnotatedJavaStructureBuilder(final String declaredbyMetadataId) {
    super(declaredbyMetadataId);
  }

  protected AbstractIdentifiableAnnotatedJavaStructureBuilder(final String declaredbyMetadataId,
      final IdentifiableAnnotatedJavaStructure existing) {
    super(declaredbyMetadataId, existing);
    init(existing);
  }

  public final boolean addAnnotation(final AnnotationMetadata annotationMetadata) {
    if (annotationMetadata == null) {
      return false;
    }
    return addAnnotation(new AnnotationMetadataBuilder(annotationMetadata));
  }

  public final boolean addAnnotation(final AnnotationMetadataBuilder annotationBuilder) {
    if (annotationBuilder == null) {
      return false;
    }
    onAddAnnotation(annotationBuilder);
    return annotations.add(annotationBuilder);
  }

  public final List<AnnotationMetadata> buildAnnotations() {
    final List<AnnotationMetadata> result = new ArrayList<AnnotationMetadata>();
    for (final AnnotationMetadataBuilder annotationBuilder : annotations) {
      result.add(annotationBuilder.build());
    }
    return result;
  }

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

  /**
   * Locates the specified type-level annotation.
   * 
   * @param type to locate (can be <code>null</code>)
   * @return the annotation, or null if not found
   * @since 1.2.0
   */
  public AnnotationMetadataBuilder getDeclaredTypeAnnotation(final JavaType type) {
    for (final AnnotationMetadataBuilder annotationBuilder : getAnnotations()) {
      if (annotationBuilder.getAnnotationType().equals(type)) {
        return annotationBuilder;
      }
    }
    return null;
  }

  private void init(final IdentifiableAnnotatedJavaStructure existing) {
    for (final AnnotationMetadata element : existing.getAnnotations()) {
      this.annotations.add(new AnnotationMetadataBuilder(element));
    }
  }

  protected void onAddAnnotation(final AnnotationMetadataBuilder annotationMetadata) {}

  public void removeAnnotation(final JavaType annotationType) {
    for (final AnnotationMetadataBuilder annotationMetadataBuilder : annotations) {
      if (annotationMetadataBuilder.getAnnotationType().equals(annotationType)) {
        annotations.remove(annotationMetadataBuilder);
        break;
      }
    }
  }

  public final void setAnnotations(final Collection<AnnotationMetadata> annotations) {
    final List<AnnotationMetadataBuilder> annotationBuilders =
        new ArrayList<AnnotationMetadataBuilder>();
    for (final AnnotationMetadata annotationMetadata : annotations) {
      annotationBuilders.add(new AnnotationMetadataBuilder(annotationMetadata));
    }
    setAnnotations(annotationBuilders);
  }

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

  public boolean updateTypeAnnotation(final AnnotationMetadata annotation) {
    return updateTypeAnnotation(annotation, null);
  }

  public boolean updateTypeAnnotation(final AnnotationMetadata annotation,
      final Set<JavaSymbolName> attributesToDeleteIfPresent) {
    boolean hasChanged = false;

    // We are going to build a replacement AnnotationMetadata.
    // This variable tracks the new attribute values the replacement will
    // hold.
    final Map<JavaSymbolName, AnnotationAttributeValue<?>> replacementAttributeValues =
        new LinkedHashMap<JavaSymbolName, AnnotationAttributeValue<?>>();

    final AnnotationMetadataBuilder existingBuilder =
        getDeclaredTypeAnnotation(annotation.getAnnotationType());

    if (existingBuilder == null) {
      // Not already present, so just go and add it
      for (final JavaSymbolName incomingAttributeName : annotation.getAttributeNames()) {
        // Do not copy incoming attributes which exist in the
        // attributesToDeleteIfPresent Set
        if (attributesToDeleteIfPresent == null
            || !attributesToDeleteIfPresent.contains(incomingAttributeName)) {
          final AnnotationAttributeValue<?> incomingValue =
              annotation.getAttribute(incomingAttributeName);
          replacementAttributeValues.put(incomingAttributeName, incomingValue);
        }
      }

      final AnnotationMetadataBuilder replacement =
          new AnnotationMetadataBuilder(annotation.getAnnotationType(),
              new ArrayList<AnnotationAttributeValue<?>>(replacementAttributeValues.values()));
      addAnnotation(replacement);
      return true;
    }

    final AnnotationMetadata existing = existingBuilder.build();

    // Copy the existing attributes into the new attributes
    for (final JavaSymbolName existingAttributeName : existing.getAttributeNames()) {
      if (attributesToDeleteIfPresent != null
          && attributesToDeleteIfPresent.contains(existingAttributeName)) {
        hasChanged = true;
      } else {
        final AnnotationAttributeValue<?> existingValue =
            existing.getAttribute(existingAttributeName);
        replacementAttributeValues.put(existingAttributeName, existingValue);
      }
    }

    // Now we ensure every incoming attribute replaces the existing
    for (final JavaSymbolName incomingAttributeName : annotation.getAttributeNames()) {
      final AnnotationAttributeValue<?> incomingValue =
          annotation.getAttribute(incomingAttributeName);

      // Add this attribute to the end of the list if the attribute is not
      // already present
      if (replacementAttributeValues.keySet().contains(incomingAttributeName)) {
        // There was already an attribute. Need to determine if this new
        // attribute value is materially different
        final AnnotationAttributeValue<?> existingValue =
            replacementAttributeValues.get(incomingAttributeName);
        Validate.notNull(existingValue, "Existing value should have been provided by earlier loop");
        if (!existingValue.equals(incomingValue)) {
          replacementAttributeValues.put(incomingAttributeName, incomingValue);
          hasChanged = true;
        }
      } else if (attributesToDeleteIfPresent == null
          || !attributesToDeleteIfPresent.contains(incomingAttributeName)) {
        // This is a new attribute that does not already exist, so add
        // it to the end of the replacement attributes
        replacementAttributeValues.put(incomingAttributeName, incomingValue);
        hasChanged = true;
      }
    }
    // Were there any material changes?
    if (!hasChanged) {
      return false;
    }

    // Make a new AnnotationMetadata representing the replacement
    final AnnotationMetadataBuilder replacement =
        new AnnotationMetadataBuilder(annotation.getAnnotationType(),
            new ArrayList<AnnotationAttributeValue<?>>(replacementAttributeValues.values()));
    annotations.remove(existingBuilder);
    addAnnotation(replacement);

    return true;
  }

  public boolean updateTypeAnnotation(final AnnotationMetadataBuilder annotationBuilder) {
    return updateTypeAnnotation(annotationBuilder.build());
  }
}