[
https://issues.apache.org/jira/browse/TOMAHAWK-952?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#action_12485561
]
Zdenek Sochor commented on TOMAHAWK-952:
----------------------------------------
Hi,
do u really have to set sort order in JSF (if only read-only)?
I think it's way too slower to do sorting in dataTable's internal
model than using custom comparator on collection in backing bean.
We're using Collections.sort(List, Comparator) method in bean to
achieve sorted data in table.
Regards,
Zdenek
> Provide cleaner, consistent sorting for dataTable and selectItems
> -----------------------------------------------------------------
>
> Key: TOMAHAWK-952
> URL:
https://issues.apache.org/jira/browse/TOMAHAWK-952
> Project: MyFaces Tomahawk
> Issue Type: New Feature
> Components: Extended Datatable, Extended SelectItems, New
Component
> Affects Versions: 1.1.6-SNAPSHOT
> Reporter: Mike Kienenberger
> Assigned To: Mike Kienenberger
> Priority: Minor
>
> My requirements in most cases are to specify a sort order in the
page code, not to allow end-users to manipulate the sort
> order. From what I can tell, there's no easy way to do this. I
documented the most effective method I could find on the wiki under a
"static sorting" subheading, but even that method leaves unnecessary
links in the column headers.
> At the same time, I looked into what it would take to make sorting
cleaner and more user-friendly.
> I came up with a subclass of extended dataTable and a replacement
SortableModel that did what I wanted for the most part:
> <my:sortableDataTable
> preserveDataModel="true"
> value="#{bean.carList}"
> var="car"
> >
> <f:facet name="comparator">
> <my:propertyComparator
> property="style.color"
> descending="true" />
> </f:facet>
> </my:sortableDataTable>
> This is based in part on reusing my components for sorting
selectItem lists. For some reason, couldn't make this work without
using preserveDataModel. [Strangely enough, doing the same thing
with the current t:dataTable sort attributes didn't require
preserveDataModel.]
> In any case, a comparator component can be any UIComponent that
implements a ComparatorSource interface (ie, public Comparator
getComparator()), which provides a great deal of flexibility.
> The propertyComparator implementation basically does the same thing
as the internal guts of the current SortableModel, but is pluggable.
I used beanutils in my comparator rather than EL to process the
property expression, which also eliminates the "rowObjectGet" hack.
An "EL comparator" could be implemented if the EL processing features
were needed.
> I think it would be worthwhile to replace the current SortableModel
with a more generic pluggable one. A good start would be to pull
all of the property-resolving/comparison out of it, and stick it into
a comparator like I did. setSortCriteria(List criteria) appears to
be misnomer since only the first item in the list is used -- using a
comparator would also solve that issue as you can create
MultipleComparator that takes a list of other comparators and goes
through them in order.
> Following is what DataTable looks like to make this work. Note
that this doesn't handle the current sorting options.
> protected DataModel createDataModel()
> {
> DataModel dataModel = super.createDataModel();
> UIComponent comparatorUIComponent = getComparator();
> Comparator comparator = null;
> if (null != comparatorUIComponent)
> {
> if (comparatorUIComponent instanceof ComparatorSource)
> {
> comparator =
> ((ComparatorSource)comparatorUIComponent).getComparator();
> }
> else
> {
> // TODO: need log error instead
> throw new
RuntimeException("comparatorUIComponent should
> implement ComparatorSource");
> }
> }
> boolean isSortable = null != comparator;
> if (isSortable)
> {
> if (!(dataModel instanceof BaseSortableModel))
> {
> dataModel = new BaseSortableModel(dataModel);
> }
> ((BaseSortableModel)dataModel).setComparator(comparator);
> }
> return dataModel;
> }
> After stripping out the comparator stuff from SortableModel, these
are the major changes:
> public void setComparator(Comparator _comparator) {
> this._comparator = _comparator;
> _sort();
> }
> private void _sort()
> {
> if (null == _comparator)
> {
> // restore unsorted order:
> _baseIndicesList = _sortedIndicesList = null;
> return;
> }
> //TODO: support -1 for rowCount:
> int sz = getRowCount();
> if ((_baseIndicesList == null) || (_baseIndicesList.size()
!= sz))
> {
> // we do not want to mutate the original data.
> // however, instead of copying the data and sorting the
copy,
> // we will create a list of indices into the original
data, and
> // sort the indices. This way, when certain rows are
made current
> // in this Collection, we can make them current in the
underlying
> // DataModel as well.
> _baseIndicesList = new IntList(sz);
> }
> final int rowIndex = _model.getRowIndex();
> _model.setRowIndex(0);
> // Make sure the model has that row 0! (It could be empty.)
> if (_model.isRowAvailable())
> {
> Collections.sort(_baseIndicesList, new
> RowDataComparator(_comparator, _model));
> _sortedIndicesList = null;
> }
> _model.setRowIndex(rowIndex);
> }
> protected class RowDataComparator implements Comparator
> {
> private Comparator dataComparator = null;
> private DataModel dataModel = null;
> public RowDataComparator(Comparator comparator,
DataModel model)
> {
> this.dataComparator = comparator;
> this.dataModel = model;
> }
> public int compare(Object arg1, Object arg2) {
> Integer r1 = (Integer)arg1;
> Integer r2 = (Integer)arg2;
> dataModel.setRowIndex(r1.intValue());
> Object rowData1 = _model.getRowData();
> dataModel.setRowIndex(r2.intValue());
> Object rowData2 = _model.getRowData();
> return dataComparator.compare(rowData1, rowData2);
> }
> }
> Also, here's how I'd like to improve t:selectItems. I've had a
custom subclass of f:selectItems of this working for awhile. Notice
how we can reuse the same propertyComparator component. This
particular implementation can take a list of comparator children and
implicitly wraps them in a MultipleComparator. That's not really
possible with a dataTable facet, so we'd want to provide a
MultipleComparator component.
> <my:orderedSelectItems value="#{bean.carList}">
> <my:propertyComparator
> property="style.color"
> descending="false" />
> </my:orderedSelectItems>
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
