1 /*

     2  * Copyright (c) 2000, 2004, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 import java.io.BufferedReader;

    27 import java.io.FileReader;

    28 import java.io.FileNotFoundException;

    29 import java.io.IOException;

    30 import java.util.ArrayList;

    31 import java.util.HashMap;

    32 import java.util.HashSet;

    33 import java.util.List;

    34 import java.util.Map;

    35 import java.util.Set;

    36 import java.util.StringTokenizer;

    37 

    38 /**

    39  * ZoneRec hold information of time zone corresponding to each text

    40  * line of the "Zone" part.

    41  *

    42  * @since 1.4

    43  */

    44 class ZoneRec {

    45     private int gmtOffset;

    46     private String ruleName;

    47     private int directSave;

    48     private Rule ruleRef;

    49     private String format;

    50     private boolean hasUntil;

    51     private int untilYear;

    52     private Month untilMonth;

    53     private RuleDay untilDay;

    54     private Time untilTime;

    55     private long untilInMillis;

    56     private String line;

    57 

    58     /**

    59      * @return the "UNTIL" value in milliseconds

    60      */

    61     Time getUntilTime() {

    62         return untilTime;

    63     }

    64 

    65     /**

    66      * @return the GMT offset value in milliseconds

    67      */

    68     int getGmtOffset() {

    69         return gmtOffset;

    70     }

    71 

    72     /**

    73      * @return the rule name to which this zone record refers

    74      */

    75     String getRuleName() {

    76         return ruleName;

    77     }

    78 

    79     /**

    80      * @return the amount of saving time directly defined in the

    81      * "RULES/SAVE" field.

    82      */

    83     int getDirectSave() {

    84         return directSave;

    85     }

    86 

    87     /**

    88      * @return true if this zone record has a reference to a rule

    89      */

    90     boolean hasRuleReference() {

    91         return ruleRef != null;

    92     }

    93 

    94     /**

    95      * Returns the "FORMAT" field string of this zone record. This

    96      * @return the "FORMAT" field

    97      */

    98     String getFormat() {

    99         return format;

   100     }

   101 

   102     /**

   103      * @return the year in the "UNTIL" field

   104      */

   105     int getUntilYear() {

   106         return untilYear;

   107     }

   108 

   109     /**

   110      * Returns the "UNTIL" field value in milliseconds from Janurary

   111      * 1, 1970 0:00 GMT.

   112      * @param currentSave the amount of daylight saving in

   113      * milliseconds that is used to adjust wall-clock time.

   114      * @return the milliseconds value of the "UNTIL" field

   115      */

   116     long getUntilTime(int currentSave) {

   117         if (untilTime.isWall()) {

   118             return untilInMillis - currentSave;

   119         }

   120         return untilInMillis;

   121     }

   122 

   123     /**

   124      * Returns the "UNTIL" time in milliseconds without adjusting GMT

   125      * offsets or daylight saving.

   126      * @return local "UNTIL" time in milliseconds

   127      */

   128     long getLocalUntilTime() {

   129         return Time.getLocalTime(untilYear,

   130                                  untilMonth,

   131                                  untilDay,

   132                                  untilTime.getTime());

   133     }

   134 

   135     /**

   136      * Returns the "UNTIL" time in milliseconds with adjusting GMT offsets and daylight saving.

   137      * @return the "UNTIL" time after the adjustment

   138      */

   139     long getLocalUntilTime(int save, int gmtOffset) {

   140         return Time.getLocalTime(untilYear,

   141                                  untilMonth,

   142                                  untilDay,

   143                                  save,

   144                                  gmtOffset,

   145                                  untilTime);

   146     }

   147 

   148     /**

   149      * @return the text line of this zone record

   150      */

   151     String getLine() {

   152         return line;

   153     }

   154 

   155     /**

   156      * Sets the specified text line to this zone record

   157      */

   158     void setLine(String line) {

   159         this.line = line;

   160     }

   161 

   162     /**

   163      * @return true if this zone record has the "UNTIL" field

   164      */

   165     boolean hasUntil() {

   166         return this.hasUntil;

   167     }

   168 

   169     /**

   170      * Adjusts the "UNTIL" time to GMT offset if this zone record has

   171      * it.  <code>untilTime</code> is not adjusted to daylight saving

   172      * in this method.

   173      */

   174     void adjustTime() {

   175         if (!hasUntil()) {

   176             return;

   177         }

   178         if (untilTime.isSTD() || untilTime.isWall()) {

   179             // adjust to gmt offset only here.  adjust to real

   180             // wall-clock time when tracking rules

   181             untilInMillis -= gmtOffset;

   182         }

   183     }

   184 

   185     /**

   186      * @return the reference to the Rule object

   187      */

   188     Rule getRuleRef() {

   189         return ruleRef;

   190     }

   191 

   192     /**

   193      * Resolves the reference to a Rule and adjusts its "UNTIL" time

   194      * to GMT offset.

   195      */

   196     void resolve(Zoneinfo zi) {

   197         if (ruleName != null && (!"-".equals(ruleName))) {

   198                 ruleRef = zi.getRule(ruleName);

   199         }

   200         adjustTime();

   201     }

   202 

   203     /**

   204      * Parses a Zone text line that is described by a StringTokenizer.

   205      * @param tokens represents tokens of a Zone text line

   206      * @return the zone record produced by parsing the text

   207      */

   208     static ZoneRec parse(StringTokenizer tokens) {

   209         ZoneRec rec = new ZoneRec();

   210         try {

   211             rec.gmtOffset = (int) Time.parse(tokens.nextToken()).getTime();

   212             String token = tokens.nextToken();

   213             char c = token.charAt(0);

   214             if (c >= '0' && c <= '9') {

   215                 rec.directSave = (int) Time.parse(token).getTime();

   216             } else {

   217                 rec.ruleName = token;

   218             }

   219             rec.format = tokens.nextToken();

   220             if (tokens.hasMoreTokens()) {

   221                 rec.hasUntil = true;

   222                 rec.untilYear = Integer.parseInt(tokens.nextToken());

   223                 if (tokens.hasMoreTokens()) {

   224                     rec.untilMonth = Month.parse(tokens.nextToken());

   225                 } else {

   226                     rec.untilMonth = Month.JANUARY;

   227                 }

   228                 if (tokens.hasMoreTokens()) {

   229                     rec.untilDay = RuleDay.parse(tokens.nextToken());

   230                 } else {

   231                     rec.untilDay = new RuleDay(1);

   232                 }

   233                 if (tokens.hasMoreTokens()) {

   234                     rec.untilTime = Time.parse(tokens.nextToken());

   235                 } else {

   236                     rec.untilTime = Time.parse("0:00");

   237                 }

   238                 rec.untilInMillis = rec.getLocalUntilTime();

   239             }

   240         } catch (Exception e) {

   241             // TODO: error reporting

   242             e.printStackTrace();

   243         }

   244         return rec;

   245     }

   246 

   247     private static void panic(String msg) {

   248         Main.panic(msg);

   249     }

   250 }