AnnotationMetadataUtils.java

package org.springframework.roo.classpath.details;

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.ArrayAttributeValue;
import org.springframework.roo.classpath.details.annotations.BooleanAttributeValue;
import org.springframework.roo.classpath.details.annotations.CharAttributeValue;
import org.springframework.roo.classpath.details.annotations.ClassAttributeValue;
import org.springframework.roo.classpath.details.annotations.DoubleAttributeValue;
import org.springframework.roo.classpath.details.annotations.EnumAttributeValue;
import org.springframework.roo.classpath.details.annotations.IntegerAttributeValue;
import org.springframework.roo.classpath.details.annotations.LongAttributeValue;
import org.springframework.roo.classpath.details.annotations.NestedAnnotationAttributeValue;
import org.springframework.roo.classpath.details.annotations.StringAttributeValue;
import org.springframework.roo.model.EnumDetails;
import org.springframework.roo.model.ImportRegistrationResolver;
import org.springframework.roo.model.JavaSymbolName;
import org.springframework.roo.model.JavaType;

/**
 * Utilities to use with {@link AnnotationMetadata}.
 * 
 * @author Ben Alex
 * @author Alan Stewart
 * @since 1.0
 */
public abstract class AnnotationMetadataUtils {

  private static String computeAttributeValue(final AnnotationAttributeValue<?> value,
      final ImportRegistrationResolver resolver) {
    String attributeValue = null;
    if (value instanceof BooleanAttributeValue) {
      attributeValue = ((BooleanAttributeValue) value).getValue().toString();
    } else if (value instanceof CharAttributeValue) {
      attributeValue = "'" + ((CharAttributeValue) value).getValue().toString() + "'";
    } else if (value instanceof ClassAttributeValue) {
      final JavaType clazz = ((ClassAttributeValue) value).getValue();
      if (resolver == null || resolver.isFullyQualifiedFormRequiredAfterAutoImport(clazz)) {
        attributeValue = clazz.getFullyQualifiedTypeName() + ".class";
      } else {
        attributeValue = clazz.getSimpleTypeName() + ".class";
      }
    } else if (value instanceof DoubleAttributeValue) {
      final DoubleAttributeValue dbl = (DoubleAttributeValue) value;
      if (dbl.isFloatingPrecisionOnly()) {
        attributeValue = dbl.getValue().toString() + "F";
      } else {
        attributeValue = dbl.getValue().toString() + "D";
      }
    } else if (value instanceof EnumAttributeValue) {
      final EnumDetails enumDetails = ((EnumAttributeValue) value).getValue();
      final JavaType clazz = enumDetails.getType();
      if (resolver == null || resolver.isFullyQualifiedFormRequiredAfterAutoImport(clazz)) {
        attributeValue =
            clazz.getFullyQualifiedTypeName() + "." + enumDetails.getField().getSymbolName();
      } else {
        attributeValue = clazz.getSimpleTypeName() + "." + enumDetails.getField().getSymbolName();
      }
    } else if (value instanceof IntegerAttributeValue) {
      attributeValue = ((IntegerAttributeValue) value).getValue().toString();
    } else if (value instanceof LongAttributeValue) {
      attributeValue = ((LongAttributeValue) value).getValue().toString() + "L";
    } else if (value instanceof StringAttributeValue) {
      attributeValue = "\"" + ((StringAttributeValue) value).getValue() + "\"";
    } else if (value instanceof NestedAnnotationAttributeValue) {
      final AnnotationMetadata annotationMetadata =
          ((NestedAnnotationAttributeValue) value).getValue();
      final StringBuilder data = new StringBuilder("@");
      final JavaType annotationType = annotationMetadata.getAnnotationType();
      if (resolver == null || resolver.isFullyQualifiedFormRequiredAfterAutoImport(annotationType)) {
        data.append(annotationType.getFullyQualifiedTypeName());
      } else {
        data.append(annotationType.getSimpleTypeName());
      }
      if (!annotationMetadata.getAttributeNames().isEmpty()) {
        data.append("(");
        int i = 0;
        for (final JavaSymbolName attributeName : annotationMetadata.getAttributeNames()) {
          i++;
          if (i > 1) {
            data.append(", ");
          }
          data.append(attributeName.getSymbolName()).append(" = ");
          data.append(computeAttributeValue(annotationMetadata.getAttribute(attributeName),
              resolver));
        }
        data.append(")");
      }
      attributeValue = data.toString();
    } else if (value instanceof ArrayAttributeValue<?>) {
      final ArrayAttributeValue<?> array = (ArrayAttributeValue<?>) value;
      final StringBuilder data = new StringBuilder("{ ");
      int i = 0;
      for (final AnnotationAttributeValue<?> val : array.getValue()) {
        i++;
        if (i > 1) {
          data.append(", ");
        }
        data.append(computeAttributeValue(val, resolver));
      }
      data.append(" }");
      attributeValue = data.toString();
    }
    return attributeValue;
  }

  /**
   * Converts the annotation into a string-based form.
   * 
   * @param annotation to covert (required)
   * @return a string-based representation (never null)
   */
  public static String toSourceForm(final AnnotationMetadata annotation) {
    return toSourceForm(annotation, null);
  }

  /**
   * Converts the annotation into a string-based form.
   * 
   * @param annotation to covert (required)
   * @param resolver to use for automatic addition of used types (may be null)
   * @return a string-based representation (never null)
   */
  public static String toSourceForm(final AnnotationMetadata annotation,
      final ImportRegistrationResolver resolver) {
    Validate.notNull(annotation, "Annotation required");

    final StringBuilder sb = new StringBuilder();
    sb.append("@");

    if (resolver != null) {
      if (resolver.isFullyQualifiedFormRequiredAfterAutoImport(annotation.getAnnotationType())) {
        sb.append(annotation.getAnnotationType().getFullyQualifiedTypeName());
      } else {
        sb.append(annotation.getAnnotationType().getSimpleTypeName());
      }
    } else {
      sb.append(annotation.getAnnotationType().getFullyQualifiedTypeName());
    }

    if (annotation.getAttributeNames().isEmpty()) {
      return sb.toString();
    }

    sb.append("(");
    boolean requireComma = false;
    for (final JavaSymbolName attributeName : annotation.getAttributeNames()) {
      // Add a comma, to separate the last annotation attribute
      if (requireComma) {
        sb.append(", ");
        requireComma = false;
      }

      // Compute the value
      final AnnotationAttributeValue<?> value = annotation.getAttribute(attributeName);

      final String attributeValue = computeAttributeValue(value, resolver);

      if (attributeValue != null) {
        // We have a supported attribute
        if (!"value".equals(attributeName.getSymbolName())
            || annotation.getAttributeNames().size() > 1) {
          sb.append(attributeName.getSymbolName());
          sb.append(" = ");
        }
        sb.append(attributeValue);
        requireComma = true;
      }
    }
    sb.append(")");
    return sb.toString();
  }
}