/** * 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; }
/** Walk all the included declarations and accumulate the set of referenced groups */ protected void computegroups() { // 1. variables for (int i = 0; i < variables.size(); i++) { DapVariable var = variables.get(i); List<DapGroup> path = var.getGroupPath(); for (DapGroup group : path) { if (!this.groups.contains(group)) this.groups.add(group); } } // 2. Dimensions for (DapDimension dim : this.dimrefs) { if (!dim.isShared()) continue; List<DapGroup> path = dim.getGroupPath(); for (DapGroup group : path) { if (!this.groups.contains(group)) this.groups.add(group); } } // 2. enumerations for (DapEnum en : this.enums) { List<DapGroup> path = en.getGroupPath(); for (DapGroup group : path) { if (!this.groups.contains(group)) this.groups.add(group); } } }
public void addAttribute(DapNode node, DapAttribute attr) { List<DapAttribute> attrs = this.attributes.get(node); if (attrs == null) { attrs = new ArrayList<DapAttribute>(); this.attributes.put(node, attrs); } attrs.add(attr); }
/** Walk all the included variables and accumulate the referenced enums */ protected void computeenums() { for (int i = 0; i < variables.size(); i++) { DapVariable var = variables.get(i); if (var.getSort() != DapSort.ATOMICVARIABLE) continue; DapType daptype = var.getBaseType(); if (!daptype.isEnumType()) continue; if (!this.enums.contains((DapEnum) daptype)) this.enums.add((DapEnum) daptype); } }
/** * Convert the view to a constraint string suitable for use in a URL, except not URL encoded. * * @return constraint string */ public String toConstraintString() { StringBuilder buf = new StringBuilder(); boolean first = true; for (int i = 0; i < segments.size(); i++) { Segment seg = segments.get(i); if (!seg.var.isTopLevel()) continue; if (!first) buf.append(";"); first = false; dumpvar(seg, buf, true); } return buf.toString(); }
/** * Locate each Structure|Sequence and: 1. check that all of its fields are referenced recursively * and not constrained, otherwise ignore 2. contract by removing all of the fields of the * Structure or Sequence. This is intended to be (not quite) the dual of expand(); */ public void contract() { // Create a set of contracted compounds Set<DapStructure> contracted = new HashSet<>(); for (int i = 0; i < variables.size(); i++) { DapVariable var = variables.get(i); if (var.isTopLevel()) { if (var.getSort() == DapSort.STRUCTURE || var.getSort() == DapSort.SEQUENCE) { contractR((DapStructure) var, contracted); } } } this.expansion = Expand.CONTRACTED; }
/** * 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 String toString() { StringBuilder buf = new StringBuilder(); buf.append(var.getFQN()); buf.append(slices.toString()); if (this.filter != null) { buf.append("|"); buf.append(filter.toString()); } return buf.toString(); }
/** * 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()); } } }
/** * Compute dimension related information using slicing and redef info. In effect, this is where * projection constraints are applied * * <p>Assume that the constraint compiler has given us the following info: * * <ol> * <li>A list of the variables to include. * <li>A pair (DapDimension,Slice) for each redef * <li>For each variable in #1, a list of slices taken from the constraint expression * </ol> * * <p>Two products will be produced. * * <ol> * <li>The variables map will be modified so that the slices properly reflect any original or * redef dimensions. * <li>A set, dimrefs, of all referenced original dimensions. * </ol> * * <p>The processing is as follows * * <ol> * <li>For each redef create a new redef dimension * <li>For each variable: * <ol> * <li>if the variable is scalar, do nothing. * <li>if the variable has no associated slices, then make its new dimensions be the * original dimensions. * <li>otherwise, walk the slices and create new dimensions from them; use redefs where * indicated * <li> * </ol> * </ol> */ protected void computedimensions() throws DapException { // Build the redefmap for (DapDimension key : redefslice.keySet()) { Slice slice = redefslice.get(key); DapDimension newdim = (DapDimension) key.clone(); newdim.setSize(slice.getCount()); redef.put(key, newdim); } // Process each variable for (int i = 0; i < segments.size(); i++) { Segment seg = segments.get(i); if (seg.var.getRank() == 0) continue; List<Slice> slices = seg.slices; List<DapDimension> orig = seg.var.getDimensions(); List<DapDimension> newdims = new ArrayList<>(); // If the slice list is short then pad it with // default slices if (slices == null) slices = new ArrayList<Slice>(); while (slices.size() < orig.size()) // pad { slices.add(new Slice().setConstrained(false)); } assert (slices != null && slices.size() == orig.size()); for (int j = 0; j < slices.size(); j++) { Slice slice = slices.get(j); DapDimension dim0 = orig.get(j); DapDimension newdim = redef.get(dim0); if (newdim == null) newdim = dim0; // fill in the undefined last value slice.setMaxSize(newdim.getSize()); slice.finish(); Slice newslice = null; if (slice.isConstrained()) { // Construct an anonymous dimension for this slice newdim = new DapDimension(slice.getCount()); } else { // replace with a new slice from the dim newslice = new Slice(newdim); if (newslice != null) { // track set of referenced non-anonymous dimensions if (!dimrefs.contains(dim0)) dimrefs.add(dim0); slices.set(j, newslice); } } // record the dimension per variable newdims.add(newdim); } seg.setDimset(newdims); } }
protected Segment findSegment(DapVariable var) { for (int i = 0; i < segments.size(); i++) { if (segments.get(i).var == var) return segments.get(i); } return null; }
/* Search the set of variables */ protected int findVariableIndex(DapVariable var) { for (int i = 0; i < variables.size(); i++) { if (variables.get(i) == var) return i; } return -1; }
public List<DapDimension> getConstrainedDimensions(DapVariable var) { List<DapDimension> dimset = null; int index = findVariableIndex(var); if (index >= 0) dimset = segments.get(index).dimset; return dimset; }
/** * @param ce the constraint over which to iterate * @throws DapException */ public ReferenceIterator(CEConstraint ce) throws DapException { list.addAll(ce.dimrefs); list.addAll(ce.enums); list.addAll(ce.variables); listiter = list.iterator(); }