src/com/ibm/icu/dev/tool/timezone/ICUZDump.java - external/github.com/unicode-org/icu - Git at Google

 /*
  ***********************************************************************
  * Copyright (C) 2007, International Business Machines                 *
  * Corporation and others. All Rights Reserved.                        *
  ***********************************************************************
  *
  */

 package com.ibm.icu.dev.tool.timezone;

 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.Writer;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.List;
 import java.util.TreeSet;

 import com.ibm.icu.text.DecimalFormat;
 import com.ibm.icu.text.DecimalFormatSymbols;
 import com.ibm.icu.text.SimpleDateFormat;
 import com.ibm.icu.util.GregorianCalendar;
 import com.ibm.icu.util.SimpleTimeZone;
 import com.ibm.icu.util.ULocale;

 /**
  * TimeZone transition dump tool.
  */
 public class ICUZDump {
     private static final String DEFAULT_LINE_SEP;

     static {
         String sep = System.getProperty("line.separator");
         DEFAULT_LINE_SEP = (sep == null) ? "\n" : sep;
     }

     private TimeZoneImpl tz = null;

     private int loyear = 1900;
     private int hiyear = 2050;
     private long tick = 1000;
     private DumpFormatter formatter;
     private String linesep = DEFAULT_LINE_SEP;

     public ICUZDump() {
     }

     public void setLowYear(int loyear) {
         this.loyear = loyear;
     }

     public void setHighYear(int hiyear) {
         this.hiyear = hiyear;
     }

     public void setTick(int tick) {
         if (tick <= 0) {
             throw new IllegalArgumentException("tick must be positive");
         }
         this.tick = tick;
     }

     public void setTimeZone(Object tzimpl) {
         this.tz = new TimeZoneImpl(tzimpl);
     }

     public void setDumpFormatter(DumpFormatter formatter) {
         this.formatter = formatter;
     }

     public void setLineSeparator(String sep) {
         this.linesep = sep;
     }

     public void dump(Writer w) throws IOException {
         if (tz == null) {
             throw new IllegalStateException("timezone is not initialized");
         }

         if (formatter == null) {
             formatter = new DumpFormatter();
         }

         final long SEARCH_INCREMENT = 12 * 60 * 60 * 1000; // half day
         long cutovers[] = getCutOverTimes();
         long t = cutovers[0];
         int offset = tz.getOffset(t);
         boolean inDst = tz.inDaylightTime(t);
         while (t < cutovers[1]) {
             long newt = t + SEARCH_INCREMENT;
             int newOffset = tz.getOffset(newt);
             boolean newInDst = tz.inDaylightTime(newt);
             if (offset != newOffset || inDst != newInDst) {
                 // find the boundary
                 long lot = t;
                 long hit = newt;
                 while (true) {
                     long diff = hit - lot;
                     if (diff <= tick) {
                         break;
                     }
                     long medt = lot + ((diff / 2) / tick) * tick;
                     int medOffset = tz.getOffset(medt);
                     boolean medInDst = tz.inDaylightTime(medt);
                     if (medOffset != offset || medInDst != inDst) {
                         hit = medt;
                     } else {
                         lot = medt;
                     }
                 }
                 w.write(formatter.format(lot, offset, tz.inDaylightTime(lot)));
                 w.write(" > ");
                 w.write(formatter.format(hit, newOffset, tz.inDaylightTime(hit)));
                 w.write(linesep);
                 offset = newOffset;
                 inDst = newInDst;
             }
             t = newt;
         }

     }

     private long[] getCutOverTimes() {
         long[] cutovers = new long[2];
         cutovers[0] = tz.getTime(loyear, 0, 1, 0, 0, 0);
         cutovers[1] = tz.getTime(hiyear, 0, 1, 0, 0, 0);
         return cutovers;
     }

     private class TimeZoneImpl {
         private Object tzobj;

         public TimeZoneImpl(Object tzobj) {
             this.tzobj = tzobj;
         }

         public int getOffset(long time) {
             try {
                 Method method = tzobj.getClass().getMethod("getOffset", new Class[] {long.class});
                 Object result = method.invoke(tzobj, new Object[] {new Long(time)});
                 return ((Integer)result).intValue();
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return 0;
         }

         public boolean inDaylightTime(long time) {
             try {
                 Method method = tzobj.getClass().getMethod("inDaylightTime", new Class[] {Date.class});
                 Object result = method.invoke(tzobj, new Object[] {new Date(time)});
                 return ((Boolean)result).booleanValue();
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return false;
         }

         public long getTime(int year, int month, int dayOfMonth, int hour, int minute, int second) {
             long time;
             if (tzobj instanceof com.ibm.icu.util.TimeZone) {
                 GregorianCalendar cal = new GregorianCalendar();
                 cal.setTimeZone((com.ibm.icu.util.TimeZone)tzobj);
                 cal.clear();
                 cal.set(year, month, dayOfMonth, hour, minute, second);
                 time = cal.getTimeInMillis();
             } else if (tzobj instanceof java.util.TimeZone) {
                 java.util.GregorianCalendar cal = new java.util.GregorianCalendar();
                 cal.setTimeZone((java.util.TimeZone)tzobj);
                 cal.clear();
                 cal.set(year, month, dayOfMonth, hour, minute, second);
                 time = cal.getTimeInMillis();
             } else {
                 throw new IllegalStateException("Unsupported TimeZone implementation");
             }
             return time;
         }
     }

     public class DumpFormatter {
         private SimpleTimeZone stz = new SimpleTimeZone(0, "");
         private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd EEE HH:mm:ss", ULocale.US);
         private DecimalFormat decf;

         public DumpFormatter() {
             DecimalFormatSymbols decfs = new DecimalFormatSymbols(ULocale.US);
             decf = new DecimalFormat("00", decfs);
         }

         public String format(long time, int offset, boolean isDst) {
             StringBuffer buf = new StringBuffer();
             stz.setRawOffset(offset);
             sdf.setTimeZone(stz);
             buf.append(sdf.format(new Date(time)));
             if (offset < 0) {
                 buf.append("-");
                 offset = -offset;
             } else {
                 buf.append("+");
             }

             int hour, min, sec;

             offset /= 1000;
             sec = offset % 60;
             offset = (offset - sec) / 60;
             min = offset % 60;
             hour = offset / 60;

             buf.append(decf.format(hour));
             buf.append(decf.format(min));
             buf.append(decf.format(sec));

             buf.append("[DST=");
             buf.append(isDst ? "1" : "0");
             buf.append("]");
             return buf.toString();
         }
     }

     /*
      * Usage:
      *
      * java -cp icu4j.jar com.ibm.icu.dev.tool.timezone [-j] [-a] [-c[<low_year>,]<high_year>] [-d<dir>] [-l<sep>] [<zone_name> [<zone_name>]]
      *
      * Options:
      *      -j      : Use JDK TimeZone.  By default, ICU TimeZone is used.
      *      -a      : Dump all available zones.
      *      -c[<low_year>,]<high_year>
      *              : When specified, dump transitions starting <low_year> (inclusive) up to
      *                <high_year> (exclusive).  The default values are 1902(low) and 2038(high).
      *      -d<dir> : When specified, write transitions in a file under the directory for each zone.
      *      -l<sep> : New line code type CR/LF/CRLF.
      */
     public static void main(String[] args) {
         boolean jdk = false;
         int low = 1902;
         int high = 2038;
         List idlist = new ArrayList();
         boolean all = false;
         String dir = null;
         String newLineMode = null;
         for (int i = 0; i < args.length; i++) {
             if (args[i].equals("-j")) {
                 jdk = true;
             } else if (args[i].startsWith("-c")) {
                 String val = args[i].substring(2);
                 String[] years = val.split(",");
                 if (years.length == 1) {
                     high = Integer.parseInt(years[0]);
                 } else if (years.length == 2) {
                     low = Integer.parseInt(years[0]);
                     high = Integer.parseInt(years[1]);
                 }
             } else if (args[i].equals("-a")) {
                 all = true;
             } else if (args[i].startsWith("-d")) {
                 dir = args[i].substring(2);
             } else if (args[i].startsWith("-l")) {
                 newLineMode = args[i].substring(2);
             } else if (!args[i].startsWith("-")){
                 idlist.add(args[i].trim());
             }
         }

         String lineSep = System.getProperty("line.separator");
         if (newLineMode != null && newLineMode.length() > 0) {
             if (newLineMode.equalsIgnoreCase("CR")) {
                 lineSep = "\r";
             } else if (newLineMode.equalsIgnoreCase("LF")) {
                 lineSep = "\n";
             } else if (newLineMode.equalsIgnoreCase("CRLF")) {
                 lineSep = "\r\n";
             }
         }

         String[] tzids = null;

         if (all) {
             if (jdk) {
                 tzids = java.util.TimeZone.getAvailableIDs();
             } else {
                 tzids = com.ibm.icu.util.TimeZone.getAvailableIDs();
             }

             // sort tzids
             TreeSet set = new TreeSet();
             for (int i = 0; i < tzids.length; i++) {
                 set.add(tzids[i]);
             }
             Iterator it = set.iterator();
             int i = 0;
             while (it.hasNext()) {
                 tzids[i++] = (String)it.next();
             }
         } else {
             int len = idlist.size();
             if (len == 0) {
                 tzids = new String[1];
                 tzids[0] = java.util.TimeZone.getDefault().getID();
             } else {
                 tzids = new String[idlist.size()];
                 idlist.toArray(tzids);
             }
         }

         File dirfile = null;
         if (dir == null || dir.length() == 0) {
             PrintWriter pw = new PrintWriter(System.out);
             try {
                 for (int i = 0; i < tzids.length; i++) {
                     if (i != 0) {
                         pw.println();
                     }
                     pw.write("ZONE: ");
                     pw.write(tzids[i]);
                     pw.println();
                     dumpZone(pw, lineSep, tzids[i], low, high, jdk);
                 }
                 pw.flush();
             } catch (IOException ioe) {
                 ioe.printStackTrace();
             }
         } else {
             dirfile = new File(dir);
             dirfile.mkdirs();

             try {
                 for (int i = 0; i < tzids.length; i++) {
                     FileOutputStream fos = new FileOutputStream(new File(dirfile, tzids[i].replace('/', '-')));
                     Writer w = new BufferedWriter(new OutputStreamWriter(fos));
                     dumpZone(w, lineSep, tzids[i], low, high, jdk);
                     w.close();
                 }
             } catch (IOException ioe) {
                 ioe.printStackTrace();
             }
         }
     }

     private static void dumpZone(Writer w, String lineSep, String tzid, int low, int high, boolean isJdk) throws IOException {
         ICUZDump dumper = new ICUZDump();
         Object tzimpl;
         if (isJdk) {
             tzimpl = java.util.TimeZone.getTimeZone(tzid);
         } else {
             tzimpl = com.ibm.icu.util.TimeZone.getTimeZone(tzid);
         }
         dumper.setTimeZone(tzimpl);
         dumper.setLowYear(low);
         dumper.setHighYear(high);
         dumper.setLineSeparator(lineSep);
         dumper.dump(w);
     }
 }
	/*
	***********************************************************************
	* Copyright (C) 2007, International Business Machines *
	* Corporation and others. All Rights Reserved. *
	***********************************************************************
	*
	*/

	package com.ibm.icu.dev.tool.timezone;

	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.OutputStreamWriter;
	import java.io.PrintWriter;
	import java.io.Writer;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Date;
	import java.util.Iterator;
	import java.util.List;
	import java.util.TreeSet;

	import com.ibm.icu.text.DecimalFormat;
	import com.ibm.icu.text.DecimalFormatSymbols;
	import com.ibm.icu.text.SimpleDateFormat;
	import com.ibm.icu.util.GregorianCalendar;
	import com.ibm.icu.util.SimpleTimeZone;
	import com.ibm.icu.util.ULocale;

	/**
	* TimeZone transition dump tool.
	*/
	public class ICUZDump {
	private static final String DEFAULT_LINE_SEP;

	static {
	String sep = System.getProperty("line.separator");
	DEFAULT_LINE_SEP = (sep == null) ? "\n" : sep;
	}

	private TimeZoneImpl tz = null;

	private int loyear = 1900;
	private int hiyear = 2050;
	private long tick = 1000;
	private DumpFormatter formatter;
	private String linesep = DEFAULT_LINE_SEP;

	public ICUZDump() {
	}

	public void setLowYear(int loyear) {
	this.loyear = loyear;
	}

	public void setHighYear(int hiyear) {
	this.hiyear = hiyear;
	}

	public void setTick(int tick) {
	if (tick <= 0) {
	throw new IllegalArgumentException("tick must be positive");
	}
	this.tick = tick;
	}

	public void setTimeZone(Object tzimpl) {
	this.tz = new TimeZoneImpl(tzimpl);
	}

	public void setDumpFormatter(DumpFormatter formatter) {
	this.formatter = formatter;
	}

	public void setLineSeparator(String sep) {
	this.linesep = sep;
	}

	public void dump(Writer w) throws IOException {
	if (tz == null) {
	throw new IllegalStateException("timezone is not initialized");
	}

	if (formatter == null) {
	formatter = new DumpFormatter();
	}

	final long SEARCH_INCREMENT = 12 * 60 * 60 * 1000; // half day
	long cutovers[] = getCutOverTimes();
	long t = cutovers[0];
	int offset = tz.getOffset(t);
	boolean inDst = tz.inDaylightTime(t);
	while (t < cutovers[1]) {
	long newt = t + SEARCH_INCREMENT;
	int newOffset = tz.getOffset(newt);
	boolean newInDst = tz.inDaylightTime(newt);
	if (offset != newOffset \|\| inDst != newInDst) {
	// find the boundary
	long lot = t;
	long hit = newt;
	while (true) {
	long diff = hit - lot;
	if (diff <= tick) {
	break;
	}
	long medt = lot + ((diff / 2) / tick) * tick;
	int medOffset = tz.getOffset(medt);
	boolean medInDst = tz.inDaylightTime(medt);
	if (medOffset != offset \|\| medInDst != inDst) {
	hit = medt;
	} else {
	lot = medt;
	}
	}
	w.write(formatter.format(lot, offset, tz.inDaylightTime(lot)));
	w.write(" > ");
	w.write(formatter.format(hit, newOffset, tz.inDaylightTime(hit)));
	w.write(linesep);
	offset = newOffset;
	inDst = newInDst;
	}
	t = newt;
	}

	}

	private long[] getCutOverTimes() {
	long[] cutovers = new long[2];
	cutovers[0] = tz.getTime(loyear, 0, 1, 0, 0, 0);
	cutovers[1] = tz.getTime(hiyear, 0, 1, 0, 0, 0);
	return cutovers;
	}

	private class TimeZoneImpl {
	private Object tzobj;

	public TimeZoneImpl(Object tzobj) {
	this.tzobj = tzobj;
	}

	public int getOffset(long time) {
	try {
	Method method = tzobj.getClass().getMethod("getOffset", new Class[] {long.class});
	Object result = method.invoke(tzobj, new Object[] {new Long(time)});
	return ((Integer)result).intValue();
	} catch (Exception e) {
	e.printStackTrace();
	}
	return 0;
	}

	public boolean inDaylightTime(long time) {
	try {
	Method method = tzobj.getClass().getMethod("inDaylightTime", new Class[] {Date.class});
	Object result = method.invoke(tzobj, new Object[] {new Date(time)});
	return ((Boolean)result).booleanValue();
	} catch (Exception e) {
	e.printStackTrace();
	}
	return false;
	}

	public long getTime(int year, int month, int dayOfMonth, int hour, int minute, int second) {
	long time;
	if (tzobj instanceof com.ibm.icu.util.TimeZone) {
	GregorianCalendar cal = new GregorianCalendar();
	cal.setTimeZone((com.ibm.icu.util.TimeZone)tzobj);
	cal.clear();
	cal.set(year, month, dayOfMonth, hour, minute, second);
	time = cal.getTimeInMillis();
	} else if (tzobj instanceof java.util.TimeZone) {
	java.util.GregorianCalendar cal = new java.util.GregorianCalendar();
	cal.setTimeZone((java.util.TimeZone)tzobj);
	cal.clear();
	cal.set(year, month, dayOfMonth, hour, minute, second);
	time = cal.getTimeInMillis();
	} else {
	throw new IllegalStateException("Unsupported TimeZone implementation");
	}
	return time;
	}
	}

	public class DumpFormatter {
	private SimpleTimeZone stz = new SimpleTimeZone(0, "");
	private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd EEE HH:mm:ss", ULocale.US);
	private DecimalFormat decf;

	public DumpFormatter() {
	DecimalFormatSymbols decfs = new DecimalFormatSymbols(ULocale.US);
	decf = new DecimalFormat("00", decfs);
	}

	public String format(long time, int offset, boolean isDst) {
	StringBuffer buf = new StringBuffer();
	stz.setRawOffset(offset);
	sdf.setTimeZone(stz);
	buf.append(sdf.format(new Date(time)));
	if (offset < 0) {
	buf.append("-");
	offset = -offset;
	} else {
	buf.append("+");
	}

	int hour, min, sec;

	offset /= 1000;
	sec = offset % 60;
	offset = (offset - sec) / 60;
	min = offset % 60;
	hour = offset / 60;

	buf.append(decf.format(hour));
	buf.append(decf.format(min));
	buf.append(decf.format(sec));

	buf.append("[DST=");
	buf.append(isDst ? "1" : "0");
	buf.append("]");
	return buf.toString();
	}
	}

	/*
	* Usage:
	*
	* java -cp icu4j.jar com.ibm.icu.dev.tool.timezone [-j] [-a] [-c[<low_year>,]<high_year>] [-d<dir>] [-l<sep>] [<zone_name> [<zone_name>]]
	*
	* Options:
	* -j : Use JDK TimeZone. By default, ICU TimeZone is used.
	* -a : Dump all available zones.
	* -c[<low_year>,]<high_year>
	* : When specified, dump transitions starting <low_year> (inclusive) up to
	* <high_year> (exclusive). The default values are 1902(low) and 2038(high).
	* -d<dir> : When specified, write transitions in a file under the directory for each zone.
	* -l<sep> : New line code type CR/LF/CRLF.
	*/
	public static void main(String[] args) {
	boolean jdk = false;
	int low = 1902;
	int high = 2038;
	List idlist = new ArrayList();
	boolean all = false;
	String dir = null;
	String newLineMode = null;
	for (int i = 0; i < args.length; i++) {
	if (args[i].equals("-j")) {
	jdk = true;
	} else if (args[i].startsWith("-c")) {
	String val = args[i].substring(2);
	String[] years = val.split(",");
	if (years.length == 1) {
	high = Integer.parseInt(years[0]);
	} else if (years.length == 2) {
	low = Integer.parseInt(years[0]);
	high = Integer.parseInt(years[1]);
	}
	} else if (args[i].equals("-a")) {
	all = true;
	} else if (args[i].startsWith("-d")) {
	dir = args[i].substring(2);
	} else if (args[i].startsWith("-l")) {
	newLineMode = args[i].substring(2);
	} else if (!args[i].startsWith("-")){
	idlist.add(args[i].trim());
	}
	}

	String lineSep = System.getProperty("line.separator");
	if (newLineMode != null && newLineMode.length() > 0) {
	if (newLineMode.equalsIgnoreCase("CR")) {
	lineSep = "\r";
	} else if (newLineMode.equalsIgnoreCase("LF")) {
	lineSep = "\n";
	} else if (newLineMode.equalsIgnoreCase("CRLF")) {
	lineSep = "\r\n";
	}
	}

	String[] tzids = null;

	if (all) {
	if (jdk) {
	tzids = java.util.TimeZone.getAvailableIDs();
	} else {
	tzids = com.ibm.icu.util.TimeZone.getAvailableIDs();
	}

	// sort tzids
	TreeSet set = new TreeSet();
	for (int i = 0; i < tzids.length; i++) {
	set.add(tzids[i]);
	}
	Iterator it = set.iterator();
	int i = 0;
	while (it.hasNext()) {
	tzids[i++] = (String)it.next();
	}
	} else {
	int len = idlist.size();
	if (len == 0) {
	tzids = new String[1];
	tzids[0] = java.util.TimeZone.getDefault().getID();
	} else {
	tzids = new String[idlist.size()];
	idlist.toArray(tzids);
	}
	}

	File dirfile = null;
	if (dir == null \|\| dir.length() == 0) {
	PrintWriter pw = new PrintWriter(System.out);
	try {
	for (int i = 0; i < tzids.length; i++) {
	if (i != 0) {
	pw.println();
	}
	pw.write("ZONE: ");
	pw.write(tzids[i]);
	pw.println();
	dumpZone(pw, lineSep, tzids[i], low, high, jdk);
	}
	pw.flush();
	} catch (IOException ioe) {
	ioe.printStackTrace();
	}
	} else {
	dirfile = new File(dir);
	dirfile.mkdirs();

	try {
	for (int i = 0; i < tzids.length; i++) {
	FileOutputStream fos = new FileOutputStream(new File(dirfile, tzids[i].replace('/', '-')));
	Writer w = new BufferedWriter(new OutputStreamWriter(fos));
	dumpZone(w, lineSep, tzids[i], low, high, jdk);
	w.close();
	}
	} catch (IOException ioe) {
	ioe.printStackTrace();
	}
	}
	}

	private static void dumpZone(Writer w, String lineSep, String tzid, int low, int high, boolean isJdk) throws IOException {
	ICUZDump dumper = new ICUZDump();
	Object tzimpl;
	if (isJdk) {
	tzimpl = java.util.TimeZone.getTimeZone(tzid);
	} else {
	tzimpl = com.ibm.icu.util.TimeZone.getTimeZone(tzid);
	}
	dumper.setTimeZone(tzimpl);
	dumper.setLowYear(low);
	dumper.setHighYear(high);
	dumper.setLineSeparator(lineSep);
	dumper.dump(w);
	}
	}