示例#1
0
  private int keyCompare(String s1, String s2) {
    SortKey<Object> k1 = sort.createSortKey(null, s1);
    SortKey<Object> k2 = sort.createSortKey(null, s2);
    System.out.println("K1: " + k1);
    System.out.println("K2: " + k2);

    return k1.compareTo(k2);
  }
示例#2
0
  @Test
  public void testEquals() {
    String abc = "ABC\u0234\u1023";
    SortKey<Object> key1 = sort.createSortKey(null, abc);
    SortKey<Object> key2 = sort.createSortKey(null, abc);

    assertEquals(0, key1.compareTo(key2));
  }
 /**
  * {@inheritDoc}
  *
  * <p>
  */
 @Override
 public void resetSortOrders() {
   if (!isSortable()) return;
   List<SortKey> keys = new ArrayList<SortKey>(getSortKeys());
   for (int i = keys.size() - 1; i >= 0; i--) {
     SortKey sortKey = keys.get(i);
     if (isSortable(sortKey.getColumn())) {
       keys.remove(sortKey);
     }
   }
   setSortKeys(keys);
 }
示例#4
0
  public void drawFeatures(Graphics2D graphics, final StreamingRenderer renderer, String layerId)
      throws IOException, FactoryException, NoninvertibleTransformException, SchemaException,
          TransformException {
    // 1) init all the readers and the lfts associated to them (one at a time to avoid deadlock)
    // and create one RenderableFeature for each
    // 2) process all the features one z-level at a time, backtracking if there are multiple
    // fts for a certain layer.

    // a listener passed around to stop data reading/painting if rendering stop request is
    // issued
    ProgressListener cancellationListener =
        new DefaultProgressListener() {
          public boolean isCanceled() {
            return renderer.renderingStopRequested;
          };
        };

    List<ZGroupLayerPainter> painters = null;
    try {
      painters = buildLayerPainters(graphics, renderer, layerId, cancellationListener);
      if (painters.isEmpty()) {
        return;
      }

      // get a comparator to find the first key to paint
      Comparator<SortKey> comparator = SortKey.buildComparator(painters.get(0).sortBy);

      // paint all the features as we can
      SortKey previousKey = null;
      while (!painters.isEmpty()) {
        SortKey smallestKey = getSmallestKey(painters, comparator);
        if (previousKey == null) {
          previousKey = smallestKey;
        } else if (comparator.compare(previousKey, smallestKey) >= 0) {
          throw new IllegalStateException(
              "The sorted rendering moved from a set of "
                  + "sort attributes, to one that's equal or greater, this is unexpected, "
                  + "bailing out to avoid an infinite loop");
        } else {
          previousKey = smallestKey;
        }

        for (Iterator it = painters.iterator(); it.hasNext(); ) {
          ZGroupLayerPainter painter = (ZGroupLayerPainter) it.next();
          painter.paintKey(smallestKey);
          // if the painter is done, close it
          if (painter.complete()) {
            painter.close();
            it.remove();
          }
        }
      }
    } finally {
      if (painters != null) {
        for (ZGroupLayerPainter painter : painters) {
          painter.close();
        }
      }
    }
  }
 public void setSortKeys(List<? extends SortKey> keys) {
   if ((keys == null) || keys.isEmpty()) {
     setSorter(null);
     return;
   }
   SortKey sortKey = SortKey.getFirstSortingKey(keys);
   // only crappy unsorted...
   if (sortKey == null) return;
   Sorter sorter = getSorter();
   if (sorter == null) {
     sorter = createDefaultSorter();
   }
   sorter.setSortKey(sortKey);
   // technically, we could re-use the sorter
   // and only reset column, comparator and direction
   // need to detangle from TableColumn before going there...
   // so for now we only change the order if we have a sorter
   // for the given column, create a new default sorter if not
   //            if ((currentSorter == null) ||
   //                    (currentSorter.getColumnIndex() != sortKey.getColumn())) {
   //                currentSorter = createDefaultSorter(sortKey);
   //            }
   //            if (currentSorter.isAscending() != sortKey.getSortOrder().isAscending()) {
   //                currentSorter.setAscending(sortKey.getSortOrder().isAscending());
   //            }
   setSorter(sorter);
 }
 void doApply(
     Stylesheet stylesheet,
     QName mode,
     Node context,
     int pos,
     int len,
     Node parent,
     Node nextSibling)
     throws TransformerException {
   if (children != null) {
     // Set current template to null
     Template saved = stylesheet.currentTemplate;
     stylesheet.currentTemplate = null;
     Object ret = select.evaluate(context, pos, len);
     // System.err.println(toString() + ": " + context+" -> "+ret);
     if (ret instanceof Collection) {
       Collection ns = (Collection) ret;
       List list = new ArrayList(ns);
       if (sortKeys != null) {
         for (Iterator i = sortKeys.iterator(); i.hasNext(); ) {
           SortKey sortKey = (SortKey) i.next();
           sortKey.init(stylesheet, mode, context, pos, len, parent, nextSibling);
         }
         Collections.sort(list, new XSLComparator(sortKeys));
       } else {
         Collections.sort(list, documentOrderComparator);
       }
       // Perform children for each node
       int l = list.size();
       int p = 1;
       for (Iterator i = list.iterator(); i.hasNext(); ) {
         Node node = (Node) i.next();
         stylesheet.current = node;
         children.apply(stylesheet, mode, node, p++, l, parent, nextSibling);
       }
     }
     // Restore current template
     stylesheet.currentTemplate = saved;
   }
   if (next != null) {
     next.apply(stylesheet, mode, context, pos, len, parent, nextSibling);
   }
 }
 /**
  * {@inheritDoc}
  *
  * <p>Overridden - that is completely new implementation - to get first/next SortOrder from sort
  * order cycle. Does nothing if the cycle is empty.
  */
 @Override
 public void toggleSortOrder(int column) {
   checkColumn(column);
   if (!isSortable(column)) return;
   SortOrder firstInCycle = getFirstInCycle();
   // nothing to toggle through
   if (firstInCycle == null) return;
   List<SortKey> keys = new ArrayList<SortKey>(getSortKeys());
   SortKey sortKey = SortUtils.getFirstSortKeyForColumn(keys, column);
   if (keys.indexOf(sortKey) == 0) {
     //  primary key: in this case we'll use next sortorder in cylce
     keys.set(0, new SortKey(column, getNextInCycle(sortKey.getSortOrder())));
   } else {
     // all others: make primary with first sortOrder in cycle
     keys.remove(sortKey);
     keys.add(0, new SortKey(column, getFirstInCycle()));
   }
   if (keys.size() > getMaxSortKeys()) {
     keys = keys.subList(0, getMaxSortKeys());
   }
   setSortKeys(keys);
 }
 /**
  * {@inheritDoc}
  *
  * <p>
  */
 @Override
 public SortOrder getSortOrder(int column) {
   SortKey key = SortUtils.getFirstSortKeyForColumn(getSortKeys(), column);
   return key != null ? key.getSortOrder() : SortOrder.UNSORTED;
 }