Example usage for org.jfree.util SortOrder ASCENDING

Introduction

In this page you can find the example usage for org.jfree.util SortOrder ASCENDING.

Prototype

SortOrder ASCENDING

To view the source code for org.jfree.util SortOrder ASCENDING.

Click Source Link

Document

Ascending order.

Usage

From source file:grafici.StatistichePieChart.java

/**
 * Creates a sample dataset.//ww  w  . j a va 2 s .co m
 * 
 * @return A sample dataset.
 */
private static PieDataset createDataset(Table results, int indexVariabile, int indexValore) {
    DefaultPieDataset dataset = new DefaultPieDataset();
    for (TableItem item : results.getItems()) {
        dataset.setValue(item.getText(indexVariabile), new Double(item.getText(indexValore)));
        dataset.sortByKeys(SortOrder.ASCENDING);
    }
    return dataset;
}

---

From source file:org.jfree.data.KeyedValueComparator.java

/**
 * Compares two {@link KeyedValue} instances and returns an
 * <code>int</code> that indicates the relative order of the two objects.
 *
 * @param o1  object 1./*from   ww  w .  ja v a2s  . c o  m*/
 * @param o2  object 2.
 *
 * @return An int indicating the relative order of the objects.
 */
@Override
public int compare(Object o1, Object o2) {

    if (o2 == null) {
        return -1;
    }
    if (o1 == null) {
        return 1;
    }

    int result;

    KeyedValue kv1 = (KeyedValue) o1;
    KeyedValue kv2 = (KeyedValue) o2;

    if (this.type == KeyedValueComparatorType.BY_KEY) {
        if (this.order.equals(SortOrder.ASCENDING)) {
            result = kv1.getKey().compareTo(kv2.getKey());
        } else if (this.order.equals(SortOrder.DESCENDING)) {
            result = kv2.getKey().compareTo(kv1.getKey());
        } else {
            throw new IllegalArgumentException("Unrecognised sort order.");
        }
    } else if (this.type == KeyedValueComparatorType.BY_VALUE) {
        Number n1 = kv1.getValue();
        Number n2 = kv2.getValue();
        if (n2 == null) {
            return -1;
        }
        if (n1 == null) {
            return 1;
        }
        double d1 = n1.doubleValue();
        double d2 = n2.doubleValue();
        if (this.order.equals(SortOrder.ASCENDING)) {
            if (d1 > d2) {
                result = 1;
            } else if (d1 < d2) {
                result = -1;
            } else {
                result = 0;
            }
        } else if (this.order.equals(SortOrder.DESCENDING)) {
            if (d1 > d2) {
                result = -1;
            } else if (d1 < d2) {
                result = 1;
            } else {
                result = 0;
            }
        } else {
            throw new IllegalArgumentException("Unrecognised sort order.");
        }
    } else {
        throw new IllegalArgumentException("Unrecognised type.");
    }

    return result;
}

---

From source file:org.openfaces.component.chart.impl.plots.GridCategoryPlotAdapter.java

@Override
public boolean render(Graphics2D g2, Rectangle2D dataArea, int index, PlotRenderingInfo info,
        CategoryCrosshairState crossHairState) {
    final boolean customRenderingModeEnabled = getRenderer() != null
            && getRenderer() instanceof AreaFillRenderer;

    if (!customRenderingModeEnabled) {
        return super.render(g2, dataArea, index, info, crossHairState);
    }/*from  w  w  w.  j  a va  2  s  .c  o m*/

    CategoryItemRenderer categoryItemRenderer = getRenderer(index);
    CategoryDataset categoryDataset = getDataset(index);

    boolean isDataSetNotEmpty = !DatasetUtilities.isEmptyOrNull(categoryDataset);
    boolean isAscendingRowOrdering = getRowRenderingOrder() == SortOrder.ASCENDING;

    if (!isDataSetNotEmpty || categoryItemRenderer == null) {
        return false;
    }
    CategoryItemRendererState rendererState = categoryItemRenderer.initialise(g2, dataArea, this, index, info);
    rendererState.setCrosshairState(crossHairState);
    int totalRows = categoryDataset.getRowCount();

    if (isAscendingRowOrdering) {
        for (int currentRowIndex = 0; currentRowIndex < totalRows; currentRowIndex++) {
            renderColumns(g2, rendererState, dataArea, categoryItemRenderer, categoryDataset, index,
                    currentRowIndex);
        }
    } else {
        for (int currentRowIndex = totalRows - 1; currentRowIndex >= 0; currentRowIndex--) {
            renderColumns(g2, rendererState, dataArea, categoryItemRenderer, categoryDataset, index,
                    currentRowIndex);
        }
    }

    return true;
}

---

From source file:org.openfaces.component.chart.impl.plots.GridCategoryPlotAdapter.java

private void renderColumns(Graphics2D g2, CategoryItemRendererState state, Rectangle2D dataArea,
        CategoryItemRenderer renderer, CategoryDataset currentDataSet, int index, int row) {
    boolean isAscendingColumnOrder = getColumnRenderingOrder() == SortOrder.ASCENDING;
    CategoryAxis categoryAxis = getDomainAxisForDataset(index);
    ValueAxis valueAxis = getRangeAxisForDataset(index);
    int totalRendererPasses = renderer.getPassCount();
    int totalColumns = currentDataSet.getColumnCount();

    for (int currentPassIndex = 0; currentPassIndex < totalRendererPasses; currentPassIndex++) {
        if (isAscendingColumnOrder) {
            for (int columnIndex = 0; columnIndex < totalColumns; columnIndex++) {
                final boolean isLastColumn = columnIndex == totalColumns - 1;
                renderColumn(g2, state, dataArea, renderer, currentDataSet, categoryAxis, valueAxis, row,
                        currentPassIndex, columnIndex, isLastColumn);
            }/*from   w ww.  j  a v  a  2s  . c o  m*/
        } else {
            for (int columnIndex = totalColumns - 1; columnIndex >= 0; columnIndex--) {
                final boolean isLastColumn = columnIndex == 0;
                renderColumn(g2, state, dataArea, renderer, currentDataSet, categoryAxis, valueAxis, row,
                        currentPassIndex, columnIndex, isLastColumn);
            }
        }
    }
}

---

From source file:org.jfree.data.DefaultKeyedValuesTest.java

/**
 * Tests sorting of data by key (ascending).
 *//*from w  w w. j a v  a  2 s . c  o m*/
@Test
public void testSortByKeyAscending() {

    DefaultKeyedValues data = new DefaultKeyedValues();
    data.addValue("C", new Double(1.0));
    data.addValue("B", null);
    data.addValue("D", new Double(3.0));
    data.addValue("A", new Double(2.0));

    data.sortByKeys(SortOrder.ASCENDING);

    // check key order
    assertEquals(data.getKey(0), "A");
    assertEquals(data.getKey(1), "B");
    assertEquals(data.getKey(2), "C");
    assertEquals(data.getKey(3), "D");

    // check retrieve value by key
    assertEquals(data.getValue("A"), new Double(2.0));
    assertEquals(data.getValue("B"), null);
    assertEquals(data.getValue("C"), new Double(1.0));
    assertEquals(data.getValue("D"), new Double(3.0));

    // check retrieve value by index
    assertEquals(data.getValue(0), new Double(2.0));
    assertEquals(data.getValue(1), null);
    assertEquals(data.getValue(2), new Double(1.0));
    assertEquals(data.getValue(3), new Double(3.0));

}

---

From source file:org.jfree.data.DefaultKeyedValuesTest.java

/**
 * Tests sorting of data by value (ascending).
 *///w  w  w. ja v a2 s  .  c om
@Test
public void testSortByValueAscending() {

    DefaultKeyedValues data = new DefaultKeyedValues();
    data.addValue("C", new Double(1.0));
    data.addValue("B", null);
    data.addValue("D", new Double(3.0));
    data.addValue("A", new Double(2.0));

    data.sortByValues(SortOrder.ASCENDING);

    // check key order
    assertEquals(data.getKey(0), "C");
    assertEquals(data.getKey(1), "A");
    assertEquals(data.getKey(2), "D");
    assertEquals(data.getKey(3), "B");

    // check retrieve value by key
    assertEquals(data.getValue("A"), new Double(2.0));
    assertEquals(data.getValue("B"), null);
    assertEquals(data.getValue("C"), new Double(1.0));
    assertEquals(data.getValue("D"), new Double(3.0));

    // check retrieve value by index
    assertEquals(data.getValue(0), new Double(1.0));
    assertEquals(data.getValue(1), new Double(2.0));
    assertEquals(data.getValue(2), new Double(3.0));
    assertEquals(data.getValue(3), null);

}

---

From source file:com.rapidminer.gui.plotter.charts.ParetoChartPlotter.java

private void prepareData() {
    synchronized (dataTable) {
        data.clear();/*from  w w w .  j ava  2s .com*/

        if ((this.groupByColumn < 0) || (this.countColumn < 0) || (countValueIndex < 0)) {
            return;
        }

        if (!this.dataTable.isNominal(this.groupByColumn)) {
            return;
        }

        if (!this.dataTable.isNominal(this.countColumn)) {
            return;
        }

        Map<String, AtomicInteger> counters = new HashMap<>();
        Map<String, AtomicInteger> totalCounters = new HashMap<>();
        for (int v = 0; v < this.dataTable.getNumberOfValues(this.groupByColumn); v++) {
            String groupByValue = this.dataTable.mapIndex(this.groupByColumn, v);
            counters.put(groupByValue, new AtomicInteger(0));
            totalCounters.put(groupByValue, new AtomicInteger(0));
        }

        Iterator<DataTableRow> i = this.dataTable.iterator();
        while (i.hasNext()) {
            DataTableRow row = i.next();

            String groupByValue = this.dataTable.getValueAsString(row, this.groupByColumn);
            String countValue = this.dataTable.getValueAsString(row, this.countColumn);

            if (countValue != null && groupByValue != null) {
                if (countValue.equals(this.countValue)) {
                    counters.get(groupByValue).getAndIncrement();
                }
                totalCounters.get(groupByValue).getAndIncrement();
            }
        }

        for (Map.Entry<String, AtomicInteger> entry : counters.entrySet()) {
            String category = entry.getKey();
            int categoryCount = entry.getValue().intValue();
            int totalCount = totalCounters.get(category).intValue();
            data.addValue(category, categoryCount);
            totalData.addValue(category, totalCount);
        }

        // sort data
        switch (sortingDirectionIndex) {
        case KEYS_DESCENDING:
            data.sortByKeys(SortOrder.DESCENDING);
            totalData.sortByKeys(SortOrder.DESCENDING);
            break;
        case KEYS_ASCENDING:
            data.sortByKeys(SortOrder.ASCENDING);
            totalData.sortByKeys(SortOrder.ASCENDING);
            break;
        case VALUES_DESCENDING:
            data.sortByValues(SortOrder.DESCENDING);
            totalData.sortByValues(SortOrder.DESCENDING);
            break;
        case VALUES_ASCENDING:
            data.sortByValues(SortOrder.ASCENDING);
            totalData.sortByValues(SortOrder.ASCENDING);
            break;
        }
    }
}

---