Question

I am trying to learn tapestry from tapestry tutorial, however
part of it is outdated.

Using GridDataSource code for it is:

package com.packtpub.celebrities.util;
import com.packtpub.celebrities.data.IDataSource;
import com.packtpub.celebrities.model.Celebrity;
import java.util.List;
import org.apache.tapestry.beaneditor.PropertyModel;
import org.apache.tapestry.grid.GridDataSource;

public class CelebritySource implements GridDataSource {
  private IDataSource dataSource;
  private List<Celebrity> selection;
  private int indexFrom;

  public CelebritySource(IDataSource ds) {
    this.dataSource = ds;
  }

  public int getAvailableRows() {
    return dataSource.getAllCelebrities().size();
  }

  public void prepare(int indexFrom, int indexTo, PropertyModel propertyModel, boolean ascending) {
    String propertyName = propertyModel == null ? null : propertyModel.getPropertyName();

    System.out.println("Preparing selection.");
    System.out.println("Index from " + indexFrom + " to " + indexTo);        
    System.out.println("Property name is: " + propertyName);
    System.out.println("Sorting order ascending: " + ascending);

    this.selection = dataSource.getRange(indexFrom, indexTo);
    this.indexFrom = indexFrom;
  }

  public Object getRowValue(int i) {
    System.out.println("Getting value for row " + i);
    return selection.get(i - this.indexFrom);
  }

  public Class getRowType() {
    return Celebrity.class;
  }
}

method implementation prepare has changed now it looks like

public void prepare(int startIndex, int endIndex, List<SortConstraint> sortConstraints) {}

one of the few examples on google.com showing new method implementation is:

public void prepare(int startIndex, int endIndex, List<SortConstraint> sortConstraints) {
  for (SortConstraint constraint : sortConstraints) {
    final ColumnSort sort = constraint.getColumnSort();

    if (sort == ColumnSort.UNSORTED) continue;

    final PropertyConduit conduit = constraint.getPropertyModel().getConduit();

    final Comparator valueComparator = new Comparator<Comparable>() {
      public int compare(Comparable o1, Comparable o2) {
        // Simplify comparison, and handle case where both are nulls.
        if (o1 == o2) return 0;
        if (o2 == null) return 1;
        if (o1 == null) return -1;
        return o1.compareTo(o2);
      }
    };

    final Comparator rowComparator = new Comparator() {
      public int compare(Object row1, Object row2) {
        Comparable value1 = (Comparable) conduit.get(row1);
        Comparable value2 = (Comparable) conduit.get(row2);
        return valueComparator.compare(value1, value2);
      }
    };

    final Comparator reverseComparator = new Comparator() {
      public int compare(Object o1, Object o2) {
        int modifier = sort == ColumnSort.ASCENDING ? 1 : -1;
        return modifier * rowComparator.compare(o1, o2);
      }
    };

    // We can freely sort this list because its just a copy.
    Collections.sort(_list, reverseComparator);
  }
}

Is there any way to create functionality of the old code work using prepare method as it is now?

public void prepare(int startIndex, int endIndex, List<SortConstraint> sortConstraints) {}

Also would appreciate any other solution to this problem.

Answer 1

It looks like the old prepare() method only let you sort on one criteria, whilst the new prepare() method lets you sort on many. (i.e. you can specify a secondary sort.)

The propertyModel and an ascending / descending enum are now held in the SortConstraint object, but looking at the code, none of that is used! So to just get the example working, try this:

public void prepare(int startIndex, int endIndex, List<SortConstraint> sortConstraints) {
  this.selection = dataSource.getRange(startIndex, endIndex);
  this.indexFrom = startIndex;
}

if you need the properyModel (for debugging) it should be accessible from:

PropertyModel propertyModel = sortConstraints.get(0).getPropertyModel();