source/mir/util/DateTimeFunctions.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30 package mir.util;
  31
  32 import java.text.SimpleDateFormat;
  33 import java.util.Calendar;
  34 import java.util.Date;
  35 import java.util.GregorianCalendar;
  36 import java.util.SimpleTimeZone;
  37 import java.util.TimeZone;
  38
  39 public class DateTimeFunctions {
  40   /**
  41    * private parameter-less constructor to prevent construction
  42    */
  43   private DateTimeFunctions() {
  44   }
  45
  46   /**
  47    * Function to parse a <a href="http://www.w3.org/TR/NOTE-datetime">W3CDTF</a> formatted string.
  48    *
  49    *
  50    * YYYY[-MM[-DD[Thh:mm[:ss[.s*]]TZD]]]
  51    *
  52    * @param aString
  53    * @return
  54    */
  55   private final static String SPACE = "[\t\n\r ]*";
  56   private final static String NUMBER = "[0-9]*";
  57   private final static String TWODIGITNUMBER = "[0-9][0-9]";
  58   private final static String FOURDIGITNUMBER = "[0-9][0-9][0-9][0-9]";
  59   private final static String FRACTION = "(\\.[0-9]*)|)";
  60   private final static String SIGN = "[-+]";
  61   private final static String TZD = "(Z|(+|-)([0-9][0-9]:[0-9][0-9]|[0-9][0-9][0-9][0-9]))";
  62
  63   public static Date parseW3CDTFString(String aString) throws UtilExc, UtilFailure {
  64     try {
  65       int year = 1;
  66       int month = 1;
  67       int day = 1;
  68       int hour = 0;
  69       int minute = 0;
  70       int second = 0;
  71       int millisecond = 0;
  72       int houroffset = 0;
  73       int minuteoffset = 0;
  74
  75       SimpleParser parser = new SimpleParser(aString.trim());
  76       String part = parser.parse(NUMBER);
  77       year=Integer.parseInt(part);
  78       if (parser.parses("-")) {
  79         parser.skip("-");
  80         part = parser.parse(NUMBER);
  81         month = Integer.parseInt(part);
  82         if (parser.parses("-")) {
  83           parser.skip("-");
  84           part = parser.parse(NUMBER);
  85           day = Integer.parseInt(part);
  86           if (parser.parses("T")) {
  87             parser.skip("T");
  88             part = parser.parse(NUMBER);
  89             hour = Integer.parseInt(part);
  90             parser.skip(":");
  91             part = parser.parse(NUMBER);
  92             minute = Integer.parseInt(part);
  93             if (parser.parses(":")) {
  94               parser.skip(":");
  95               part = parser.parse(NUMBER);
  96               second = Integer.parseInt(part);
  97               if (parser.parses("\\.")) {
  98                 parser.skip("\\.");
  99                 part = parser.parse(NUMBER).substring(0,3);
 100                 while (part.length()<3)
 101                   part = "0" + part;
 102                 millisecond = Integer.parseInt(part);
 103               }
 104             }
 105             if (parser.parses("Z|\\+|-")) {
 106               String sign = parser.parse("Z|\\+|-");
 107               if (sign.equals("+") || sign.equals("-")) {
 108                 if (parser.parses(TWODIGITNUMBER)) {
 109                   part = parser.parse(TWODIGITNUMBER);
 110                   houroffset = Integer.parseInt(part);
 111                 }
 112                 if (parser.parses(":"))
 113                   parser.skip(":");
 114                 if (parser.parses(TWODIGITNUMBER)) {
 115                   part = parser.parse(TWODIGITNUMBER);
 116                   minuteoffset = Integer.parseInt(part);
 117                 }
 118
 119                 if (sign.equals("-")) {
 120                   houroffset = -houroffset;
 121                   minuteoffset = - minuteoffset;
 122                 }
 123               }
 124             }
 125
 126
 127           }
 128         }
 129       }
 130
 131
 132       String[] ids = TimeZone.getAvailableIDs((houroffset * 60 + minuteoffset) * 60 * 1000);
 133       String timeZoneID = "custom";
 134       if (ids.length != 0)
 135         timeZoneID = ids[0];
 136       SimpleTimeZone pdt = new SimpleTimeZone((houroffset * 60 + minuteoffset) * 60 * 1000, timeZoneID);
 137
 138       Calendar calendar = new GregorianCalendar(pdt);
 139       calendar.set(year, month, day, hour, minute, second);
 140       calendar.set(Calendar.MILLISECOND, millisecond);
 141
 142       System.out.println(aString + " -> " + new SimpleDateFormat("yyyy-dd-MM HH:mm Z").format(calendar.getTime()));
 143
 144       return calendar.getTime();
 145     }
 146     catch (Throwable t) {
 147       System.out.println(aString + " -> " + t.toString());
 148
 149       throw new UtilFailure(t);
 150     }
 151   }
 152 }