docs: private void computeIntersection() {
      final ByteMap<ExpressionDataPoint[]> ordered_intersection = 
          new ByteMap<ExpressionDataPoint[]>(); 
      final Iterator<ITimeSyncedIterator> it = queries.values().iterator();
      
      // assume we have at least on query in our set
      ITimeSyncedIterator sub = it.next();
      Map<String, ByteMap<Integer>> flattened_tags = 
          new HashMap<String, ByteMap<Integer>>(queries.size()); 
      ByteMap<Integer> tags = new ByteMap<Integer>();
      flattened_tags.put(sub.getId(), tags);
      ExpressionDataPoint[] dps = sub.values();
      
      for (int i = 0; i < sub.size(); i++) {
        final byte[] tagks = flattenTags(intersect_on_query_tagks, include_agg_tags,
            dps[i].tags(), dps[i].aggregatedTags(), sub);
        tags.put(tagks, i);
  
        final ExpressionDataPoint[] idps = new ExpressionDataPoint[queries.size()];
        idps[sub.getIndex()] = dps[i];
        ordered_intersection.put(tagks, idps);
      }
      
      if (!it.hasNext()) {
        setCurrentAndMeta(ordered_intersection);
        return;
      }
      
      while (it.hasNext()) {
        sub = it.next();
        tags = new ByteMap<Integer>();
        flattened_tags.put(sub.getId(), tags);
        dps = sub.values();
        
        // loop through the series in the sub iterator, compute the flattened tag
        // ids, then kick out any that are NOT in the existing intersection map.
        for (int i = 0; i < sub.size(); i++) {
          final byte[] tagks = flattenTags(intersect_on_query_tagks, include_agg_tags, 
              dps[i].tags(), dps[i].aggregatedTags(), sub);
          tags.put(tagks, i);
  
          final ExpressionDataPoint[] idps = ordered_intersection.get(tagks);
          if (idps == null) {
            if (LOG.isDebugEnabled()) {
              LOG.debug("Kicking out " + Bytes.pretty(tagks) + " from " + sub.getId());
            }
            sub.nullIterator(i);
            continue;
          }
          idps[sub.getIndex()] = dps[i];
        }
        
        // gotta go backwards now to complete the intersection by kicking
        // any series that appear in other sets but not HERE
        final Iterator<Entry<byte[], ExpressionDataPoint[]>> reverse_it = 
            ordered_intersection.iterator();
        while (reverse_it.hasNext()) {
          Entry<byte[], ExpressionDataPoint[]> e = reverse_it.next();
          if (!tags.containsKey(e.getKey())) {
            if (LOG.isDebugEnabled()) {
              LOG.debug("Kicking out " + Bytes.pretty(e.getKey()) + 
                  " from the main list since the query for " + sub.getId() + 
                  " didn't have it");
            }
            
            // null the iterators for the other sets
            for (final Map.Entry<String, ByteMap<Integer>> entry : 
                flattened_tags.entrySet()) {
              if (entry.getKey().equals(sub.getId())) {
                continue;
              }
              final Integer index = entry.getValue().get(e.getKey());
              if (index != null) {
                queries.get(entry.getKey()).nullIterator(index);
              }
            }
            
            reverse_it.remove();
          }
        }
      }
      
      // now set our properly condensed and ordered values
      if (ordered_intersection.size() < 1) {
        // TODO - is it best to toss an exception here or return an empty result?
        throw new IllegalDataException("No intersections found: " + this);
      }
      
      setCurrentAndMeta(ordered_intersection);
    }