< prev index next >
src/java.desktop/share/classes/javax/swing/DefaultRowSorter.java
Print this page
@@ -31,81 +31,81 @@
import java.util.Comparator;
import java.util.List;
import javax.swing.SortOrder;
/**
- * An implementation of <code>RowSorter</code> that provides sorting and
+ * An implementation of {@code RowSorter} that provides sorting and
* filtering around a grid-based data model.
- * Beyond creating and installing a <code>RowSorter</code>, you very rarely
+ * Beyond creating and installing a {@code RowSorter}, you very rarely
* need to interact with one directly. Refer to
* {@link javax.swing.table.TableRowSorter TableRowSorter} for a concrete
- * implementation of <code>RowSorter</code> for <code>JTable</code>.
+ * implementation of {@code RowSorter} for {@code JTable}.
* <p>
- * Sorting is done based on the current <code>SortKey</code>s, in order.
- * If two objects are equal (the <code>Comparator</code> for the
- * column returns 0) the next <code>SortKey</code> is used. If no
- * <code>SortKey</code>s remain or the order is <code>UNSORTED</code>, then
+ * Sorting is done based on the current {@code SortKey}s, in order.
+ * If two objects are equal (the {@code Comparator} for the
+ * column returns 0) the next {@code SortKey} is used. If no
+ * {@code SortKey}s remain or the order is {@code UNSORTED}, then
* the order of the rows in the model is used.
* <p>
- * Sorting of each column is done by way of a <code>Comparator</code>
- * that you can specify using the <code>setComparator</code> method.
- * If a <code>Comparator</code> has not been specified, the
- * <code>Comparator</code> returned by
- * <code>Collator.getInstance()</code> is used on the results of
- * calling <code>toString</code> on the underlying objects. The
- * <code>Comparator</code> is never passed <code>null</code>. A
- * <code>null</code> value is treated as occurring before a
- * non-<code>null</code> value, and two <code>null</code> values are
+ * Sorting of each column is done by way of a {@code Comparator}
+ * that you can specify using the {@code setComparator} method.
+ * If a {@code Comparator} has not been specified, the
+ * {@code Comparator} returned by
+ * {@code Collator.getInstance()} is used on the results of
+ * calling {@code toString} on the underlying objects. The
+ * {@code Comparator} is never passed {@code null}. A
+ * {@code null} value is treated as occurring before a
+ * non-{@code null} value, and two {@code null} values are
* considered equal.
* <p>
- * If you specify a <code>Comparator</code> that casts its argument to
+ * If you specify a {@code Comparator} that casts its argument to
* a type other than that provided by the model, a
- * <code>ClassCastException</code> will be thrown when the data is sorted.
+ * {@code ClassCastException} will be thrown when the data is sorted.
* <p>
- * In addition to sorting, <code>DefaultRowSorter</code> provides the
+ * In addition to sorting, {@code DefaultRowSorter} provides the
* ability to filter rows. Filtering is done by way of a
- * <code>RowFilter</code> that is specified using the
- * <code>setRowFilter</code> method. If no filter has been specified all
+ * {@code RowFilter} that is specified using the
+ * {@code setRowFilter} method. If no filter has been specified all
* rows are included.
* <p>
* By default, rows are in unsorted order (the same as the model) and
- * every column is sortable. The default <code>Comparator</code>s are
+ * every column is sortable. The default {@code Comparator}s are
* documented in the subclasses (for example, {@link
* javax.swing.table.TableRowSorter TableRowSorter}).
* <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
+ * {@code modelStructureChanged} method is invoked) the following
+ * are reset to their default values: {@code Comparator}s by
* column, current sort order, and whether each column is sortable. To
- * find the default <code>Comparator</code>s, see the concrete
+ * find the default {@code Comparator}s, see the concrete
* implementation (for example, {@link
* javax.swing.table.TableRowSorter TableRowSorter}). The default
* sort order is unsorted (the same as the model), and columns are
* sortable by default.
* <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,
+ * {@code modelStructureChanged} method is invoked) the following
+ * are reset to their default values: {@code Comparator}s by column,
* current sort order and whether a column is sortable.
* <p>
- * <code>DefaultRowSorter</code> is an abstract class. Concrete
+ * {@code DefaultRowSorter} is an abstract class. Concrete
* subclasses must provide access to the underlying data by invoking
* {@code setModelWrapper}. The {@code setModelWrapper} method
* <b>must</b> be invoked soon after the constructor is
* called, ideally from within the subclass's constructor.
* Undefined behavior will result if you use a {@code
* DefaultRowSorter} without specifying a {@code ModelWrapper}.
* <p>
- * <code>DefaultRowSorter</code> has two formal type parameters. The
+ * {@code DefaultRowSorter} has two formal type parameters. The
* first type parameter corresponds to the class of the model, for example
- * <code>DefaultTableModel</code>. The second type parameter
+ * {@code DefaultTableModel}. The second type parameter
* corresponds to the class of the identifier passed to the
- * <code>RowFilter</code>. Refer to <code>TableRowSorter</code> and
- * <code>RowFilter</code> for more details on the type parameters.
+ * {@code RowFilter}. Refer to {@code TableRowSorter} and
+ * {@code RowFilter} for more details on the type parameters.
*
* @param <M> the type of the model
- * @param <I> the type of the identifier passed to the <code>RowFilter</code>
+ * @param <I> the type of the identifier passed to the {@code RowFilter}
* @see javax.swing.table.TableRowSorter
* @see javax.swing.table.DefaultTableModel
* @see java.text.Collator
* @since 1.6
*/
@@ -188,11 +188,11 @@
*/
private int modelRowCount;
/**
- * Creates an empty <code>DefaultRowSorter</code>.
+ * Creates an empty {@code DefaultRowSorter}.
*/
public DefaultRowSorter() {
sortKeys = Collections.emptyList();
maxSortKeys = 3;
}
@@ -242,19 +242,19 @@
return getModelWrapper().getModel();
}
/**
* Sets whether or not the specified column is sortable. The specified
- * value is only checked when <code>toggleSortOrder</code> is invoked.
+ * value is only checked when {@code toggleSortOrder} is invoked.
* It is still possible to sort on a column that has been marked as
* unsortable by directly setting the sort keys. The default is
* true.
*
* @param column the column to enable or disable sorting on, in terms
* of the underlying model
* @param sortable whether or not the specified column is sortable
- * @throws IndexOutOfBoundsException if <code>column</code> is outside
+ * @throws IndexOutOfBoundsException if {@code column} is outside
* the range of the model
* @see #toggleSortOrder
* @see #setSortKeys
*/
public void setSortable(int column, boolean sortable) {
@@ -286,15 +286,15 @@
* Sets the sort keys. This creates a copy of the supplied
* {@code List}; subsequent changes to the supplied
* {@code List} do not effect this {@code DefaultRowSorter}.
* If the sort keys have changed this triggers a sort.
*
- * @param sortKeys the new <code>SortKeys</code>; <code>null</code>
+ * @param sortKeys the new {@code SortKeys}; {@code null}
* is a shorthand for specifying an empty list,
* indicating that the view should be unsorted
* @throws IllegalArgumentException if any of the values in
- * <code>sortKeys</code> are null or have a column index outside
+ * {@code sortKeys} are null or have a column index outside
* the range of the model
*/
public void setSortKeys(List<? extends SortKey> sortKeys) {
List<SortKey> old = this.sortKeys;
if (sortKeys != null && sortKeys.size() > 0) {
@@ -337,33 +337,33 @@
/**
* Sets the maximum number of sort keys. The number of sort keys
* determines how equal values are resolved when sorting. For
* example, assume a table row sorter is created and
- * <code>setMaxSortKeys(2)</code> is invoked on it. The user
+ * {@code setMaxSortKeys(2)} is invoked on it. The user
* clicks the header for column 1, causing the table rows to be
* sorted based on the items in column 1. Next, the user clicks
* the header for column 2, causing the table to be sorted based
* on the items in column 2; if any items in column 2 are equal,
* then those particular rows are ordered based on the items in
* column 1. In this case, we say that the rows are primarily
* sorted on column 2, and secondarily on column 1. If the user
* then clicks the header for column 3, then the items are
* primarily sorted on column 3 and secondarily sorted on column
* 2. Because the maximum number of sort keys has been set to 2
- * with <code>setMaxSortKeys</code>, column 1 no longer has an
+ * with {@code setMaxSortKeys}, column 1 no longer has an
* effect on the order.
* <p>
* The maximum number of sort keys is enforced by
- * <code>toggleSortOrder</code>. You can specify more sort
- * keys by invoking <code>setSortKeys</code> directly and they will
- * all be honored. However if <code>toggleSortOrder</code> is subsequently
+ * {@code toggleSortOrder}. You can specify more sort
+ * keys by invoking {@code setSortKeys} directly and they will
+ * all be honored. However if {@code toggleSortOrder} is subsequently
* invoked the maximum number of sort keys will be enforced.
* The default value is 3.
*
* @param max the maximum number of sort keys
- * @throws IllegalArgumentException if <code>max</code> < 1
+ * @throws IllegalArgumentException if {@code max < 1}
*/
public void setMaxSortKeys(int max) {
if (max < 1) {
throw new IllegalArgumentException("Invalid max");
}
@@ -379,11 +379,11 @@
return maxSortKeys;
}
/**
* If true, specifies that a sort should happen when the underlying
- * model is updated (<code>rowsUpdated</code> is invoked). For
+ * model is updated ({@code rowsUpdated} is invoked). For
* example, if this is true and the user edits an entry the
* location of that item in the view may change. The default is
* false.
*
* @param sortsOnUpdates whether or not to sort on update events
@@ -403,18 +403,18 @@
}
/**
* Sets the filter that determines which rows, if any, should be
* hidden from the view. The filter is applied before sorting. A value
- * of <code>null</code> indicates all values from the model should be
+ * of {@code null} indicates all values from the model should be
* included.
* <p>
- * <code>RowFilter</code>'s <code>include</code> method is passed an
- * <code>Entry</code> that wraps the underlying model. The number
- * of columns in the <code>Entry</code> corresponds to the
- * number of columns in the <code>ModelWrapper</code>. The identifier
- * comes from the <code>ModelWrapper</code> as well.
+ * {@code RowFilter}'s {@code include} method is passed an
+ * {@code Entry} that wraps the underlying model. The number
+ * of columns in the {@code Entry} corresponds to the
+ * number of columns in the {@code ModelWrapper}. The identifier
+ * comes from the {@code ModelWrapper} as well.
* <p>
* This method triggers a sort.
*
* @param filter the filter used to determine what entries should be
* included
@@ -559,11 +559,11 @@
}
/**
* Sorts and filters the rows in the view based on the sort keys
* of the columns currently being sorted and the filter, if any,
- * associated with this sorter. An empty <code>sortKeys</code> list
+ * associated with this sorter. An empty {@code sortKeys} list
* indicates that the view should unsorted, the same as the model.
*
* @see #setRowFilter
* @see #setSortKeys
*/
@@ -703,28 +703,28 @@
}
/**
* Returns whether or not to convert the value to a string before
* doing comparisons when sorting. If true
- * <code>ModelWrapper.getStringValueAt</code> will be used, otherwise
- * <code>ModelWrapper.getValueAt</code> will be used. It is up to
- * subclasses, such as <code>TableRowSorter</code>, to honor this value
- * in their <code>ModelWrapper</code> implementation.
+ * {@code ModelWrapper.getStringValueAt} will be used, otherwise
+ * {@code ModelWrapper.getValueAt} will be used. It is up to
+ * subclasses, such as {@code TableRowSorter}, to honor this value
+ * in their {@code ModelWrapper} implementation.
*
* @param column the index of the column to test, in terms of the
* underlying model
* @return true if values are to be converted to strings before doing
* comparisons when sorting
- * @throws IndexOutOfBoundsException if <code>column</code> is not valid
+ * @throws IndexOutOfBoundsException if {@code column} is not valid
*/
protected boolean useToString(int column) {
return (getComparator(column) == null);
}
/**
* Refreshes the modelToView mapping from that of viewToModel.
- * If <code>unsetFirst</code> is true, all indices in modelToView are
+ * If {@code unsetFirst} is true, all indices in modelToView are
* first set to -1.
*/
private void setModelToViewFromViewToModel(boolean unsetFirst) {
int i;
if (unsetFirst) {
@@ -747,18 +747,18 @@
}
return new int[0];
}
/**
- * Sets the <code>Comparator</code> to use when sorting the specified
+ * Sets the {@code Comparator} to use when sorting the specified
* column. This does not trigger a sort. If you want to sort after
- * setting the comparator you need to explicitly invoke <code>sort</code>.
+ * setting the comparator you need to explicitly invoke {@code sort}.
*
- * @param column the index of the column the <code>Comparator</code> is
+ * @param column the index of the column the {@code Comparator} is
* to be used for, in terms of the underlying model
- * @param comparator the <code>Comparator</code> to use
- * @throws IndexOutOfBoundsException if <code>column</code> is outside
+ * @param comparator the {@code Comparator} to use
+ * @throws IndexOutOfBoundsException if {@code column} is outside
* the range of the underlying model
*/
public void setComparator(int column, Comparator<?> comparator) {
checkColumn(column);
if (comparators == null) {
@@ -766,17 +766,17 @@
}
comparators[column] = comparator;
}
/**
- * Returns the <code>Comparator</code> for the specified
- * column. This will return <code>null</code> if a <code>Comparator</code>
+ * Returns the {@code Comparator} for the specified
+ * column. This will return {@code null} if a {@code Comparator}
* has not been specified for the column.
*
- * @param column the column to fetch the <code>Comparator</code> for, in
+ * @param column the column to fetch the {@code Comparator} for, in
* terms of the underlying model
- * @return the <code>Comparator</code> for the specified column
+ * @return the {@code Comparator} for the specified column
* @throws IndexOutOfBoundsException if column is outside
* the range of the underlying model
*/
public Comparator<?> getComparator(int column) {
checkColumn(column);
@@ -1014,11 +1014,11 @@
current.length - last);
}
/**
* Returns true if we should try and optimize the processing of the
- * <code>TableModelEvent</code>. If this returns false, assume the
+ * {@code TableModelEvent}. If this returns false, assume the
* event was dealt with and no further processing needs to happen.
*/
private boolean shouldOptimizeChange(int firstRow, int lastRow) {
if (!isTransformed()) {
// Not transformed, nothing to do.
@@ -1225,40 +1225,40 @@
}
}
/**
- * <code>DefaultRowSorter.ModelWrapper</code> is responsible for providing
- * the data that gets sorted by <code>DefaultRowSorter</code>. You
- * normally do not interact directly with <code>ModelWrapper</code>.
- * Subclasses of <code>DefaultRowSorter</code> provide an
- * implementation of <code>ModelWrapper</code> wrapping another model.
+ * {@code DefaultRowSorter.ModelWrapper} is responsible for providing
+ * the data that gets sorted by {@code DefaultRowSorter}. You
+ * normally do not interact directly with {@code ModelWrapper}.
+ * Subclasses of {@code DefaultRowSorter} provide an
+ * implementation of {@code ModelWrapper} wrapping another model.
* For example,
- * <code>TableRowSorter</code> provides a <code>ModelWrapper</code> that
- * wraps a <code>TableModel</code>.
+ * {@code TableRowSorter} provides a {@code ModelWrapper} that
+ * wraps a {@code TableModel}.
* <p>
- * <code>ModelWrapper</code> makes a distinction between values as
- * <code>Object</code>s and <code>String</code>s. This allows
+ * {@code ModelWrapper} makes a distinction between values as
+ * {@code Object}s and {@code String}s. This allows
* implementations to provide a custom string
- * converter to be used instead of invoking <code>toString</code> on the
+ * converter to be used instead of invoking {@code toString} on the
* object.
*
* @param <M> the type of the underlying model
* @param <I> the identifier supplied to the filter
* @since 1.6
* @see RowFilter
* @see RowFilter.Entry
*/
protected abstract static class ModelWrapper<M,I> {
/**
- * Creates a new <code>ModelWrapper</code>.
+ * Creates a new {@code ModelWrapper}.
*/
protected ModelWrapper() {
}
/**
- * Returns the underlying model that this <code>Model</code> is
+ * Returns the underlying model that this {@code Model} is
* wrapping.
*
* @return the underlying model
*/
public abstract M getModel();
@@ -1287,19 +1287,19 @@
* the range of the model
*/
public abstract Object getValueAt(int row, int column);
/**
- * Returns the value as a <code>String</code> at the specified
- * index. This implementation uses <code>toString</code> on
- * the result from <code>getValueAt</code> (making sure
+ * Returns the value as a {@code String} at the specified
+ * index. This implementation uses {@code toString} on
+ * the result from {@code getValueAt} (making sure
* to return an empty string for null values). Subclasses that
* override this method should never return null.
*
* @param row the row index
* @param column the column index
- * @return the value at the specified index as a <code>String</code>
+ * @return the value at the specified index as a {@code String}
* @throws IndexOutOfBoundsException if the indices are outside
* the range of the model
*/
public String getStringValueAt(int row, int column) {
Object o = getValueAt(row, column);
@@ -1314,12 +1314,12 @@
}
/**
* Returns the identifier for the specified row. The return value
* of this is used as the identifier for the
- * <code>RowFilter.Entry</code> that is passed to the
- * <code>RowFilter</code>.
+ * {@code RowFilter.Entry} that is passed to the
+ * {@code RowFilter}.
*
* @param row the row to return the identifier for, in terms of
* the underlying model
* @return the identifier
* @see RowFilter.Entry#getIdentifier
< prev index next >