awsapi/src/com/cloud/bridge/util/ISO8601SimpleDateTimeFormat.java

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

package com.cloud.bridge.util;

import java.text.SimpleDateFormat;

import java.text.DateFormat;
import java.text.FieldPosition;
import java.text.ParsePosition;
import java.util.Date;
import java.util.Calendar;
import java.util.TimeZone;

/**
 * Format and parse a date string which is expected to be in ISO 8601 DateTimeFormat especially for 
 * use in XML documents.
 * An example is for use with GMTDateTimeUserType to provide parsing of DateTime format strings into 
 * accurate Java Date representations based on UTC.
 * The purpose of this class is to allow the creation of accurate date time representations following
 * the ISO 8601 format YYYY-MM-DDThh:MM:ss
 * using the letter "T" as the date/time separator
 * This representation may be immediately followed by a "Z" (Zulu i.e. at zero offset from GMT) to indicate UTC 
 * or, otherwise, to a specific time zone.  If a time zone (tz) is encoded then this is held as the difference 
 * between the local time in the tz and UCT, expressed as a positive(+) or negative(-) offset (hhMM) appended 
 * to the format.
 * The default case holds no tz information and assumes that a date time representation referenced to Zulu
 * (i.e. zero offset from GMT) is required.  When formatting an existing Date transform it into the Zulu timezone
 * so that it is explicitly at GMT with zero offset.  This provides the default representation for the encoding 
 * of AWS datetime values.
 * For testing, it may be useful to note that, as at 2012, a city whose time is always in the Zulu timezone is
 * Reykjavik, Iceland.
 * The parsing and formatting methods provided by this class are GMT-referenced and locale insensitive.
 */

public class ISO8601SimpleDateTimeFormat extends SimpleDateFormat {
	
	private static final long serialVersionUID = 7388260211953189670L;
	
	protected static TimeZone defaultTimeZone = TimeZone.getTimeZone("Z");
	
	  /**
	   * Construct a new ISO8601DateTimeFormat using the default time zone.
	   * Initializes calendar inherited from java.text.DateFormat.calendar
	   *
	   */
	  public ISO8601SimpleDateTimeFormat() {
	    setCalendar(Calendar.getInstance(defaultTimeZone));
	  }

	  /**
	   * Construct a new ISO8601DateTimeFormat using a specific time zone.
	   * Initializes calendar inherited from java.text.DateFormat.calendar
	   * @param tz The time zone used to format and parse the date.
	   */
	  public ISO8601SimpleDateTimeFormat(TimeZone tz) {
	    setCalendar(Calendar.getInstance(tz));
	  }

      /**
       * The abstract superclass DateFormat has two business methods to override.  These are
       * public StringBuffer format(Date arg0, StringBuffer arg1, FieldPosition arg2)
       * public Date parse(String arg0, ParsePosition arg1)
       */
	
	  /**
	   * @see DateFormat#format(Date, StringBuffer, FieldPosition)
	   */
      @Override
	  public StringBuffer format(Date date, StringBuffer stringBuffer, FieldPosition fieldPosition) {
         calendar.setTime(date);
         calendar.setTimeZone(defaultTimeZone);
         writeYYYYMM(stringBuffer);
         stringBuffer.append('T');
         writehhMMss(stringBuffer);
         stringBuffer.append(".000Z");
         return stringBuffer;
	  }

	  /* @see DateFormat#parse(String, ParsePosition)
	   * Assigns the values of YYYY-MM-DDThh:MM:ss fields between the delimiters of dateString
	   * or a near approximation using the superclass SimpleDateFormat if not formatted exactly as ISO8601
	   */
	  @Override
	  public Date parse(String dateString, ParsePosition pos) {
		ParsePosition startpos = pos;
	    int p = pos.getIndex();
	    // Assign value of YYYY
	    try {
	      int YYYY = Integer.valueOf(dateString.substring(p, p + 4)).intValue();
	      p += 4;
	      if (dateString.charAt(p) != '-') {
	        throw new IllegalArgumentException();
	      }
	      p++;
	    // Assign value of MM
	      int MM = Integer.valueOf(dateString.substring(p, p + 2)).intValue() - 1;
	      p += 2;
	      if (dateString.charAt(p) != '-') {
		        throw new IllegalArgumentException();
	      }
	      p++;
	    // Asign value of dd
	      int DD = Integer.valueOf(dateString.substring(p, p + 2)).intValue();
	      p += 2;
	      if (dateString.charAt(p) != 'T') {
		        throw new IllegalArgumentException();
	      }
	      p++;
	    // Assign value of hh
	      int hh = Integer.valueOf(dateString.substring(p, p + 2)).intValue();
	      p += 2;
	      if (dateString.charAt(p) != ':') {
		        throw new IllegalArgumentException();
	      }
	      p++;
       // Assign value of mm
	      int mm = Integer.valueOf(dateString.substring(p, p + 2)).intValue();
	      p += 2;
	      if (dateString.charAt(p) != ':') {
		        throw new IllegalArgumentException();
	      }
		  p++;
	   // Assign value of ss
	      int ss = 0;
	   //   if (p < dateString.length() && dateString.charAt(p) == ':') {
       // Allow exactly two ss digits after final : delimiter
	        ss = Integer.valueOf(dateString.substring(p, p + 2)).intValue();
	        p += 2;
		// Set calendar inherited from java.text.DateFormat.calendar
	      calendar.set(YYYY, MM, DD, hh, mm, ss);
	      calendar.set(Calendar.MILLISECOND, 0); // Since java.util.Date holds none, zeroize milliseconds
		// process appended timezone if any or Z otherwise
	    p = parseTZ(p, dateString);
	    }
	    catch (IllegalArgumentException ex) {
	      super.setTimeZone(TimeZone.getTimeZone("GMT"));
	      super.applyPattern("yyyy-MM-dd HH:mm:ss");
	      return super.parse(dateString, startpos);
	    }
	    catch (Exception ex) {
		super.setTimeZone(TimeZone.getTimeZone("GMT"));
		return super.parse(dateString, startpos);    // default pattern
	    } 
	    finally
	    {
	     pos.setIndex(p);
	    }
	   // Return the Calendar instance's Date representation of its value
		return calendar.getTime();
	 }

		  /**
		   * Write the time zone string.  Remember that in the default TimeZone there is no offset and the
		   * convention to supply the TimeZone string constant "Z" is applicable.  As an optimization there
		   * is no need to call this method where the default TimeZone has been set.
		   * @param stringBuffer The buffer to append the time zone.
		   */
		  protected final void writeTZ(StringBuffer stringBuffer) {
		    int offset =
		      calendar.get(Calendar.ZONE_OFFSET) + calendar.get(Calendar.DST_OFFSET);
		    if (offset == 0) {
		      stringBuffer.append('Z');
		    }
		    else {
		      int offsetHour = offset / 3600000;
		      int offsetMin = (offset % 3600000) / 60000;
		      if (offset >= 0) {
		        stringBuffer.append('+');
		      }
		      else {
		        stringBuffer.append('-');
		        offsetHour = 0 - offsetHour;
		        offsetMin = 0 - offsetMin;
		      }
		      appendInt(stringBuffer, offsetHour, 2);
		      stringBuffer.append(':');
		      appendInt(stringBuffer, offsetMin, 2);
		    }
		  }

		  /**
		   * Write hour, minutes, and seconds.
		   * @param stringBuffer The buffer to append the string.
		   */
		  protected final void writehhMMss(StringBuffer stringBuffer) {
		    int hh = calendar.get(Calendar.HOUR_OF_DAY);
		    appendInt(stringBuffer, hh, 2);
		    stringBuffer.append(':');

		    int mm = calendar.get(Calendar.MINUTE);
		    appendInt(stringBuffer, mm, 2);
		    stringBuffer.append(':');

		    int ss = calendar.get(Calendar.SECOND);
		    appendInt(stringBuffer, ss, 2);
		  }

		  /**
		   * Write YYYY, and MMs.
		   * @param stringBuffer The buffer to append the string.
		   */
		  protected final void writeYYYYMM(StringBuffer stringBuffer) {
		    int YYYY = calendar.get(Calendar.YEAR);
		    appendInt(stringBuffer, YYYY, 4);

		    String MM;
		    switch (calendar.get(Calendar.MONTH)) {
		      case Calendar.JANUARY :
		        MM = "-01-";
		        break;
		      case Calendar.FEBRUARY :
		        MM = "-02-";
		        break;
		      case Calendar.MARCH :
		        MM = "-03-";
		        break;
		      case Calendar.APRIL :
		        MM = "-04-";
		        break;
		      case Calendar.MAY :
		        MM = "-05-";
		        break;
		      case Calendar.JUNE :
		        MM = "-06-";
		        break;
		      case Calendar.JULY :
		        MM = "-07-";
		        break;
		      case Calendar.AUGUST :
		        MM = "-08-";
		        break;
		      case Calendar.SEPTEMBER :
		        MM = "-09-";
		        break;
		      case Calendar.OCTOBER :
		        MM = "-10-";
		        break;
		      case Calendar.NOVEMBER :
		        MM = "-11-";
		        break;
		      case Calendar.DECEMBER :
		        MM = "-12-";
		        break;
		      default :
		        MM = "-NA-";
		        break;
		    }
		    stringBuffer.append(MM);

		    int DD = calendar.get(Calendar.DAY_OF_MONTH);
		    appendInt(stringBuffer, DD, 2);
		  }

		  /**
		   * Write an integer value with leading zeros.
		   * @param stringBuffer The buffer to append the string.
		   * @param value The value to write.
		   * @param length The length of the string to write.
		   */
		  protected final void appendInt(StringBuffer stringBuffer, int value, int length) {
		    int len1 = stringBuffer.length();
		    stringBuffer.append(value);
		    int len2 = stringBuffer.length();
		    for (int i = len2; i < len1 + length; ++i) {
		      stringBuffer.insert(len1, '0');
		    }
		  }
		  
		  /**
		   * Parse the time zone.
		   * @param i The position to start parsing.
		   * @param dateString The dateString to parse.
		   * @return The position after parsing has finished.
		   */

		  protected final int parseTZ(int i, String dateString)  {
		    if (i < dateString.length()) {
		      // check and handle the zone/dst offset
		      int offset = 0;
		      if (dateString.charAt(i) == 'Z') {
		        offset = 0;
		        i++;
		      }
		      else {
		        int sign = 1;
		        if (dateString.charAt(i) == '-') {
		          sign = -1;
		        }
		        else if (dateString.charAt(i) != '+') {
		          throw new IllegalArgumentException();
		        }
		        i++;

		        int offsetHour = Integer.valueOf(dateString.substring(i, i + 2)).intValue();
		        i += 2;

		        if (dateString.charAt(i) != ':') {
		          throw new IllegalArgumentException();
		        }
		        i++;

		        int offsetMin = Integer.valueOf(dateString.substring(i, i + 2)).intValue();
		        i += 2;
		        offset = ((offsetHour * 60) + offsetMin) * 60000 * sign;
		      }
		      int offsetCal =
		        calendar.get(Calendar.ZONE_OFFSET) + calendar.get(Calendar.DST_OFFSET);

		      calendar.add(Calendar.MILLISECOND, offsetCal - offset);
		    }
		    return i;
		    
		  }

		  @Override
		     public int hashCode() {
		         return (calendar.get(2)+calendar.get(16));
		         // numberFormat (used by superclass) will not distribute, so use calendar third and penultimate fields
		         // (i.e. dd and ss) instead
		         // in Java 6 (Calendar.FIELD_COUNT-1) returns 16
		     }
		 
		  @Override
		     public boolean equals(Object obj) {
		         if (this == obj) return true;
		         if (obj == null || getClass() != obj.getClass()) return false;
		         DateFormat other = (DateFormat) obj;
		         Calendar otherCalendar = other.getCalendar();
		         for (int i = 0; i < Calendar.FIELD_COUNT; i++)
		        	 if ( calendar.get(i) != (otherCalendar.get(i)) ) return false;
		         return true;
		     }
		 

		
	}