static RepresentationType getType(FirstItemIterable<Representation> representations) {
Representation representation = representations.getFirst();
if (representation == null) {
return RepresentationType.STRING;
}
return representation.getRepresentationType();
}
public Representation<?> createRepresentation(Class<?> clazz) {
/* If we have a specific representation for this type, use it. */
if (reprMap_.containsKey(clazz)) {
return reprMap_.get(clazz);
}
/* Arrays need treating specially. */
else if (clazz.isArray()) {
Class<?> scalarClass = getScalarClass(clazz);
if (reprMap_.containsKey(scalarClass)) {
Representation<?> scalarRepr = reprMap_.get(scalarClass);
/* If the scalar type is a structured object
* (either appears in the map of known types with
* isColumn=false, or implicitly structured by being absent
* from that map),
* there's not much we can do with it, since you
* can't map that structure to a sequence of columns
* (you don't know how many there would be).
* So we have to discard it. */
if (scalarRepr == null || !scalarRepr.isColumn()) {
return null;
}
/* If the scalar type is a column type, assume that it's
* OK for an array (or array of arrays, or ...) to be
* a column too. Note however that this code is not
* quite right at the moment; it will work for identity
* representations, but ones that convert input objects
* to a different representation (e.g. toString) will
* go wrong here. */
else {
return createSimpleColumnRepresentation(clazz);
}
} else {
return null;
}
}
/* Non-array types with no special instructions will be treated
* as structured objects. */
else {
return createIdentityRepresentation(clazz, false);
}
}
@Override
public Job requestJob() {
Job assignJob = null;
synchronized (this.lock) {
for (int i = 0; i < this.nonSubmitted.size(); i++) {
Representation repSrc =
ResourceClosetImpl.getInstance()
.getResource(this.nonSubmitted.elementAt(i).getResource())
.getRepresentation(this.nonSubmitted.elementAt(i).getRepresentationSource());
if (repSrc.isReady()) {
assignJob = this.nonSubmitted.elementAt(i);
this.levelUp(assignJob);
return assignJob;
}
}
}
return assignJob;
}
public Object freeze(ColumnLoader.ValueSet valueSet) {
final int n = valueSet.map.keySet().size();
int extra = valueSet.containsNull ? 1 : 0;
Comparable[] codeValues = valueSet.map.keySet().toArray(new Comparable[n + extra]);
Arrays.sort(codeValues, 0, n);
ColumnLoader.ValueSet codeValueSet = new ColumnLoader.ValueSet(int.class);
for (Comparable value : valueSet.values) {
int code;
if (value == null) {
code = n;
} else {
code = Arrays.binarySearch(codeValues, value);
assert code >= 0 : code + ", " + value;
}
codeValueSet.add(code);
}
Object codes = representation.freeze(codeValueSet);
return Pair.of(codes, codeValues);
}
public Object getObject(Object dataSet, int ordinal) {
Pair<Object, Object[]> pair = (Pair<Object, Object[]>) dataSet;
int code = representation.getInt(pair.left, ordinal);
return pair.right[code];
}
/** {@inheritDoc} */
@Override
public String getValueRepresentation(WritableAssertionInfo info, Value value) {
return displayer.getValueRepresentation(info, value);
}
/** {@inheritDoc} */
@Override
public String getColumnRepresentation(WritableAssertionInfo info, Column column) {
return displayer.getColumnRepresentation(info, column);
}
/** {@inheritDoc} */
@Override
public String getRowRepresentation(WritableAssertionInfo info, Row row) {
return displayer.getRowRepresentation(info, row);
}
/** {@inheritDoc} */
@Override
public String getChangeRepresentation(WritableAssertionInfo info, Change change) {
return displayer.getChangeRepresentation(info, change);
}
/** {@inheritDoc} */
@Override
public String getRequestRepresentation(WritableAssertionInfo info, Request request) {
return displayer.getRequestRepresentation(info, request);
}
/** {@inheritDoc} */
@Override
public String getTableRepresentation(WritableAssertionInfo info, Table table) {
return displayer.getTableRepresentation(info, table);
}
public final Response ok(Representation representation) {
if (representation.isEmpty()) {
return noContent();
}
return response(Response.ok(), representation);
}
public String assemble(Representation representation) {
return representation.serialize(format, baseUri, extensions);
}
public static void write(
Representation representation, RepresentationFormat format, URI baseUri) {
representation.serialize(format, baseUri, null);
}
