/*

 * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.swing.table;

import java.text.Collator;

import java.util.*;

import javax.swing.DefaultRowSorter;

import javax.swing.RowFilter;

import javax.swing.SortOrder;

/**

 * An implementation of <code>RowSorter</code> that provides sorting

 * and filtering using a <code>TableModel</code>.

 * The following example shows adding sorting to a <code>JTable</code>:

 * <pre>

 *   TableModel myModel = createMyTableModel();

 *   JTable table = new JTable(myModel);

 *   table.setRowSorter(new TableRowSorter(myModel));

 * </pre>

 * This will do all the wiring such that when the user does the appropriate

 * gesture, such as clicking on the column header, the table will

 * visually sort.

 * <p>

 * <code>JTable</code>'s row-based methods and <code>JTable</code>'s

 * selection model refer to the view and not the underlying

 * model. Therefore, it is necessary to convert between the two.  For

 * example, to get the selection in terms of <code>myModel</code>

 * you need to convert the indices:

 * <pre>

 *   int[] selection = table.getSelectedRows();

 *   for (int i = 0; i < selection.length; i++) {

 *     selection[i] = table.convertRowIndexToModel(selection[i]);

 *   }

 * </pre>

 * Similarly to select a row in <code>JTable</code> based on

 * a coordinate from the underlying model do the inverse:

 * <pre>

 *   table.setRowSelectionInterval(table.convertRowIndexToView(row),

 *                                 table.convertRowIndexToView(row));

 * </pre>

 * <p>

 * The previous example assumes you have not enabled filtering.  If you

 * have enabled filtering <code>convertRowIndexToView</code> will return

 * -1 for locations that are not visible in the view.

 * <p>

 * <code>TableRowSorter</code> uses <code>Comparator</code>s for doing

 * comparisons. The following defines how a <code>Comparator</code> is

 * chosen for a column:

 * <ol>

 * <li>If a <code>Comparator</code> has been specified for the column by the

 *     <code>setComparator</code> method, use it.

 * <li>If the column class as returned by <code>getColumnClass</code> is

 *     <code>String</code>, use the <code>Comparator</code> returned by

 *     <code>Collator.getInstance()</code>.

 * <li>If the column class implements <code>Comparable</code>, use a

 *     <code>Comparator</code> that invokes the <code>compareTo</code>

 *     method.

 * <li>If a <code>TableStringConverter</code> has been specified, use it

 *     to convert the values to <code>String</code>s and then use the

 *     <code>Comparator</code> returned by <code>Collator.getInstance()</code>.

 * <li>Otherwise use the <code>Comparator</code> returned by

 *     <code>Collator.getInstance()</code> on the results from

 *     calling <code>toString</code> on the objects.

 * </ol>

 * <p>

 * In addition to sorting <code>TableRowSorter</code> provides the ability

 * to filter.  A filter is specified using the <code>setFilter</code>

 * method. The following example will only show rows containing the string

 * "foo":

 * <pre>

 *   TableModel myModel = createMyTableModel();

 *   TableRowSorter sorter = new TableRowSorter(myModel);

 *   sorter.setRowFilter(RowFilter.regexFilter(".*foo.*"));

 *   JTable table = new JTable(myModel);

 *   table.setRowSorter(sorter);

 * </pre>

 * <p>

 * If the underlying model structure changes (the

 * <code>modelStructureChanged</code> method is invoked) the following

 * are reset to their default values: <code>Comparator</code>s by

 * column, current sort order, and whether each column is sortable. The default

 * sort order is natural (the same as the model), and columns are

 * sortable by default.

 * <p>

 * <code>TableRowSorter</code> has one formal type parameter: the type

 * of the model.  Passing in a type that corresponds exactly to your

 * model allows you to filter based on your model without casting.

 * Refer to the documentation of <code>RowFilter</code> for an example

 * of this.

 * <p>

 * <b>WARNING:</b> <code>DefaultTableModel</code> returns a column

 * class of <code>Object</code>.  As such all comparisons will

 * be done using <code>toString</code>.  This may be unnecessarily

 * expensive.  If the column only contains one type of value, such as

 * an <code>Integer</code>, you should override <code>getColumnClass</code> and

 * return the appropriate <code>Class</code>.  This will dramatically

 * increase the performance of this class.

 *

 * @param <M> the type of the model, which must be an implementation of

 *            <code>TableModel</code>

 * @see javax.swing.JTable

 * @see javax.swing.RowFilter

 * @see javax.swing.table.DefaultTableModel

 * @see java.text.Collator

 * @see java.util.Comparator

 * @since 1.6

 */

public class TableRowSorter<M extends TableModel> extends DefaultRowSorter<M, Integer> {

    /**

     * Comparator that uses compareTo on the contents.

     */

    private static final Comparator<?> COMPARABLE_COMPARATOR =

            new ComparableComparator();

    /**

     * Underlying model.

     */

    private M tableModel;

    /**

     * For toString conversions.

     */

    private TableStringConverter stringConverter;

    /**

     * Creates a <code>TableRowSorter</code> with an empty model.

     */

    public TableRowSorter() {

        this(null);

    }

    /**

     * Creates a <code>TableRowSorter</code> using <code>model</code>

     * as the underlying <code>TableModel</code>.

     *

     * @param model the underlying <code>TableModel</code> to use,

     *        <code>null</code> is treated as an empty model

     */

    public TableRowSorter(M model) {

        setModel(model);

    }

    /**

     * Sets the <code>TableModel</code> to use as the underlying model

     * for this <code>TableRowSorter</code>.  A value of <code>null</code>

     * can be used to set an empty model.

     *

     * @param model the underlying model to use, or <code>null</code>

     */

    public void setModel(M model) {

        tableModel = model;

        setModelWrapper(new TableRowSorterModelWrapper());

    }

    /**

     * Sets the object responsible for converting values from the

     * model to strings.  If non-<code>null</code> this

     * is used to convert any object values, that do not have a

     * registered <code>Comparator</code>, to strings.

     *

     * @param stringConverter the object responsible for converting values

     *        from the model to strings

     */

    public void setStringConverter(TableStringConverter stringConverter) {

        this.stringConverter = stringConverter;

    }

    /**

     * Returns the object responsible for converting values from the

     * model to strings.

     *

     * @return object responsible for converting values to strings.

     */

    public TableStringConverter getStringConverter() {

        return stringConverter;

    }

    /**

     * Returns the <code>Comparator</code> for the specified

     * column.  If a <code>Comparator</code> has not been specified using

     * the <code>setComparator</code> method a <code>Comparator</code>

     * will be returned based on the column class

     * (<code>TableModel.getColumnClass</code>) of the specified column.

     * If the column class is <code>String</code>,

     * <code>Collator.getInstance</code> is returned.  If the

     * column class implements <code>Comparable</code> a private

     * <code>Comparator</code> is returned that invokes the

     * <code>compareTo</code> method.  Otherwise

     * <code>Collator.getInstance</code> is returned.

     *

     * @throws IndexOutOfBoundsException {@inheritDoc}

     */

    public Comparator<?> getComparator(int column) {

        Comparator<?> comparator = super.getComparator(column);

        if (comparator != null) {

            return comparator;

        }

        Class<?> columnClass = getModel().getColumnClass(column);

        if (columnClass == String.class) {

            return Collator.getInstance();

        }

        if (Comparable.class.isAssignableFrom(columnClass)) {

            return COMPARABLE_COMPARATOR;

        }

        return Collator.getInstance();

    }

    /**

     * {@inheritDoc}

     *

     * @throws IndexOutOfBoundsException {@inheritDoc}

     */

    protected boolean useToString(int column) {

        Comparator<?> comparator = super.getComparator(column);

        if (comparator != null) {

            return false;

        }

        Class<?> columnClass = getModel().getColumnClass(column);

        if (columnClass == String.class) {

            return false;

        }

        if (Comparable.class.isAssignableFrom(columnClass)) {

            return false;

        }

        return true;

    }

    /**

     * Implementation of DefaultRowSorter.ModelWrapper that delegates to a

     * TableModel.

     */

    private class TableRowSorterModelWrapper extends ModelWrapper<M,Integer> {

        public M getModel() {

            return tableModel;

        }

        public int getColumnCount() {

            return (tableModel == null) ? 0 : tableModel.getColumnCount();

        }

        public int getRowCount() {

            return (tableModel == null) ? 0 : tableModel.getRowCount();

        }

        public Object getValueAt(int row, int column) {

            return tableModel.getValueAt(row, column);

        }

        public String getStringValueAt(int row, int column) {

            TableStringConverter converter = getStringConverter();

            if (converter != null) {

                // Use the converter

                String value = converter.toString(

                        tableModel, row, column);

                if (value != null) {

                    return value;

                }

                return "";

            }

            // No converter, use getValueAt followed by toString

            Object o = getValueAt(row, column);

            if (o == null) {

                return "";

            }

            String string = o.toString();

            if (string == null) {

                return "";

            }

            return string;

        }

        public Integer getIdentifier(int index) {

            return index;

        }

    }

    private static class ComparableComparator implements Comparator<Object> {

        @SuppressWarnings("unchecked")

        public int compare(Object o1, Object o2) {

            return ((Comparable)o1).compareTo(o2);

        }

    }

}