ADF table: case-insensitive sorting

Question

I have an <af:table> that uses a SortableModel as it's data source. I have sorting enabled on the table, but it's sorted according to case sensitivity.
My data source has mixed case, and I'd like to be able to sort regardless of case. Is there anyway to change the behavior so it does a case-insensitive sort instead?
Thanks

Answer 1

In case anyone else is looking for this, I went ahead and wrote an extension of CollectionModel that performs a case insensitive sort on String objects. I'm posting it here in the hopes it will help others in the same jam I was. It would really have been helpful if Oracle had made the source code to SortableModel available. I hope I did things properly with the rowKey stuff since there are no examples to work from.
Anyway, here it is:
package com.fhm.mwb.ui.model;
import oracle.adf.view.faces.model.CollectionModel;
import oracle.adf.view.faces.model.SortCriterion;
import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.commons.collections.comparators.ComparatorChain;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.faces.FacesException;
import javax.faces.model.DataModelEvent;
import javax.faces.model.DataModelListener;
* This class provides a sortable data model that uses case insensitive sort order when processing
* String objects.  All other objects in the data must implement Comparable and are sorted using
* Comparable.compare().
public class CaseInsensitiveSortableModel extends CollectionModel {
    private static BasicComparator _comparator = new BasicComparator();
     * Default constructor.
    public CaseInsensitiveSortableModel() {
     * Construct on top of a list of data.
     * @param list List of data to wrap in the model
    public CaseInsensitiveSortableModel(List list) {
        setWrappedData(list);
     * Set the sort criteria for this model
     * @param criteria List of SortCriterion objects
    public void setSortCriteria(List criteria) {
        _sortCriteria = criteria;
        if((criteria != null) && (criteria.size() > 0)) {
            // Sort our model data using this new criteria
            ComparatorChain chain = new ComparatorChain();
            for(int i = 0; i < criteria.size(); i++) {
                SortCriterion crit = (SortCriterion) criteria.get(i);
                chain.addComparator(new BeanComparator(crit.getProperty(), _comparator),
                    !crit.isAscending());
            List list = (List) getWrappedData();
            Collections.sort(list, chain);
            setWrappedData(list);
        } else {
            // Clear out our sort order
            _sortCriteria = new ArrayList();
     * Get the current sort criteria.
     * @return List of sort criteria
    public List getSortCriteria() {
        return _sortCriteria;
     * Determine if a given column is sortable.
     * @param column Name of the column to test
     * @return boolean true if the column is sortable
    public boolean isSortable(String column) {
        return true;    // Everything is sortable for now
     * Sets up a value at a particular rowKey to be the current value. The current value
     * is returned by calling {@link #getRowData}.
     * @param rowKey the rowKey of the value to make current. Use null to clear the current value.
    public void setRowKey(String rowKey) {
        if(rowKey == null) {
            setRowIndex(-1);
        } else {
            setRowIndex(Integer.valueOf(rowKey).intValue());
     * Gets the rowKey of the current value. The current value is returned by
     * calling {@link #getRowData}.
     * @return the rowKey of the current value, or null if there is no current value
    public String getRowKey() {
        return isRowAvailable() ? String.valueOf(_rowIndex) : null;
     * Set the list data we are wrapping
     * @throws ClassCastException if data is
     *  non-null and is not a List
    public void setWrappedData(Object data) {
        _wrappedList = (List) data;
        if(_wrappedList == null) {
            setRowIndex(-1);
     * Return the object representing the data wrapped by this model, if any.
    public Object getWrappedData() {
        return _wrappedList;
     * Return true if there is wrappedData
     * available, and the current value of rowIndex is greater
     * than or equal to zero, and less than the size of the list.  Otherwise,
     * return false.
     * @exception FacesException if an error occurs getting the row availability
    public boolean isRowAvailable() {
        return ((_rowIndex < 0) || (_rowIndex > getRowCount())) ? false : true;
     * If there is wrappedData available, return the
     * length of the list.  If no wrappedData is available,
     * return -1.
     * @exception FacesException if an error occurs getting the row count
    public int getRowCount() {
        return (_wrappedList == null) ? (-1) : _wrappedList.size();
     * If row data is available, return the list element at the index
     * specified by rowIndex.  If no wrapped data is available,
     * return null.
     * @exception IllegalArgumentException if now row data is available
     *  at the currently specified row index
    public Object getRowData() {
        if(_wrappedList == null) {
            return null;
        } else if(!isRowAvailable()) {
            throw new IllegalArgumentException("No row data available");
        } else {
            return wrappedList.get(rowIndex);
     * Return the zero-relative index of the currently selected row.  If
     * we are not currently positioned on a row, or no wrappedData
     * is available, return -1.
     * @exception FacesException if an error occurs getting the row index
    public int getRowIndex() {
        return _rowIndex;
     * Set the zero-relative index of the currently selected row, or -1
     * to indicate that we are not positioned on a row.  It is
     * possible to set the row index at a value for which the underlying data
     * collection does not contain any row data.  Therefore, callers may
     * use the isRowAvailable() method to detect whether row data
     * will be available for use by the getRowData() method.
     * If there is no wrappedData available when this method
     * is called, the specified rowIndex is stored (and may be
     * retrieved by a subsequent call to getRowData()), but no
     * event is sent.  Otherwise, if the currently selected row index is
     * changed by this call, a {@link DataModelEvent} will be sent to the
     * rowSelected() method of all registered
     * {@link DataModelListener}s.
     * @param rowIndex The new zero-relative index (must be non-negative)
     * @exception FacesException if an error occurs setting the row index
     * @exception IllegalArgumentException if rowIndex
     *  is less than -1
    public void setRowIndex(int rowIndex) {
        if(rowIndex < -1) {
            throw new IllegalArgumentException("Row index must be >= 0");
        int old = _rowIndex;
        _rowIndex = rowIndex;
        if(_wrappedList == null) {
            return;
        DataModelListener[] listeners = getDataModelListeners();
        if((old != _rowIndex) && (listeners != null)) {
            Object rowData = null;
            if(isRowAvailable()) {
                rowData = getRowData();
            DataModelEvent event = new DataModelEvent(this, _rowIndex, rowData);
            int n = listeners.length;
            for(int j = 0; j < n; j++) {
                if(null != listeners[j]) {
                    listeners[j].rowSelected(event);
    private List _wrappedList = new ArrayList();
    private List _sortCriteria = new ArrayList();
    private int _rowIndex = -1;
     * Internal class to provide a general Comparator that treats Strings in a case
     * insensitive manner.  All other types are assumed to be instances of Comparable
     * and handled as such.
    private static class BasicComparator implements Comparator, Serializable {
        private static final Comparator INSENSITIVE_COMPARATOR = String.CASE_INSENSITIVE_ORDER;
        private static final Comparator NORMAL_COMPARATOR = ComparableComparator.getInstance();
        public BasicComparator() {
        public int compare(Object o1, Object o2) {
            if(o1 instanceof String && o2 instanceof String) {
                return INSENSITIVE_COMPARATOR.compare(o1, o2);
            } else {
                return NORMAL_COMPARATOR.compare(o1, o2);
}