< prev index next >
src/java.desktop/share/classes/javax/swing/RowFilter.java
Print this page
@@ -32,25 +32,25 @@
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
/**
- * <code>RowFilter</code> is used to filter out entries from the
+ * {@code RowFilter} is used to filter out entries from the
* model so that they are not shown in the view. For example, a
- * <code>RowFilter</code> associated with a <code>JTable</code> might
+ * {@code RowFilter} associated with a {@code JTable} might
* only allow rows that contain a column with a specific string. The
* meaning of <em>entry</em> depends on the component type.
* For example, when a filter is
- * associated with a <code>JTable</code>, an entry corresponds to a
- * row; when associated with a <code>JTree</code>, an entry corresponds
+ * associated with a {@code JTable}, an entry corresponds to a
+ * row; when associated with a {@code JTree}, an entry corresponds
* to a node.
* <p>
- * Subclasses must override the <code>include</code> method to
+ * Subclasses must override the {@code include} method to
* indicate whether the entry should be shown in the
- * view. The <code>Entry</code> argument can be used to obtain the values in
+ * view. The {@code Entry} argument can be used to obtain the values in
* each of the columns in that entry. The following example shows an
- * <code>include</code> method that allows only entries containing one or
+ * {@code include} method that allows only entries containing one or
* more values starting with the string "a":
* <pre>
* RowFilter<Object,Object> startsWithAFilter = new RowFilter<Object,Object>() {
* public boolean include(Entry<? extends Object, ? extends Object> entry) {
* for (int i = entry.getValueCount() - 1; i >= 0; i--) {
@@ -63,14 +63,14 @@
* // entry is not shown
* return false;
* }
* };
* </pre>
- * <code>RowFilter</code> has two formal type parameters that allow
- * you to create a <code>RowFilter</code> for a specific model. For
+ * {@code RowFilter} has two formal type parameters that allow
+ * you to create a {@code RowFilter} for a specific model. For
* example, the following assumes a specific model that is wrapping
- * objects of type <code>Person</code>. Only <code>Person</code>s
+ * objects of type {@code Person}. Only {@code Person}s
* with an age over 20 will be shown:
* <pre>
* RowFilter<PersonModel,Integer> ageFilter = new RowFilter<PersonModel,Integer>() {
* public boolean include(Entry<? extends PersonModel, ? extends Integer> entry) {
* PersonModel personModel = entry.getModel();
@@ -86,20 +86,20 @@
* PersonModel model = createPersonModel();
* TableRowSorter<PersonModel> sorter = new TableRowSorter<PersonModel>(model);
* sorter.setRowFilter(ageFilter);
* </pre>
*
- * @param <M> the type of the model; for example <code>PersonModel</code>
+ * @param <M> the type of the model; for example {@code PersonModel}
* @param <I> the type of the identifier; when using
- * <code>TableRowSorter</code> this will be <code>Integer</code>
+ * {@code TableRowSorter} this will be {@code Integer}
* @see javax.swing.table.TableRowSorter
* @since 1.6
*/
public abstract class RowFilter<M,I> {
/**
* Enumeration of the possible comparison values supported by
- * some of the default <code>RowFilter</code>s.
+ * some of the default {@code RowFilter}s.
*
* @see RowFilter
* @since 1.6
*/
public enum ComparisonType {
@@ -139,14 +139,14 @@
}
}
}
/**
- * Returns a <code>RowFilter</code> that uses a regular
+ * Returns a {@code RowFilter} that uses a regular
* expression to determine which entries to include. Only entries
* with at least one matching value are included. For
- * example, the following creates a <code>RowFilter</code> that
+ * example, the following creates a {@code RowFilter} that
* includes entries with at least one value starting with
* "a":
* <pre>
* RowFilter.regexFilter("^a");
* </pre>
@@ -162,28 +162,28 @@
* @param <M> the type of the model to which the {@code RowFilter} applies
* @param <I> the type of the identifier passed to the {@code RowFilter}
* @param regex the regular expression to filter on
* @param indices the indices of the values to check. If not supplied all
* values are evaluated
- * @return a <code>RowFilter</code> implementing the specified criteria
- * @throws NullPointerException if <code>regex</code> is
- * <code>null</code>
- * @throws IllegalArgumentException if any of the <code>indices</code>
+ * @return a {@code RowFilter} implementing the specified criteria
+ * @throws NullPointerException if {@code regex} is
+ * {@code null}
+ * @throws IllegalArgumentException if any of the {@code indices}
* are < 0
- * @throws PatternSyntaxException if <code>regex</code> is
+ * @throws PatternSyntaxException if {@code regex} is
* not a valid regular expression.
* @see java.util.regex.Pattern
*/
public static <M,I> RowFilter<M,I> regexFilter(String regex,
int... indices) {
return new RegexFilter<M, I>(Pattern.compile(regex), indices);
}
/**
- * Returns a <code>RowFilter</code> that includes entries that
- * have at least one <code>Date</code> value meeting the specified
- * criteria. For example, the following <code>RowFilter</code> includes
+ * Returns a {@code RowFilter} that includes entries that
+ * have at least one {@code Date} value meeting the specified
+ * criteria. For example, the following {@code RowFilter} includes
* only entries with at least one date value after the current date:
* <pre>
* RowFilter.dateFilter(ComparisonType.AFTER, new Date());
* </pre>
*
@@ -191,27 +191,27 @@
* @param <I> the type of the identifier passed to the {@code RowFilter}
* @param type the type of comparison to perform
* @param date the date to compare against
* @param indices the indices of the values to check. If not supplied all
* values are evaluated
- * @return a <code>RowFilter</code> implementing the specified criteria
- * @throws NullPointerException if <code>date</code> is
- * <code>null</code>
- * @throws IllegalArgumentException if any of the <code>indices</code>
- * are < 0 or <code>type</code> is
- * <code>null</code>
+ * @return a {@code RowFilter} implementing the specified criteria
+ * @throws NullPointerException if {@code date} is
+ * {@code null}
+ * @throws IllegalArgumentException if any of the {@code indices}
+ * are < 0 or {@code type} is
+ * {@code null}
* @see java.util.Calendar
* @see java.util.Date
*/
public static <M,I> RowFilter<M,I> dateFilter(ComparisonType type,
Date date, int... indices) {
return new DateFilter<M, I>(type, date.getTime(), indices);
}
/**
- * Returns a <code>RowFilter</code> that includes entries that
- * have at least one <code>Number</code> value meeting the
+ * Returns a {@code RowFilter} that includes entries that
+ * have at least one {@code Number} value meeting the
* specified criteria. For example, the following
* filter will only include entries with at
* least one number value equal to 10:
* <pre>
* RowFilter.numberFilter(ComparisonType.EQUAL, 10);
@@ -221,25 +221,25 @@
* @param <I> the type of the identifier passed to the {@code RowFilter}
* @param type the type of comparison to perform
* @param number a {@code Number} value to compare against
* @param indices the indices of the values to check. If not supplied all
* values are evaluated
- * @return a <code>RowFilter</code> implementing the specified criteria
- * @throws IllegalArgumentException if any of the <code>indices</code>
- * are < 0, <code>type</code> is <code>null</code>
- * or <code>number</code> is <code>null</code>
+ * @return a {@code RowFilter} implementing the specified criteria
+ * @throws IllegalArgumentException if any of the {@code indices}
+ * are < 0, {@code type} is {@code null}
+ * or {@code number} is {@code null}
*/
public static <M,I> RowFilter<M,I> numberFilter(ComparisonType type,
Number number, int... indices) {
return new NumberFilter<M, I>(type, number, indices);
}
/**
- * Returns a <code>RowFilter</code> that includes entries if any
+ * Returns a {@code RowFilter} that includes entries if any
* of the supplied filters includes the entry.
* <p>
- * The following example creates a <code>RowFilter</code> that will
+ * The following example creates a {@code RowFilter} that will
* include any entries containing the string "foo" or the string
* "bar":
* <pre>
* List<RowFilter<Object,Object>> filters = new ArrayList<RowFilter<Object,Object>>(2);
* filters.add(RowFilter.regexFilter("foo"));
@@ -247,27 +247,27 @@
* RowFilter<Object,Object> fooBarFilter = RowFilter.orFilter(filters);
* </pre>
*
* @param <M> the type of the model to which the {@code RowFilter} applies
* @param <I> the type of the identifier passed to the {@code RowFilter}
- * @param filters the <code>RowFilter</code>s to test
+ * @param filters the {@code RowFilter}s to test
* @throws IllegalArgumentException if any of the filters
- * are <code>null</code>
- * @throws NullPointerException if <code>filters</code> is null
- * @return a <code>RowFilter</code> implementing the specified criteria
+ * are {@code null}
+ * @throws NullPointerException if {@code filters} is null
+ * @return a {@code RowFilter} implementing the specified criteria
* @see java.util.Arrays#asList
*/
public static <M,I> RowFilter<M,I> orFilter(
Iterable<? extends RowFilter<? super M, ? super I>> filters) {
return new OrFilter<M,I>(filters);
}
/**
- * Returns a <code>RowFilter</code> that includes entries if all
+ * Returns a {@code RowFilter} that includes entries if all
* of the supplied filters include the entry.
* <p>
- * The following example creates a <code>RowFilter</code> that will
+ * The following example creates a {@code RowFilter} that will
* include any entries containing the string "foo" and the string
* "bar":
* <pre>
* List<RowFilter<Object,Object>> filters = new ArrayList<RowFilter<Object,Object>>(2);
* filters.add(RowFilter.regexFilter("foo"));
@@ -275,46 +275,46 @@
* RowFilter<Object,Object> fooBarFilter = RowFilter.andFilter(filters);
* </pre>
*
* @param <M> the type of the model the {@code RowFilter} applies to
* @param <I> the type of the identifier passed to the {@code RowFilter}
- * @param filters the <code>RowFilter</code>s to test
- * @return a <code>RowFilter</code> implementing the specified criteria
+ * @param filters the {@code RowFilter}s to test
+ * @return a {@code RowFilter} implementing the specified criteria
* @throws IllegalArgumentException if any of the filters
- * are <code>null</code>
- * @throws NullPointerException if <code>filters</code> is null
+ * are {@code null}
+ * @throws NullPointerException if {@code filters} is null
* @see java.util.Arrays#asList
*/
public static <M,I> RowFilter<M,I> andFilter(
Iterable<? extends RowFilter<? super M, ? super I>> filters) {
return new AndFilter<M,I>(filters);
}
/**
- * Returns a <code>RowFilter</code> that includes entries if the
+ * Returns a {@code RowFilter} that includes entries if the
* supplied filter does not include the entry.
*
* @param <M> the type of the model to which the {@code RowFilter} applies
* @param <I> the type of the identifier passed to the {@code RowFilter}
- * @param filter the <code>RowFilter</code> to negate
- * @return a <code>RowFilter</code> implementing the specified criteria
- * @throws IllegalArgumentException if <code>filter</code> is
- * <code>null</code>
+ * @param filter the {@code RowFilter} to negate
+ * @return a {@code RowFilter} implementing the specified criteria
+ * @throws IllegalArgumentException if {@code filter} is
+ * {@code null}
*/
public static <M,I> RowFilter<M,I> notFilter(RowFilter<M,I> filter) {
return new NotFilter<M,I>(filter);
}
/**
* Returns true if the specified entry should be shown;
* returns false if the entry should be hidden.
* <p>
- * The <code>entry</code> argument is valid only for the duration of
- * the invocation. Using <code>entry</code> after the call returns
+ * The {@code entry} argument is valid only for the duration of
+ * the invocation. Using {@code entry} after the call returns
* results in undefined behavior.
*
- * @param entry a non-<code>null</code> object that wraps the underlying
+ * @param entry a non-{@code null} object that wraps the underlying
* object from the model
* @return true if the entry should be shown
*/
public abstract boolean include(Entry<? extends M, ? extends I> entry);
@@ -325,26 +325,26 @@
// to do so it would be possible to get a ClassCastException during normal
// usage.
//
/**
- * An <code>Entry</code> object is passed to instances of
- * <code>RowFilter</code>, allowing the filter to get the value of the
+ * An {@code Entry} object is passed to instances of
+ * {@code RowFilter}, allowing the filter to get the value of the
* entry's data, and thus to determine whether the entry should be shown.
- * An <code>Entry</code> object contains information about the model
+ * An {@code Entry} object contains information about the model
* as well as methods for getting the underlying values from the model.
*
- * @param <M> the type of the model; for example <code>PersonModel</code>
+ * @param <M> the type of the model; for example {@code PersonModel}
* @param <I> the type of the identifier; when using
- * <code>TableRowSorter</code> this will be <code>Integer</code>
+ * {@code TableRowSorter} this will be {@code Integer}
* @see javax.swing.RowFilter
* @see javax.swing.DefaultRowSorter#setRowFilter(javax.swing.RowFilter)
* @since 1.6
*/
public abstract static class Entry<M, I> {
/**
- * Creates an <code>Entry</code>.
+ * Creates an {@code Entry}.
*/
public Entry() {
}
/**
@@ -363,11 +363,11 @@
*/
public abstract int getValueCount();
/**
* Returns the value at the specified index. This may return
- * <code>null</code>. When used with a table, index
+ * {@code null}. When used with a table, index
* corresponds to the column number in the model.
*
* @param index the index of the value to get
* @return value at the specified index
* @throws IndexOutOfBoundsException if index < 0 or
@@ -375,17 +375,17 @@
*/
public abstract Object getValue(int index);
/**
* Returns the string value at the specified index. If
- * filtering is being done based on <code>String</code> values
- * this method is preferred to that of <code>getValue</code>
- * as <code>getValue(index).toString()</code> may return a
- * different result than <code>getStringValue(index)</code>.
+ * filtering is being done based on {@code String} values
+ * this method is preferred to that of {@code getValue}
+ * as {@code getValue(index).toString()} may return a
+ * different result than {@code getStringValue(index)}.
* <p>
- * This implementation calls <code>getValue(index).toString()</code>
- * after checking for <code>null</code>. Subclasses that provide
+ * This implementation calls {@code getValue(index).toString()}
+ * after checking for {@code null}. Subclasses that provide
* different string conversion should override this method if
* necessary.
*
* @param index the index of the value to get
* @return {@code non-null} string at the specified index
@@ -398,11 +398,11 @@
}
/**
* Returns the identifer (in the model) of the entry.
* For a table this corresponds to the index of the row in the model,
- * expressed as an <code>Integer</code>.
+ * expressed as an {@code Integer}.
*
* @return a model-based (not view-based) identifier for
* this entry
*/
public abstract I getIdentifier();
< prev index next >