Util.java

Go to the documentation of this file.

/*
 * Project: Server for annotations sharing
 * Author: Ing. Jaroslav Dytrych idytrych@fit.vutbr.cz
 * File: Util.java
 * Description: Utility class (manipulates RFC 3339 dates and contains other 
 *              utility methods)
 */

/**
 * @file Util.java
 *
 * @brief Utility class (manipulates RFC 3339 dates and contains other utility methods)
 */

package cz.vutbr.fit.knot.annotations.comet;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;

/**
 * Utility class (manipulates RFC 3339 dates and contains other utility methods)
 *
 * @brief Utility class (manipulates RFC 3339 dates)
 * @author idytrych
 */
public class Util {
  /*
   * Adapted from http://lit.hatori42.com/RFC3339Date.txt and added sign recognition.
   *
  I was working on an Atom (http://www.w3.org/2005/Atom) parser and discovered that I
  could not parse dates in the format defined by RFC 3339 using the  SimpleDateFormat
  class. The  reason was the ':' in the time  zone. This code strips out the colon if
  it's there and tries four different formats on the resulting string depending on if
  it has a  time zone, or if it has a  fractional second part.  There is a probably a
  better way  to do this, and a more proper way.  But this is a really small addition
  to a  codebase  (You don't  need a jar, just throw  this  function in  some  static
  Utility class if you have one).

  Feel free to use this in your code, but I'd appreciate it if you keep this note  in
  the code if you distribute it.  Thanks!

  For  people  who might  be  googling: The date  format  parsed  by  this  goes  by:
  atomDateConstruct,  xsd:dateTime,  RFC3339  and  is compatable with: ISO.8601.1988,
  W3C.NOTE-datetime-19980827  and  W3C.REC-xmlschema-2-20041028   (that  I  know  of)


  Copyright 2007, Chad Okere (ceothrow1 at gmail dotcom)
  OMG NO WARRENTY EXPRESSED OR IMPLIED!!!1
   */
  
   public static final int RESERVED_CHARS = 0;
  public static final int TEXTUAL_CHARS = 1;
  public static final int NUMERAL_CHARS = 2;
  public static final int TEXTUAL_MAX_SIZE = 8;
  public static final int NUMERAL_MAX_SIZE = 4;
  
  public static final String START_OF_TEXTUAL = "&";
  public static final String START_OF_NUMERAL = "&#";
  public static final String END_OF_MARK = ";";
  
  public static final ArrayList<String> AMP_LIST = new ArrayList<String>(Arrays.asList("&",START_OF_TEXTUAL + "amp" + END_OF_MARK,START_OF_NUMERAL + "38" + END_OF_MARK));
  public static final ArrayList<String> APOS_LIST = new ArrayList<String>(Arrays.asList("'",START_OF_TEXTUAL + "apos" + END_OF_MARK,START_OF_NUMERAL + "39" + END_OF_MARK));
  public static final ArrayList<String> QUOT_LIST = new ArrayList<String>(Arrays.asList("\"",START_OF_TEXTUAL + "quot" + END_OF_MARK,START_OF_NUMERAL + "34" + END_OF_MARK));
  public static final ArrayList<String> GT_LIST = new ArrayList<String>(Arrays.asList(">",START_OF_TEXTUAL + "gt" + END_OF_MARK,START_OF_NUMERAL + "62" + END_OF_MARK));
  public static final ArrayList<String> LT_LIST = new ArrayList<String>(Arrays.asList("<",START_OF_TEXTUAL + "lt" + END_OF_MARK,START_OF_NUMERAL + "60" + END_OF_MARK));
  
  public static final ArrayList<ArrayList<String>> RESERVED_HTML_CHARS =  new ArrayList<ArrayList<String>>();
  static{
      RESERVED_HTML_CHARS.add(AMP_LIST);
      RESERVED_HTML_CHARS.add(APOS_LIST);
      RESERVED_HTML_CHARS.add(QUOT_LIST);
      RESERVED_HTML_CHARS.add(GT_LIST);
      RESERVED_HTML_CHARS.add(LT_LIST);
  }
  /**
   * Parse date in format according to RFC 3339
   *
   * @author Chad Okere (ceothrow1 at gmail dotcom)
   * @author idytrych
   * @param datestring Date in string
   * @return Returns parsed date
   */
  public static java.util.Date parseRFC3339Date(String datestring) throws java.text.ParseException, IndexOutOfBoundsException {
    Date d = new Date();

    //if there is no time zone, we don't need to do any special parsing.
    if (datestring.endsWith("Z")) {
      try {
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");//spec for RFC3339
        d = s.parse(datestring);
      } catch (java.text.ParseException pe) {//try again with optional decimals
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSS'Z'");//spec for RFC3339 (with fractional seconds)
        s.setLenient(true);
        d = s.parse(datestring);
      }
      return d;
    }

    //step one, split off the timezone.
    String sign = "-";
    if (datestring.contains("+")) {
      sign = "+";
    }
    String firstpart = datestring.substring(0, datestring.lastIndexOf(sign));
    String secondpart = datestring.substring(datestring.lastIndexOf(sign));

    //step two, remove the colon from the timezone offset
    secondpart = secondpart.substring(0, secondpart.indexOf(':')) + secondpart.substring(secondpart.indexOf(':') + 1);
    datestring = firstpart + secondpart;
    SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");//spec for RFC3339
    try {
      d = s.parse(datestring);
    } catch (java.text.ParseException pe) {//try again with optional decimals
      s = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSSSSZ");//spec for RFC3339 (with fractional seconds)
      s.setLenient(true);
      d = s.parse(datestring);
    }
    return d;
  }  // parseRFC3339Date()

  /**
   * Parse date in format according to RFC 3339 (date only, without time)
   *
   * @author idytrych
   * @param datestring Date in string
   * @return Returns parsed date
   */
  public static java.util.Date parseDate(String datestring) throws java.text.ParseException, IndexOutOfBoundsException {
    Date d = new Date();

    //if there is no time zone, we don't need to do any special parsing.
    if (datestring.endsWith("Z")) {
      SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd'Z'");//spec for RFC3339
      d = s.parse(datestring);
      return d;
    }

    //step one, split off the timezone.
    String sign = "-";
    if (datestring.contains("+")) {
      sign = "+";
    }
    String firstpart = datestring.substring(0, datestring.lastIndexOf(sign));
    String secondpart = datestring.substring(datestring.lastIndexOf(sign));

    //step two, remove the colon from the timezone offset
    secondpart = secondpart.substring(0, secondpart.indexOf(':')) + secondpart.substring(secondpart.indexOf(':') + 1);
    datestring = firstpart + secondpart;
    SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-ddZ");//spec for RFC3339
    d = s.parse(datestring);
    return d;
  }  // parseDate()

  /**
   * Parse time in format according to RFC 3339
   *
   * @author idytrych
   * @param datestring Time in string
   * @return Returns parsed time (with some date)
   */
  public static java.util.Date parseTime(String datestring) throws java.text.ParseException, IndexOutOfBoundsException {
    Date d = new Date();

    //if there is no time zone, we don't need to do any special parsing.
    if (datestring.endsWith("Z")) {
      try {
        SimpleDateFormat s = new SimpleDateFormat("HH:mm:ss'Z'");//spec for RFC3339
        d = s.parse(datestring);
      } catch (java.text.ParseException pe) {//try again with optional decimals
        SimpleDateFormat s = new SimpleDateFormat("HH:mm:ss.SSSSSS'Z'");//spec for RFC3339 (with fractional seconds)
        s.setLenient(true);
        d = s.parse(datestring);
      }
      return d;
    }

    //step one, split off the timezone.
    String sign = "-";
    if (datestring.contains("+")) {
      sign = "+";
    }
    String firstpart = datestring.substring(0, datestring.lastIndexOf(sign));
    String secondpart = datestring.substring(datestring.lastIndexOf(sign));

    //step two, remove the colon from the timezone offset
    secondpart = secondpart.substring(0, secondpart.indexOf(':')) + secondpart.substring(secondpart.indexOf(':') + 1);
    datestring = firstpart + secondpart;
    SimpleDateFormat s = new SimpleDateFormat("HH:mm:ssZ");//spec for RFC3339
    try {
      d = s.parse(datestring);
    } catch (java.text.ParseException pe) {//try again with optional decimals
      s = new SimpleDateFormat("HH:mm:ss.SSSSSSZ");//spec for RFC3339 (with fractional seconds)
      s.setLenient(true);
      d = s.parse(datestring);
    }
    return d;
  }  // parseTime()

  /**
   * Converts date to string in format according to RFC 3339
   *
   * @param date Date to be converted
   * @return String with date in format according to RFC 3339
   */
  public static String toRFC3339Date(Date date) {
    if(date == null) return "";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
    String formatted = sdf.format(date);
    if (!formatted.endsWith("Z")) {
      formatted = formatted.substring(0,formatted.length() - 2) + ":"
                  + formatted.substring(formatted.length() - 2,formatted.length());
    }
    return formatted;
  }

  /**
   * Converts date to string in format according to RFC 3339 (date only, without time)
   *
   * @param date Date to be converted
   * @return String with date in format according to RFC 3339 (without time)
   */
  public static String toRFC3339DateOnly(Date date) {
    if(date == null) return "";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddZ");
    String formatted;
    try{
      formatted = sdf.format(date);
    }
    
    catch(Exception e){
      System.out.print(e.getMessage());
      return "";
    }
    
    if (!formatted.endsWith("Z")) {
      formatted = formatted.substring(0,formatted.length() - 2) + ":"
                  + formatted.substring(formatted.length() - 2,formatted.length());
    }
    return formatted;
  }

  /**
   * Converts date to string in format according to RFC 3339 
   * (date only, without time, without time zone)
   *
   * @param date Date to be converted
   * @return String with date in format according to RFC 3339 (without time and time zone)
   */
  public static String toRFC3339DateOnlyWTZ(Date date) {
    if(date == null) return "";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    String formatted;
    try{
      formatted = sdf.format(date);
    }
    
    catch(Exception e){
      System.out.print(e.getMessage());
      return "";
    }
    
    return formatted;
  }
  
  /**
   * Converts time to string in format according to RFC 3339
   *
   * @param date Date with time to be converted
   * @return String with time in format according to RFC 3339
   */
  public static String toRFC3339Time(Date date) {
    if(date == null) return "";
    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ssZ");
    String formatted = sdf.format(date);
    if (!formatted.endsWith("Z")) {
      formatted = formatted.substring(0,formatted.length() - 2) + ":"
                  + formatted.substring(formatted.length() - 2,formatted.length());
    }
    return formatted;
  }
  

  /**
   * Gets minimum of three values
   * 
   * @param a Value 1
   * @param b Value 2
   * @param c Value 3
   * @return Returns minimum of three values
   */
  public static int minimum (int a, int b, int c) {
    return Math.min(a, Math.min(b, c));
  }

  /**
   * Compute Levenshtein distance
   * Adapted from http://www.merriampark.com/ld.htm
   * 
   * @author Michael Gilleland (megilleland at yahoo.com)
   * @param s String s
   * @param t String t
   * @return Returns Levenshtein distance of strings s and t
   */
  public static int levenshtein (String s, String t) {
    int d[][]; // matrix
    int n; // length of s
    int m; // length of t
    int i; // iterates through s
    int j; // iterates through t
    char s_i; // ith character of s
    char t_j; // jth character of t
    int cost; // cost

    // Step 1

    n = s.length();
    m = t.length();
    if (n == 0) {
      return m;
    }
    if (m == 0) {
      return n;
    }
    d = new int[n + 1][m + 1];

    // Step 2

    for (i = 0; i <= n; i++) {
      d[i][0] = i;
    }

    for (j = 0; j <= m; j++) {
      d[0][j] = j;
    }

    // Step 3

    for (i = 1; i <= n; i++) {

      s_i = s.charAt(i - 1);

      // Step 4

      for (j = 1; j <= m; j++) {

        t_j = t.charAt(j - 1);

        // Step 5

        if (s_i == t_j) {
          cost = 0;
        } else {
          cost = 1;
        }

        // Step 6

        d[i][j] = minimum(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);

      }

    }

    // Step 7

    return d[n][m];

  }  // levenshtein()

  /**
   * Escapes string for use in XML
   * (replaces <,>,&,",')
   * 
   * @param str String to escape
   * @return Escaped string
   */
  public static String escapeForXml(String str) {
    String escaped = str.replace("&", "&amp;");
    escaped = escaped.replace("<", "&lt;");
    escaped = escaped.replace(">", "&gt;");
    escaped = escaped.replace("\"", "&quot;");
    escaped = escaped.replace("'", "&apos;");
    return escaped;
  } 
  
  /**
   * Parses the timezone from the end of the String
   * @param date String with date and timezone on the end of it.
   * @return Timezone string or null
   */
  public static String parseTimeZoneID(String date){
    if(date == null || date.length()-5 < 0){
      return null;
    }
    String offset = date.substring(date.length()-6, date.length());
    if(offset.matches("(\\+|-)(0[0-9]|1[0-5]):[0-5][0-9]")){
      return offset;
    }
    else{
      return null;
    }
  }
  
  /**
   * The method seeks a special character in a string and evaluates whether it 
   * is a character entity.
   * 
   * @param source tested string
   * @return true if it is character entity
   */
  private static boolean isSpecial(String source){
      int startIndex = 0;
      boolean isTextOnly = false;
      boolean isNumberOnly = false;
      
      if(source.charAt(0) != '&'){
        return false;
      }else{
        startIndex ++;
      }
      
      if(source.charAt(1) == '#'){
        startIndex ++;
        isNumberOnly = true;
      }
      
      for(int i = startIndex; i < source.length(); i++){
        char actualChar = source.charAt(i);
        
        if(actualChar == ';' && (isTextOnly || isNumberOnly) && i > 0){
          return true;
        }
        
        if(isTextOnly && !isNumberOnly){
          //text only section
          if(!Character.isLetter(actualChar)){
            return false;
          }
        }else if(!isTextOnly && isNumberOnly){
          //number only
          if(!Character.isDigit(actualChar) && (i - startIndex) > NUMERAL_MAX_SIZE){
            return false;
          }
        }else{
          return false;
        }
      }
    return false;
  }
  /**
   * The method converts an ordinary string to XML string.
   * 
   * @param source ordinary string
   * @return converted XML string
   *
   */
  public static String toHTMLString(String source){
    if (source == null) {
      return "";
    }
    StringBuilder result = new StringBuilder();
    boolean added;
    
    for(int i = 0; i < source.length(); i++){
      added = false;
      Iterator <ArrayList<String>> reservedCharsIt = RESERVED_HTML_CHARS.iterator();
      while(reservedCharsIt.hasNext()){
        ArrayList<String> currentReservedChar = reservedCharsIt.next();
        if(source.charAt(i) == currentReservedChar.get(RESERVED_CHARS).charAt(0)){
          if(source.charAt(i) != '&'){
            result.append(currentReservedChar.get(NUMERAL_CHARS));
            added = true;
            continue;
          }else{
            int index = source.indexOf(END_OF_MARK, i);
            int length = 0;
            if(index > 0){
              length = index - source.length();
            }
            
            if(length > 0 && length <= TEXTUAL_MAX_SIZE && isSpecial(source.substring(i, index))){
              i += length;
              result.append(source.substring(i, index));
              added = true;
              continue;
            }else{
              result.append(currentReservedChar.get(NUMERAL_CHARS));
              added = true;
              continue;
            }
          }
        }
      }
      if(!added){
        result.append(source.charAt(i));
      }
    }
    
    return result.toString();
  }
  
}  // class Util