/**
* Count the number of fields of a structure that already in this view.
*
* @param struct the dapstructure to check
* @return # of fields in this view
* @throws DapException
*/
protected int expansionCount(DapStructure struct) {
int count = 0;
for (DapVariable field : struct.getFields()) {
if (findVariableIndex(field) >= 0) count++;
}
return count;
}
/**
* Locate each unexpanded Structure|Sequence and: 1. check that none of its fields is referenced
* => do not expand 2. add all of its fields as leaves Note that #2 may end up adding additional
* leaf structs &/or seqs
*/
public void expand() {
// Create a queue of unprocessed leaf compounds
Queue<DapVariable> queue = new ArrayDeque<DapVariable>();
for (int i = 0; i < variables.size(); i++) {
DapVariable var = variables.get(i);
if (!var.isTopLevel()) continue;
// prime the queue
if (var.getSort() == DapSort.STRUCTURE || var.getSort() == DapSort.SEQUENCE) {
DapStructure struct = (DapStructure) var; // remember Sequence subclass Structure
if (expansionCount(struct) == 0) queue.add(var);
}
}
// Process the queue in prefix order
while (queue.size() > 0) {
DapVariable vvstruct = queue.remove();
DapStructure dstruct = (DapStructure) vvstruct;
for (DapVariable field : dstruct.getFields()) {
if (findVariableIndex(field) < 0) {
// Add field as leaf
this.segments.add(new Segment(field));
this.variables.add(field);
}
if (field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE) {
if (expansionCount((DapStructure) field) == 0) queue.add(field);
}
}
}
this.expansion = Expand.EXPANDED;
}
/**
* Recursive helper
*
* @param dstruct to contract
* @param contracted set of already contracted compounds
* @return true if this structure was contracted, false otherwise
*/
protected boolean contractR(DapStructure dstruct, Set<DapStructure> contracted) {
if (contracted.contains(dstruct)) return true;
int processed = 0;
List<DapVariable> fields = dstruct.getFields();
for (DapVariable field : fields) {
if (findVariableIndex(field) < 0) break; // this compound cannot be contracted
if ((field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE)
&& !contracted.contains((DapStructure) field)) {
if (!contractR((DapStructure) field, contracted))
break; // this compound cannot be contracted
}
processed++;
}
if (processed < fields.size()) return false;
contracted.add(dstruct); // all compound fields were successfully contracted.
return true;
}
public void structure(DapStructure struct) throws DapException {
List<DapVariable> fields = struct.getFields();
Odometer odom = null;
if (struct.getRank() == 0) { // scalar
odom = new ScalarOdometer();
} else { // dimensioned
List<Slice> slices = ce.getConstrainedSlices(struct);
odom = Odometer.factory(slices, struct.getDimensions(), false);
}
while (odom.hasNext()) {
// generate a value for each field recursively
for (int i = 0; i < fields.size(); i++) {
DapVariable field = fields.get(i);
variable(field);
}
odom.next();
}
}
/**
* See if a structure is "whole", which means that none of its fields is missing from the
* constraint, all of fields use default (non-constrained) dimension), and all of its fields are
* also whole. This must be done recursively.
*
* @param dstruct to test
* @return true if this structure is whole.
*/
protected boolean isWholeCompound(DapStructure dstruct) {
int processed = 0;
List<DapVariable> fields = dstruct.getFields();
for (DapVariable field : fields) {
// not contractable if this field has non-original dimensions
Segment seg = findSegment(field);
if (seg == null) break; // this compound is not whole
List<Slice> slices = seg.slices;
if (slices != null) {
for (Slice slice : slices) {
if (slice.isConstrained()) break;
}
}
if (field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE) {
if (!isWholeCompound((DapStructure) field)) break; // this compound is not whole
}
processed++;
}
return (processed == fields.size());
}
/**
* Recursive helper for tostring/toConstraintString
*
* @param seg
* @param buf
* @param forconstraint
*/
protected void dumpvar(Segment seg, StringBuilder buf, boolean forconstraint) {
if (seg.var.isTopLevel()) buf.append(seg.var.getFQN());
else buf.append(seg.var.getShortName());
List<DapDimension> dimset = seg.var.getDimensions();
// Add any slices
List<Slice> slices = seg.slices;
if (slices == null) dimset = new ArrayList<DapDimension>();
else assert dimset.size() == slices.size();
for (int i = 0; i < dimset.size(); i++) {
Slice slice = slices.get(i);
DapDimension dim = dimset.get(i);
try {
buf.append(forconstraint ? slice.toConstraintString() : slice.toString());
} catch (DapException de) {
}
}
// if the var is atomic, then we are done
if (seg.var.getSort() == DapSort.ATOMICVARIABLE) return;
// If structure and all fields are in the view, then done
if (seg.var.getSort() == DapSort.STRUCTURE || seg.var.getSort() == DapSort.SEQUENCE) {
if (!isWholeCompound((DapStructure) seg.var)) {
// Need to insert {...} and recurse
buf.append(LBRACE);
DapStructure struct = (DapStructure) seg.var;
boolean first = true;
for (DapVariable field : struct.getFields()) {
if (!first) buf.append(";");
first = false;
Segment fseg = findSegment(field);
dumpvar(fseg, buf, forconstraint);
}
buf.append(RBRACE);
}
if (seg.var.getSort() == DapSort.SEQUENCE && seg.filter != null) {
buf.append("|");
buf.append(seg.filter.toString());
}
}
}