Customizing column sorting in new jsf table

Question

The new JSF table in the creator 2 is great. I like it. It includes so many out of the box features. It is the reason we use the creator for our current project.
But I cannot figure out how to customize the column sorting.
Why do I need column sorting?
I need to sort a column that can include ad IP address or a host name. Our customer can either use a host name or an IP address to address a device in the network, both in the same column.
Now sorting an IP address is already difficult. It is actually a sort over a 4 byte number. Sorting over host names is normal alphabetic string sorting.
How to sort over both in the same column?
This cannot be done using standard sorting. I need to use a validator or something similar to customize the sorting of this column.
Can anybody help me with a hint if:
1- Customizing sorting over a column is possible. (I really would like to keep all other sorting features (icons, multi column support...)).
2- A hint or code sample, how to do this.
If this is not possible, I urge the creator team to think of implementing this soon. Otherwise one killer feature of the creator 2 will lose a lot of its teeth.

Answer 1

Thx mayagiri for your reply!
But including the src-code for the dataprovider package into a test project, and debugging in the creator-ide has done the thing!
Here our solution:
Class ToCompare is the object type which address field displayed in a page, simply containing a table with 2 adress colums, that can be sorted either according to our ip/hostname-comparison or according to String.compare().
* ToCompare.java
* Created on 10. Februar 2006, 10:41
* This class is a basic model object,
* with a field - String address - according
* to which it shall be sortable.
package comparator;
* @author mock
public class ToCompare {
     * holds the IP or Host address
    private String address=null;
     * Instance of a Comparator class that
     * provides our sorting algorithm
    private RcHostComparator hostComparator=null;
    /** Creates a new instance of ToCompare */   
    public ToCompare() {
        this("defaultHost");       
     * when creating a new ToCompare instance,
     * the hostComparator is created for it
     *  @ param aAddress - IP or Hostname
    public ToCompare(String aAddress) {
        address=aAddress;
        hostComparator=new RcHostComparator(address);
    public String getAddress() {
        return address;
    public RcHostComparator getHostComparator() {
        return hostComparator;
}Here the code of the Class RcHostComparator, it is created with the address field of the ToCompare object that it holds. It first checks if the address field is an IP or not, and then chooses the comparison algorithm according to its own field state and the field state of the object to compare to:
* RcHostComparator.java
* Created on 10. Februar 2006, 10:43
*  This class is used to provide a method for
*  comparing objects that have an address field,
*  containing either IP adresses or hostnames.
package comparator;
import java.text.CollationKey;
import java.text.Collator;
import java.util.Comparator;
import java.util.Locale;
* @author mock
public class RcHostComparator implements Comparator
     * holds the IP or Host address
    private String address=null;
     * Is the address an IP
    private boolean isIPAddress=false;
     * if (!isIPAddress) this is created out of the address
     * to provide a performant way of comparing it with another
     * CollationKey, in order to sort Strings localized
     *  @ see java.text.Collator
     *  @ see java.text.CollationKey
    private CollationKey hostnameCollationKey=null;
     * if (isIPAddress) this array holds
     * the 4 byte of the Ip address to compare
    private int[] intValues=null;
     * minimum for IP bytes/ints
    private static final int minIntValue=0;
     * maximum for IP bytes/ints
    private static final int maxIntValue=255;
     * Creates a new instance of IpComparator
     *  @ param aAddress  - holds the IP or Host address
    public RcHostComparator(String aAddress) {
        address=aAddress;
         * check if address is an IP
        isIPAddress=checkIP();
         * if Hostname -> instantiate localized CollationKeys
        if(!isIPAddress){
             Collator _localeCollator=Collator.getInstance(Locale.getDefault());
             hostnameCollationKey=_localeCollator.getCollationKey(address);
        }else{}
     *  Here the comparison of the address fields is done.
     *  There a 4 cases:
     *  -1 both Hostnames
     *  -2 aObject1 IP, aObject2 Hostname
     *  -3 aObject1 Hostname, aObject2 IP
     *  -4 both IPs
     *  @ param aObject1, aObject2 - Comparator objects
    public int compare(Object aObject1, Object aObject2)
      int _result= 0;
      if(aObject1 instanceof RcHostComparator && aObject2 instanceof RcHostComparator )
           RcHostComparator _ipComparator1=(RcHostComparator)aObject1;
           RcHostComparator _ipComparator2=(RcHostComparator)aObject2;
           *  Compare algorithms, according to address types
           if(!_ipComparator1.isIPAddress()&&!_ipComparator2.isIPAddress()){
                   *  If both addresses are Strings use collationKey.compareTo(Object o)
                _result=_ipComparator1.getHostnameCollationKey().compareTo(_ipComparator2.getHostnameCollationKey());
           }else{
                   *  IPs are smaller than Strings -> aObject1 < aObject2
                if(_ipComparator1.isIPAddress()&&!_ipComparator2.isIPAddress()){
                     _result=-1;
                }else{
                            *  IPs are smaller than Strings -> aObject1 > aObject2
                     if(!_ipComparator1.isIPAddress()){
                          _result=1;
                     }else{
                         int _intIndex=0;
                         int[] _int1=_ipComparator1.getIntValues();
                         int[] _int2=_ipComparator2.getIntValues();
                                  * compare IP adresses per bytes
                         while(_result==0 && _intIndex<4){
                              if(_int1[_intIndex]>_int2[_intIndex]){
                                   _result=1;
                              }else if(_int1[_intIndex]<_int2[_intIndex]){
                                   _result=-1;
                              }else{}                            
                                         _intIndex++;
      }else{}   
      return _result;
     *  checks if the address field holds an IP or a hostname
     *  if (_isIP) fill intValues[] with IP bytes
     *  if (!isIP)  create hostnameCollationKey
    private boolean checkIP(){
       boolean _isIP=false;
       String[] _getInts=null;
        *  basic check for IP address pattern
        *  4 digits also allowed, cause leading
        *  0 stands for octet number ->
        *  0172=122                  ->
        *  0172.0172.0172.0172 = 122.122.122.122
       boolean _firstcheck=address.matches("[0-9]{1,4}\\.[0-9]{1,4}\\.[0-9]{1,4}\\.[0-9]{1,4}");
       if(_firstcheck){
            _getInts=address.split("\\.");           
            intValues=new int[4];
            for (int _count=0; _count<4; _count++){
               try{                     
                   int _toIntValue;
                   if(_getInts[_count].startsWith("0")){
                            // if leading 0 parse as octet -> radix=8
                           _toIntValue=Integer.parseInt(_getInts[_count], 8);                          
                   }else{  
                            // parse as is -> radix=10 -> (optional)
                           _toIntValue=Integer.parseInt(_getInts[_count]);                          
                   if(_toIntValue<minIntValue||_toIntValue>maxIntValue){
                          // out of unsigned byte range -> no IP
                          return _isIP;
                   }else{
                          // inside byte range -> could be part of an IP
                          intValues[_count]=_toIntValue;
               }catch(NumberFormatException e){
                       // not parseable -> no IP
                       return _isIP;
           // all 4 bytes/ints are parseable and in unsigned byte range -> this is an IP
            _isIP=true;
       }else{}      
       return _isIP;
    public boolean isIPAddress() {
            return isIPAddress;
    public int[] getIntValues() {
            return intValues;
    public CollationKey getHostnameCollationKey() {
            return hostnameCollationKey;
    public String getAddress()
        return address;
}The page bean holds an array of ToCompare objects. It is the model for a new table component, hold by an ObjectArrayDataProvider. Here a code excerpt:
public class Page1 extends AbstractPageBean
    private ToCompare[] toCompare= new ToCompare[]{
        new ToCompare("1.1.1.1"),
        new ToCompare("2.1.1.1"),
        new ToCompare("9.1.1.1"),
        new ToCompare("11.1.1.1"),
        new ToCompare("0172.0172.0172.0172"),
        new ToCompare("123.1.1.1"),
        new ToCompare("a"),
        new ToCompare("o"),
        new ToCompare("u"),
        new ToCompare("z"),
        new ToCompare("�"),      
        new ToCompare("�"),
        new ToCompare("�")        
     * This method is automatically generated, so any user-specified code inserted
     * here is subject to being replaced
    private void _init() throws Exception
        objectArrayDataProvider1.setArray(toCompare);
    private TableRowGroup tableRowGroup1 = new TableRowGroup();   
    private ObjectArrayDataProvider objectArrayDataProvider1 = new ObjectArrayDataProvider();
}The relevant .jsp section for the two column table looks like:
<ui:tableRowGroup binding="#{Page1.tableRowGroup1}" id="tableRowGroup1" rows="10" sourceData="#{Page1.objectArrayDataProvider1}" sourceVar="currentRow">
  <ui:tableColumn binding="#{Page1.tableColumn1}" headerText="SortIP" id="tableColumn1" sort="#{currentRow.value['hostComparator']}">
    <ui:staticText binding="#{Page1.staticText1}" id="staticText1" text="#{currentRow.value['address']}"/>
  </ui:tableColumn>
  <ui:tableColumn binding="#{Page1.tableColumn2}" headerText="SortString" id="tableColumn2" sort="address">
    <ui:staticText binding="#{Page1.staticText2}" id="staticText2" text="#{currentRow.value['address']}"/>
  </ui:tableColumn>
</ui:tableRowGroup>Sorting localized with Locale="DE_de" according to ip/hostcompare sorts:
SortIP
1.1.1.1
2.1.1.1
9.1.1.1
11.1.1.1
0172.0172.0172.0172
123.1.1.1
a
�
o
�
u
�
zWhereas normal sort over String address whitout localization sorts:
SortString
0172.0172.0172.0172
1.1.1.1
11.1.1.1
123.1.1.1
2.1.1.1
9.1.1.1
a
o
u
z
�
�
�Not that short, but I hope it will help - if anyone has the need for another than the default sorting algorithms
Best regards,
Hate E. Lee