PropertyValueComparator.java

/***************************************************************************
 * Copyright (C) 2003-2009 eXo Platform SAS.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see<http://www.gnu.org/licenses/>.
 *
 **************************************************************************/
package org.exoplatform.ecm.utils.comparator;

import java.util.Calendar;
import java.util.Comparator;

import javax.jcr.Node;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;

import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;

/**
 * Created by The eXo Platform SARL
 * Author : Hoang Van Hung
 *          hunghvit@gmail.com
 * May 14, 2009
 */
public class PropertyValueComparator implements Comparator<Node> {

  public static final String ASCENDING_ORDER  = "Ascending";

  public static final String DESCENDING_ORDER = "Descending";

  private String             propertyName;

  private String             orderType;
  private static final Log LOG  = ExoLogger.getLogger(PropertyValueComparator.class.getName());
  public PropertyValueComparator(String propertyName, String orderType) {
    this.propertyName = propertyName;
    this.orderType = orderType;
  }

  public int compare(Node node0, Node node1) {
    int flipFlop = ASCENDING_ORDER.equals(orderType) ? 1 : -1;    
    int requireType = getRequireType(node0);    
    int requireType2 = getRequireType(node1);     
    if (requireType == -1 && requireType2 == -1) return 0;    
    if (requireType == -1 && requireType2 != -1) return -1 * flipFlop;    
    if (requireType != -1 && requireType2 == -1) return 1 * flipFlop; 
    try {
      switch (requireType) {
      case PropertyType.BINARY:
        return compareString(node0, node1);
      case PropertyType.BOOLEAN:
        return compareString(node0, node1);
      case PropertyType.NAME:
        return compareString(node0, node1);
      case PropertyType.PATH:
        return compareString(node0, node1);
      case PropertyType.STRING:
        return compareString(node0, node1);
      case PropertyType.LONG:
        return compareLong(node0, node1);
      case PropertyType.DOUBLE:
        return compareLong(node0, node1);
      case PropertyType.DATE:
        return compareDate(node0, node1);
      case PropertyType.REFERENCE:
        return compareString(node0, node1);
      default:
        throw new RepositoryException("Unknown type " + requireType);
      }
    } catch (Exception e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Unexpected error", e);
      }
      return 0;
    }
  }
  
  private int compareLong(Node node0, Node node1) {
    try {
      long propertyValue0 = node0.getProperty(propertyName) == null ? -1 : node0.getProperty(propertyName)
              .getLong();
      long propertyValue1 = node1.getProperty(propertyName) == null ? -1 : node1.getProperty(propertyName)
              .getLong();
      if (ASCENDING_ORDER.equals(orderType)) {
        if (propertyValue0 < propertyValue1) {
          return -1;
        } else if (propertyValue0 == propertyValue1) {
          return 0;
        } else {
          return 1;
        }
      } else {
        if (propertyValue0 < propertyValue1) {
          return 1;
        } else if (propertyValue0 == propertyValue1) {
          return 0;
        } else {
          return -1;
        }
      }
    } catch (RepositoryException e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Unexpected error", e);
      }
      return 0;
    }
  }

  private int getRequireType(Node node) {
    try {
      if (node.hasProperty(propertyName)) {
        return node.getProperty(propertyName).getDefinition().getRequiredType();
      }
     return -1;
    } catch (RepositoryException e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Unexpected error", e);
      }
      return -1;
    }
  }

  private int compareString(Node node0, Node node1) {
    try {
      String propertyValue0 = node0.getProperty(propertyName) == null ? ""
                                                                     : String.valueOf(node0.getProperty(propertyName)
                                                                                           .getString());
      String propertyValue1 = node1.getProperty(propertyName) == null ? ""
                                                                     : String.valueOf(node1.getProperty(propertyName)
                                                                                           .getString());
      if(ASCENDING_ORDER.equals(orderType)) {
        return propertyValue0.compareToIgnoreCase(propertyValue1);
      }
      return propertyValue1.compareToIgnoreCase(propertyValue0);
    } catch(RepositoryException e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Unexpected error", e);
      }
      return 0;
    }
  }

  public int compareDate(Node node0, Node node1) {
    try{
        Calendar date0 = node0.getProperty(propertyName).getDate();
        Calendar date1 = node1.getProperty(propertyName).getDate();
        if(ASCENDING_ORDER.equals(orderType)) {
          return date0.compareTo(date1) ;
        }
        return date1.compareTo(date0) ;
    } catch (Exception e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Unexpected error", e);
      }
    }
    return 0;
  }
}