예제 #1
0
  /**
   * 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);
    }
  }
예제 #2
0
 /** 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);
     }
   }
 }
예제 #3
0
  /**
   * 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;
  }
예제 #4
0
 /** 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);
   }
 }
예제 #5
0
 /**
  * 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();
 }
예제 #6
0
 /**
  * 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;
 }
예제 #7
0
 /**
  * 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());
     }
   }
 }
예제 #8
0
 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;
 }
예제 #9
0
 /* 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;
 }
예제 #10
0
 public List<DapDimension> getConstrainedDimensions(DapVariable var) {
   List<DapDimension> dimset = null;
   int index = findVariableIndex(var);
   if (index >= 0) dimset = segments.get(index).dimset;
   return dimset;
 }