package annotations;
/*>>>
import org.checkerframework.checker.nullness.qual.*;
*/
import java.util.*;
import annotations.field.*;
import annotations.el.AnnotationDef;
/**
* An {@link AnnotationBuilder} builds a single annotation object after the
* annotation's fields have been supplied one by one.
*
* <p>
* It is not possible to specify the type name or the retention policy.
* Either the {@link AnnotationBuilder} expects a certain definition (and
* may throw exceptions if the fields deviate from it) or it determines the
* definition automatically from the supplied fields.
*
* <p>
* Each {@link AnnotationBuilder} is mutable and single-use; the purpose of an
* {@link AnnotationFactory} is to produce as many {@link AnnotationBuilder}s
* as needed.
*/
public class AnnotationBuilder {
// Sometimes, we build the AnnotationDef at the very end, and sometimes
// we have it before starting.
AnnotationDef def;
private String typeName;
Set<Annotation> tlAnnotationsHere;
boolean arrayInProgress = false;
boolean active = true;
// Generally, don't use this. Use method fieldTypes() instead.
private Map<String, AnnotationFieldType> fieldTypes =
new LinkedHashMap<String, AnnotationFieldType>();
Map<String, Object> fieldValues =
new LinkedHashMap<String, Object>();
public String typeName() {
if (def != null) {
return def.name;
} else {
return typeName;
}
}
public Map<String, AnnotationFieldType> fieldTypes() {
if (def != null) {
return def.fieldTypes;
} else {
return fieldTypes;
}
}
class SimpleArrayBuilder implements ArrayBuilder {
boolean abActive = true;
String fieldName;
AnnotationFieldType aft; // the type for the elements
List<Object> arrayElements =
new ArrayList<Object>();
SimpleArrayBuilder(String fieldName, AnnotationFieldType aft) {
assert aft != null;
assert fieldName != null;
this.fieldName = fieldName;
this.aft = aft;
}
public void appendElement(Object x) {
if (!abActive) {
throw new IllegalStateException("Array is finished");
}
if (!aft.isValidValue(x)) {
throw new IllegalArgumentException(String.format("Bad array element value%n %s (%s)%nfor field %s%n %s (%s)",
x, x.getClass(), fieldName, aft, aft.getClass()));
}
arrayElements.add(x);
}
public void finish() {
if (!abActive) {
throw new IllegalStateException("Array is finished");
}
fieldValues.put(fieldName, Collections
.<Object>unmodifiableList(arrayElements));
arrayInProgress = false;
abActive = false;
}
}
private void checkAddField(String fieldName) {
if (!active) {
throw new IllegalStateException("Already finished");
}
if (arrayInProgress) {
throw new IllegalStateException("Array in progress");
}
if (fieldValues.containsKey(fieldName)) {
throw new IllegalArgumentException("Duplicate field \'"
+ fieldName + "\' in " + fieldValues);
}
}
/**
* Supplies a scalar field of the given name, type, and value for inclusion
* in the annotation returned by {@link #finish}. See the rules for values
* on {@link Annotation#getFieldValue}.
*
* <p>
* Each field may be supplied only once. This method may throw an exception
* if the {@link AnnotationBuilder} expects a certain definition for
* the built annotation and the given field does not exist in that
* definition or has the wrong type.
*/
public void addScalarField(String fieldName, ScalarAFT aft, Object x) {
checkAddField(fieldName);
if (x instanceof Annotation && !(x instanceof Annotation)) {
throw new IllegalArgumentException("All subannotations must be Annotations");
}
if (def == null) {
fieldTypes.put(fieldName, aft);
}
fieldValues.put(fieldName, x);
}
/**
* Begins supplying an array field of the given name and type. The elements
* of the array must be passed to the returned {@link ArrayBuilder} in
* order, and the {@link ArrayBuilder} must be finished before any other
* methods on this {@link AnnotationBuilder} are called.
* <code>aft.{@link ArrayAFT#elementType elementType}</code> must be known
* (not <code>null</code>).
*
* <p>
* Each field may be supplied only once. This method may throw an exception
* if the {@link AnnotationBuilder} expects a certain definition for
* the built annotation and the given field does not exist in that
* definition or has the wrong type.
*/
public ArrayBuilder beginArrayField(String fieldName, ArrayAFT aft) {
checkAddField(fieldName);
if (def == null) {
fieldTypes.put(fieldName, aft);
} else {
aft = (ArrayAFT) fieldTypes().get(fieldName);
if (aft == null) {
throw new Error(String.format("Definition for %s lacks field %s:%n %s",
def.name, fieldName, def));
}
assert aft != null;
}
arrayInProgress = true;
assert aft.elementType != null;
return new SimpleArrayBuilder(fieldName, aft.elementType);
}
/**
* Supplies an zero-element array field whose element type is unknown. The
* field type of this array is represented by an {@link ArrayAFT} with
* {@link ArrayAFT#elementType elementType} == <code>null</code>.
*
* <p>
* This can sometimes happen due to a design flaw in the format of
* annotations in class files. An array value does not specify an type
* itself; instead, each element carries a type. Thus, a zero-length array
* carries no indication of its element type.
*/
public void addEmptyArrayField(String fieldName) {
checkAddField(fieldName);
if (def == null) {
fieldTypes.put(fieldName, new ArrayAFT(null));
}
fieldValues.put(fieldName, Collections.emptyList());
}
/**
* Returns the completed annotation. This method may throw an exception if
* the {@link AnnotationBuilder} expects a certain definition for the
* built annotation and one or more fields in that definition were not
* supplied. Once this method has been called, no more method calls may be
* made on this {@link AnnotationBuilder}.
*/
public Annotation finish() {
if (!active) {
throw new IllegalStateException("Already finished: " + this);
}
if (arrayInProgress) {
throw new IllegalStateException("Array in progress: " + this);
}
active = false;
if (def == null) {
assert fieldTypes != null;
def = new AnnotationDef(typeName, tlAnnotationsHere, fieldTypes);
} else {
assert typeName == null;
assert fieldTypes.isEmpty();
}
return new Annotation(def, fieldValues);
}
AnnotationBuilder(AnnotationDef def) {
assert def != null;
this.def = def;
}
AnnotationBuilder(String typeName) {
assert typeName != null;
this.typeName = typeName;
}
AnnotationBuilder(String typeName, Set<Annotation> tlAnnotationsHere) {
assert typeName != null;
this.typeName = typeName;
this.tlAnnotationsHere = tlAnnotationsHere;
}
public String toString() {
if (def != null) {
return String.format("AnnotationBuilder %s", def);
} else {
return String.format("(AnnotationBuilder %s : %s)", typeName, tlAnnotationsHere);
}
}
}