A sortable data provider for memory-stored beans for Wicket.

NullChainSensitiveBeanComparator.java

import org.apache.commons.beanutils.BeanComparator;
import org.apache.wicket.util.lang.PropertyResolver;

import java.util.Comparator;

public class NullChainSensitiveBeanComparator extends BeanComparator {

	public NullChainSensitiveBeanComparator() {
	}

	public NullChainSensitiveBeanComparator(String property) {
		super(property);
	}

	public NullChainSensitiveBeanComparator(String property, Comparator comparator) {
		super(property, comparator);
	}

	@SuppressWarnings("unchecked")
	@Override
	public int compare(Object o1, Object o2) {

		String property = getProperty();
		Comparator comparator = getComparator();

		if (property == null) {
			return comparator.compare(o1, o2);
		}

		Object value1 = PropertyResolver.getValue(property, o1);
		Object value2 = PropertyResolver.getValue(property, o2);

		Number numValue1 = tryNumber(value1), numValue2 = tryNumber(value2);

		if (numValue1 != null && numValue2 != null) {
			return comparator.compare(numValue1, numValue2);
		} else {
			return comparator.compare(value1, value2);
		}
	}

	private Number tryNumber(Object value) {
		try {
			return Double.valueOf(value.toString().trim());
		} catch (Exception e) {
			return null;
		}
	}

}

SortableNullableListDataProvider.java

import org.apache.commons.collections.comparators.NullComparator;
import org.apache.wicket.extensions.markup.html.repeater.util.SortableDataProvider;
import org.apache.wicket.model.IModel;
import org.apache.wicket.model.Model;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class SortableNullableListDataProvider<T extends Serializable> extends SortableDataProvider<T> {

	private final IModel<? extends List<? extends T>> underlyingListModel;

	public SortableNullableListDataProvider(IModel<? extends List<? extends T>> underlyingModel) {
		this.underlyingListModel = underlyingModel;
	}

	@Override
	public Iterator<? extends T> iterator(int first, int count) {
		if (getModelObject() == null) {
			return Collections.<T>emptyList().iterator();
		}
		return makeSortedList().subList((int) first, (int) (first + count)).iterator();
	}

	@Override
	public int size() {
		if (getModelObject() == null) {
			return 0;
		} else {
			return getModelObject().size();
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public IModel<T> model(T object) {
		return new Model(object);
	}

	@SuppressWarnings("unchecked")
	protected List<? extends T> makeSortedList() {

		if (getSort() == null || getSort().getProperty() == null) {
			return getModelObject();
		}

		Comparator comparator = getComparator();
		if (!getSort().isAscending()) {
			comparator = Collections.reverseOrder(comparator);
		}
		List<T> sortedList = new ArrayList(getModelObject());
		Collections.sort(sortedList, comparator);
		return sortedList;
	}

	protected final IModel<? extends List<? extends T>> getUnderlyingModel() {
		return underlyingListModel;
	}

	/**
	 * Override this method in order to apply any custom filtering on the list represented by this
	 * data provider.
	 *
	 * @return The object to be used for the list output.
	 */
	protected List<? extends T> getModelObject() {
		return getUnderlyingModel().getObject();
	}

	protected Comparator<?> getComparator() {
		return new NullChainSensitiveBeanComparator(
				getSort().getProperty(),
				new NullComparator(false));
	}

}