package org.springframework.roo.classpath.details.annotations;
import static org.springframework.roo.model.JpaJavaType.COLUMN;
import static org.springframework.roo.model.JpaJavaType.EMBEDDED;
import static org.springframework.roo.model.JpaJavaType.EMBEDDED_ID;
import static org.springframework.roo.model.JpaJavaType.ENUMERATED;
import static org.springframework.roo.model.JpaJavaType.ID;
import static org.springframework.roo.model.JpaJavaType.LOB;
import static org.springframework.roo.model.JpaJavaType.MANY_TO_MANY;
import static org.springframework.roo.model.JpaJavaType.MANY_TO_ONE;
import static org.springframework.roo.model.JpaJavaType.ONE_TO_MANY;
import static org.springframework.roo.model.JpaJavaType.ONE_TO_ONE;
import static org.springframework.roo.model.JpaJavaType.TRANSIENT;
import static org.springframework.roo.model.JpaJavaType.VERSION;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.Map;
import org.apache.commons.lang3.Validate;
import org.springframework.roo.classpath.details.comments.CommentStructure;
import org.springframework.roo.model.Builder;
import org.springframework.roo.model.EnumDetails;
import org.springframework.roo.model.JavaSymbolName;
import org.springframework.roo.model.JavaType;
/**
* Builder for {@link AnnotationMetadata}.
* <p>
* The "add" method will replace any existing annotation attribute with the same
* name, taking care to preserve its location.
*
* @author Ben Alex
* @author Andrew Swan
* @since 1.1
*/
public class AnnotationMetadataBuilder implements Builder<AnnotationMetadata> {
public static final AnnotationMetadata JPA_COLUMN_ANNOTATION = getInstance(COLUMN);
public static final AnnotationMetadata JPA_EMBEDDED_ANNOTATION = getInstance(EMBEDDED);
public static final AnnotationMetadata JPA_EMBEDDED_ID_ANNOTATION = getInstance(EMBEDDED_ID);
public static final AnnotationMetadata JPA_ENUMERATED_ANNOTATION = getInstance(ENUMERATED);
public static final AnnotationMetadata JPA_ID_ANNOTATION = getInstance(ID);
public static final AnnotationMetadata JPA_LOB_ANNOTATION = getInstance(LOB);
public static final AnnotationMetadata JPA_MANY_TO_MANY_ANNOTATION = getInstance(MANY_TO_MANY);
public static final AnnotationMetadata JPA_MANY_TO_ONE_ANNOTATION = getInstance(MANY_TO_ONE);
public static final AnnotationMetadata JPA_ONE_TO_MANY_ANNOTATION = getInstance(ONE_TO_MANY);
public static final AnnotationMetadata JPA_ONE_TO_ONE_ANNOTATION = getInstance(ONE_TO_ONE);
public static final AnnotationMetadata JPA_TRANSIENT_ANNOTATION = getInstance(TRANSIENT);
public static final AnnotationMetadata JPA_VERSION_ANNOTATION = getInstance(VERSION);
/**
* Returns the metadata for the existing annotation, with no attribute
* values
*
* @param annotationType the annotation type (required)
* @return a non-<code>null</code> instance
* @since 1.2.0
*/
public static AnnotationMetadata getInstance(final Class<?> annotationType) {
return new AnnotationMetadataBuilder(annotationType).build();
}
public static AnnotationMetadata getInstance(final JavaType annotationType) {
return new AnnotationMetadataBuilder(annotationType).build();
}
public static AnnotationMetadataBuilder getInstance(
final JavaType annotationType,
final Collection<AnnotationAttributeValue<?>> attributeValues) {
return new AnnotationMetadataBuilder(annotationType, attributeValues);
}
/**
* Returns the metadata for the existing annotation, with no attribute
* values
*
* @param annotationType the fully-qualified name of the annotation type
* (required)
* @return a non-<code>null</code> instance
* @since 1.2.0
*/
public static AnnotationMetadata getInstance(final String annotationType) {
return new AnnotationMetadataBuilder(annotationType).build();
}
private JavaType annotationType;
private final Map<String, AnnotationAttributeValue<?>> attributeValues = new LinkedHashMap<String, AnnotationAttributeValue<?>>();
private CommentStructure commentStructure;
/**
* Constructor. The caller must set the annotation type via
* {@link #setAnnotationType(JavaType)} before calling {@link #build()}
*/
public AnnotationMetadataBuilder() {
}
/**
* Constructor for using an existing {@link AnnotationMetadata} as a
* baseline for building a new instance.
*
* @param existing required
*/
public AnnotationMetadataBuilder(final AnnotationMetadata existing) {
Validate.notNull(existing);
annotationType = existing.getAnnotationType();
for (final JavaSymbolName attributeName : existing.getAttributeNames()) {
attributeValues.put(attributeName.getSymbolName(),
existing.getAttribute(attributeName));
}
this.setCommentStructure(existing.getCommentStructure());
}
/**
* Constructor for no initial attribute values
*
* @param annotationType the annotation class (required)
* @since 1.2.0
*/
public AnnotationMetadataBuilder(final Class<?> annotationType) {
this(new JavaType(annotationType));
}
/**
* Constructor for no initial attribute values
*
* @param annotationType
*/
public AnnotationMetadataBuilder(final JavaType annotationType) {
this.annotationType = annotationType;
}
/**
* Constructor that accepts an optional list of values
*
* @param annotationType
* @param attributeValues can be <code>null</code>
*/
public AnnotationMetadataBuilder(final JavaType annotationType,
final Collection<AnnotationAttributeValue<?>> attributeValues) {
this.annotationType = annotationType;
setAttributes(attributeValues);
}
/**
* Constructor for no initial attribute values
*
* @param annotationType the fully-qualified name of the annotation type
* (required)
*/
public AnnotationMetadataBuilder(final String annotationType) {
this(new JavaType(annotationType));
}
public void addAttribute(final AnnotationAttributeValue<?> value) {
// Locate existing attribute with this key and replace it
attributeValues.put(value.getName().getSymbolName(), value);
}
public void addBooleanAttribute(final String key, final boolean value) {
addAttribute(new BooleanAttributeValue(new JavaSymbolName(key), value));
}
public void addCharAttribute(final String key, final char value) {
addAttribute(new CharAttributeValue(new JavaSymbolName(key), value));
}
/**
* Adds an attribute with the given {@link JavaType} as its value
*
* @param key the attribute name (required)
* @param javaType the value (required)
*/
public void addClassAttribute(final String key, final JavaType javaType) {
addAttribute(new ClassAttributeValue(new JavaSymbolName(key), javaType));
}
public void addClassAttribute(final String key,
final String fullyQualifiedTypeName) {
addAttribute(new ClassAttributeValue(new JavaSymbolName(key),
new JavaType(fullyQualifiedTypeName)));
}
public void addDoubleAttribute(final String key, final double value,
final boolean floatingPrecisionOnly) {
addAttribute(new DoubleAttributeValue(new JavaSymbolName(key), value,
floatingPrecisionOnly));
}
public void addEnumAttribute(final String key, final EnumDetails details) {
addAttribute(new EnumAttributeValue(new JavaSymbolName(key), details));
}
public void addEnumAttribute(final String key, final JavaType javaType,
final JavaSymbolName enumConstant) {
final EnumDetails details = new EnumDetails(javaType, enumConstant);
addAttribute(new EnumAttributeValue(new JavaSymbolName(key), details));
}
public void addEnumAttribute(final String key, final JavaType javaType,
final String enumConstant) {
final EnumDetails details = new EnumDetails(javaType,
new JavaSymbolName(enumConstant));
addAttribute(new EnumAttributeValue(new JavaSymbolName(key), details));
}
public void addEnumAttribute(final String key,
final String fullyQualifiedTypeName, final String enumConstant) {
final EnumDetails details = new EnumDetails(new JavaType(
fullyQualifiedTypeName), new JavaSymbolName(enumConstant));
addAttribute(new EnumAttributeValue(new JavaSymbolName(key), details));
}
public void addIntegerAttribute(final String key, final int value) {
addAttribute(new IntegerAttributeValue(new JavaSymbolName(key), value));
}
public void addLongAttribute(final String key, final long value) {
addAttribute(new LongAttributeValue(new JavaSymbolName(key), value));
}
public void addStringAttribute(final String key, final String value) {
addAttribute(new StringAttributeValue(new JavaSymbolName(key), value));
}
public AnnotationMetadata build() {
DefaultAnnotationMetadata annotationMetadata = new DefaultAnnotationMetadata(
getAnnotationType(),
new ArrayList<AnnotationAttributeValue<?>>(getAttributes()
.values()));
annotationMetadata.setCommentStructure(commentStructure);
return annotationMetadata;
}
public JavaType getAnnotationType() {
return annotationType;
}
public Map<String, AnnotationAttributeValue<?>> getAttributes() {
return attributeValues;
}
public void removeAttribute(final String key) {
// Locate existing attribute with this key and replace it
attributeValues.remove(key);
}
public void setAnnotationType(final JavaType annotationType) {
this.annotationType = annotationType;
}
/**
* Sets the attribute values
*
* @param attributeValues the values to set; can be <code>null</code> for
* none
*/
public void setAttributes(
final Collection<AnnotationAttributeValue<?>> attributeValues) {
this.attributeValues.clear();
if (attributeValues != null) {
for (final AnnotationAttributeValue<?> attributeValue : attributeValues) {
addAttribute(attributeValue);
}
}
}
public CommentStructure getCommentStructure() {
return commentStructure;
}
public void setCommentStructure(CommentStructure commentStructure) {
this.commentStructure = commentStructure;
}
}