Home | History | Annotate | Download | only in calendarcommon
      1 /*
      2  * Copyright (C) 2006 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.calendarcommon;
     18 
     19 import android.text.TextUtils;
     20 import android.text.format.Time;
     21 import android.util.Log;
     22 import android.util.TimeFormatException;
     23 
     24 import java.util.Calendar;
     25 import java.util.HashMap;
     26 
     27 /**
     28  * Event recurrence utility functions.
     29  */
     30 public class EventRecurrence {
     31     private static String TAG = "EventRecur";
     32 
     33     public static final int SECONDLY = 1;
     34     public static final int MINUTELY = 2;
     35     public static final int HOURLY = 3;
     36     public static final int DAILY = 4;
     37     public static final int WEEKLY = 5;
     38     public static final int MONTHLY = 6;
     39     public static final int YEARLY = 7;
     40 
     41     public static final int SU = 0x00010000;
     42     public static final int MO = 0x00020000;
     43     public static final int TU = 0x00040000;
     44     public static final int WE = 0x00080000;
     45     public static final int TH = 0x00100000;
     46     public static final int FR = 0x00200000;
     47     public static final int SA = 0x00400000;
     48 
     49     public Time      startDate;     // set by setStartDate(), not parse()
     50 
     51     public int       freq;          // SECONDLY, MINUTELY, etc.
     52     public String    until;
     53     public int       count;
     54     public int       interval;
     55     public int       wkst;          // SU, MO, TU, etc.
     56 
     57     /* lists with zero entries may be null references */
     58     public int[]     bysecond;
     59     public int       bysecondCount;
     60     public int[]     byminute;
     61     public int       byminuteCount;
     62     public int[]     byhour;
     63     public int       byhourCount;
     64     public int[]     byday;
     65     public int[]     bydayNum;
     66     public int       bydayCount;
     67     public int[]     bymonthday;
     68     public int       bymonthdayCount;
     69     public int[]     byyearday;
     70     public int       byyeardayCount;
     71     public int[]     byweekno;
     72     public int       byweeknoCount;
     73     public int[]     bymonth;
     74     public int       bymonthCount;
     75     public int[]     bysetpos;
     76     public int       bysetposCount;
     77 
     78     /** maps a part string to a parser object */
     79     private static HashMap<String,PartParser> sParsePartMap;
     80     static {
     81         sParsePartMap = new HashMap<String,PartParser>();
     82         sParsePartMap.put("FREQ", new ParseFreq());
     83         sParsePartMap.put("UNTIL", new ParseUntil());
     84         sParsePartMap.put("COUNT", new ParseCount());
     85         sParsePartMap.put("INTERVAL", new ParseInterval());
     86         sParsePartMap.put("BYSECOND", new ParseBySecond());
     87         sParsePartMap.put("BYMINUTE", new ParseByMinute());
     88         sParsePartMap.put("BYHOUR", new ParseByHour());
     89         sParsePartMap.put("BYDAY", new ParseByDay());
     90         sParsePartMap.put("BYMONTHDAY", new ParseByMonthDay());
     91         sParsePartMap.put("BYYEARDAY", new ParseByYearDay());
     92         sParsePartMap.put("BYWEEKNO", new ParseByWeekNo());
     93         sParsePartMap.put("BYMONTH", new ParseByMonth());
     94         sParsePartMap.put("BYSETPOS", new ParseBySetPos());
     95         sParsePartMap.put("WKST", new ParseWkst());
     96     }
     97 
     98     /* values for bit vector that keeps track of what we have already seen */
     99     private static final int PARSED_FREQ = 1 << 0;
    100     private static final int PARSED_UNTIL = 1 << 1;
    101     private static final int PARSED_COUNT = 1 << 2;
    102     private static final int PARSED_INTERVAL = 1 << 3;
    103     private static final int PARSED_BYSECOND = 1 << 4;
    104     private static final int PARSED_BYMINUTE = 1 << 5;
    105     private static final int PARSED_BYHOUR = 1 << 6;
    106     private static final int PARSED_BYDAY = 1 << 7;
    107     private static final int PARSED_BYMONTHDAY = 1 << 8;
    108     private static final int PARSED_BYYEARDAY = 1 << 9;
    109     private static final int PARSED_BYWEEKNO = 1 << 10;
    110     private static final int PARSED_BYMONTH = 1 << 11;
    111     private static final int PARSED_BYSETPOS = 1 << 12;
    112     private static final int PARSED_WKST = 1 << 13;
    113 
    114     /** maps a FREQ value to an integer constant */
    115     private static final HashMap<String,Integer> sParseFreqMap = new HashMap<String,Integer>();
    116     static {
    117         sParseFreqMap.put("SECONDLY", SECONDLY);
    118         sParseFreqMap.put("MINUTELY", MINUTELY);
    119         sParseFreqMap.put("HOURLY", HOURLY);
    120         sParseFreqMap.put("DAILY", DAILY);
    121         sParseFreqMap.put("WEEKLY", WEEKLY);
    122         sParseFreqMap.put("MONTHLY", MONTHLY);
    123         sParseFreqMap.put("YEARLY", YEARLY);
    124     }
    125 
    126     /** maps a two-character weekday string to an integer constant */
    127     private static final HashMap<String,Integer> sParseWeekdayMap = new HashMap<String,Integer>();
    128     static {
    129         sParseWeekdayMap.put("SU", SU);
    130         sParseWeekdayMap.put("MO", MO);
    131         sParseWeekdayMap.put("TU", TU);
    132         sParseWeekdayMap.put("WE", WE);
    133         sParseWeekdayMap.put("TH", TH);
    134         sParseWeekdayMap.put("FR", FR);
    135         sParseWeekdayMap.put("SA", SA);
    136     }
    137 
    138     /** If set, allow lower-case recurrence rule strings.  Minor performance impact. */
    139     private static final boolean ALLOW_LOWER_CASE = true;
    140 
    141     /** If set, validate the value of UNTIL parts.  Minor performance impact. */
    142     private static final boolean VALIDATE_UNTIL = false;
    143 
    144     /** If set, require that only one of {UNTIL,COUNT} is present.  Breaks compat w/ old parser. */
    145     private static final boolean ONLY_ONE_UNTIL_COUNT = false;
    146 
    147 
    148     /**
    149      * Thrown when a recurrence string provided can not be parsed according
    150      * to RFC2445.
    151      */
    152     public static class InvalidFormatException extends RuntimeException {
    153         InvalidFormatException(String s) {
    154             super(s);
    155         }
    156     }
    157 
    158 
    159     public void setStartDate(Time date) {
    160         startDate = date;
    161     }
    162 
    163     /**
    164      * Converts one of the Calendar.SUNDAY constants to the SU, MO, etc.
    165      * constants.  btw, I think we should switch to those here too, to
    166      * get rid of this function, if possible.
    167      */
    168     public static int calendarDay2Day(int day)
    169     {
    170         switch (day)
    171         {
    172             case Calendar.SUNDAY:
    173                 return SU;
    174             case Calendar.MONDAY:
    175                 return MO;
    176             case Calendar.TUESDAY:
    177                 return TU;
    178             case Calendar.WEDNESDAY:
    179                 return WE;
    180             case Calendar.THURSDAY:
    181                 return TH;
    182             case Calendar.FRIDAY:
    183                 return FR;
    184             case Calendar.SATURDAY:
    185                 return SA;
    186             default:
    187                 throw new RuntimeException("bad day of week: " + day);
    188         }
    189     }
    190 
    191     public static int timeDay2Day(int day)
    192     {
    193         switch (day)
    194         {
    195             case Time.SUNDAY:
    196                 return SU;
    197             case Time.MONDAY:
    198                 return MO;
    199             case Time.TUESDAY:
    200                 return TU;
    201             case Time.WEDNESDAY:
    202                 return WE;
    203             case Time.THURSDAY:
    204                 return TH;
    205             case Time.FRIDAY:
    206                 return FR;
    207             case Time.SATURDAY:
    208                 return SA;
    209             default:
    210                 throw new RuntimeException("bad day of week: " + day);
    211         }
    212     }
    213     public static int day2TimeDay(int day)
    214     {
    215         switch (day)
    216         {
    217             case SU:
    218                 return Time.SUNDAY;
    219             case MO:
    220                 return Time.MONDAY;
    221             case TU:
    222                 return Time.TUESDAY;
    223             case WE:
    224                 return Time.WEDNESDAY;
    225             case TH:
    226                 return Time.THURSDAY;
    227             case FR:
    228                 return Time.FRIDAY;
    229             case SA:
    230                 return Time.SATURDAY;
    231             default:
    232                 throw new RuntimeException("bad day of week: " + day);
    233         }
    234     }
    235 
    236     /**
    237      * Converts one of the SU, MO, etc. constants to the Calendar.SUNDAY
    238      * constants.  btw, I think we should switch to those here too, to
    239      * get rid of this function, if possible.
    240      */
    241     public static int day2CalendarDay(int day)
    242     {
    243         switch (day)
    244         {
    245             case SU:
    246                 return Calendar.SUNDAY;
    247             case MO:
    248                 return Calendar.MONDAY;
    249             case TU:
    250                 return Calendar.TUESDAY;
    251             case WE:
    252                 return Calendar.WEDNESDAY;
    253             case TH:
    254                 return Calendar.THURSDAY;
    255             case FR:
    256                 return Calendar.FRIDAY;
    257             case SA:
    258                 return Calendar.SATURDAY;
    259             default:
    260                 throw new RuntimeException("bad day of week: " + day);
    261         }
    262     }
    263 
    264     /**
    265      * Converts one of the internal day constants (SU, MO, etc.) to the
    266      * two-letter string representing that constant.
    267      *
    268      * @param day one the internal constants SU, MO, etc.
    269      * @return the two-letter string for the day ("SU", "MO", etc.)
    270      *
    271      * @throws IllegalArgumentException Thrown if the day argument is not one of
    272      * the defined day constants.
    273      */
    274     private static String day2String(int day) {
    275         switch (day) {
    276         case SU:
    277             return "SU";
    278         case MO:
    279             return "MO";
    280         case TU:
    281             return "TU";
    282         case WE:
    283             return "WE";
    284         case TH:
    285             return "TH";
    286         case FR:
    287             return "FR";
    288         case SA:
    289             return "SA";
    290         default:
    291             throw new IllegalArgumentException("bad day argument: " + day);
    292         }
    293     }
    294 
    295     private static void appendNumbers(StringBuilder s, String label,
    296                                         int count, int[] values)
    297     {
    298         if (count > 0) {
    299             s.append(label);
    300             count--;
    301             for (int i=0; i<count; i++) {
    302                 s.append(values[i]);
    303                 s.append(",");
    304             }
    305             s.append(values[count]);
    306         }
    307     }
    308 
    309     private void appendByDay(StringBuilder s, int i)
    310     {
    311         int n = this.bydayNum[i];
    312         if (n != 0) {
    313             s.append(n);
    314         }
    315 
    316         String str = day2String(this.byday[i]);
    317         s.append(str);
    318     }
    319 
    320     @Override
    321     public String toString()
    322     {
    323         StringBuilder s = new StringBuilder();
    324 
    325         s.append("FREQ=");
    326         switch (this.freq)
    327         {
    328             case SECONDLY:
    329                 s.append("SECONDLY");
    330                 break;
    331             case MINUTELY:
    332                 s.append("MINUTELY");
    333                 break;
    334             case HOURLY:
    335                 s.append("HOURLY");
    336                 break;
    337             case DAILY:
    338                 s.append("DAILY");
    339                 break;
    340             case WEEKLY:
    341                 s.append("WEEKLY");
    342                 break;
    343             case MONTHLY:
    344                 s.append("MONTHLY");
    345                 break;
    346             case YEARLY:
    347                 s.append("YEARLY");
    348                 break;
    349         }
    350 
    351         if (!TextUtils.isEmpty(this.until)) {
    352             s.append(";UNTIL=");
    353             s.append(until);
    354         }
    355 
    356         if (this.count != 0) {
    357             s.append(";COUNT=");
    358             s.append(this.count);
    359         }
    360 
    361         if (this.interval != 0) {
    362             s.append(";INTERVAL=");
    363             s.append(this.interval);
    364         }
    365 
    366         if (this.wkst != 0) {
    367             s.append(";WKST=");
    368             s.append(day2String(this.wkst));
    369         }
    370 
    371         appendNumbers(s, ";BYSECOND=", this.bysecondCount, this.bysecond);
    372         appendNumbers(s, ";BYMINUTE=", this.byminuteCount, this.byminute);
    373         appendNumbers(s, ";BYSECOND=", this.byhourCount, this.byhour);
    374 
    375         // day
    376         int count = this.bydayCount;
    377         if (count > 0) {
    378             s.append(";BYDAY=");
    379             count--;
    380             for (int i=0; i<count; i++) {
    381                 appendByDay(s, i);
    382                 s.append(",");
    383             }
    384             appendByDay(s, count);
    385         }
    386 
    387         appendNumbers(s, ";BYMONTHDAY=", this.bymonthdayCount, this.bymonthday);
    388         appendNumbers(s, ";BYYEARDAY=", this.byyeardayCount, this.byyearday);
    389         appendNumbers(s, ";BYWEEKNO=", this.byweeknoCount, this.byweekno);
    390         appendNumbers(s, ";BYMONTH=", this.bymonthCount, this.bymonth);
    391         appendNumbers(s, ";BYSETPOS=", this.bysetposCount, this.bysetpos);
    392 
    393         return s.toString();
    394     }
    395 
    396     public boolean repeatsOnEveryWeekDay() {
    397         if (this.freq != WEEKLY) {
    398             return false;
    399         }
    400 
    401         int count = this.bydayCount;
    402         if (count != 5) {
    403             return false;
    404         }
    405 
    406         for (int i = 0 ; i < count ; i++) {
    407             int day = byday[i];
    408             if (day == SU || day == SA) {
    409                 return false;
    410             }
    411         }
    412 
    413         return true;
    414     }
    415 
    416     /**
    417      * Determines whether this rule specifies a simple monthly rule by weekday, such as
    418      * "FREQ=MONTHLY;BYDAY=3TU" (the 3rd Tuesday of every month).
    419      * <p>
    420      * Negative days, e.g. "FREQ=MONTHLY;BYDAY=-1TU" (the last Tuesday of every month),
    421      * will cause "false" to be returned.
    422      * <p>
    423      * Rules that fire every week, such as "FREQ=MONTHLY;BYDAY=TU" (every Tuesday of every
    424      * month) will cause "false" to be returned.  (Note these are usually expressed as
    425      * WEEKLY rules, and hence are uncommon.)
    426      *
    427      * @return true if this rule is of the appropriate form
    428      */
    429     public boolean repeatsMonthlyOnDayCount() {
    430         if (this.freq != MONTHLY) {
    431             return false;
    432         }
    433 
    434         if (bydayCount != 1 || bymonthdayCount != 0) {
    435             return false;
    436         }
    437 
    438         if (bydayNum[0] <= 0) {
    439             return false;
    440         }
    441 
    442         return true;
    443     }
    444 
    445     /**
    446      * Determines whether two integer arrays contain identical elements.
    447      * <p>
    448      * The native implementation over-allocated the arrays (and may have stuff left over from
    449      * a previous run), so we can't just check the arrays -- the separately-maintained count
    450      * field also matters.  We assume that a null array will have a count of zero, and that the
    451      * array can hold as many elements as the associated count indicates.
    452      * <p>
    453      * TODO: replace this with Arrays.equals() when the old parser goes away.
    454      */
    455     private static boolean arraysEqual(int[] array1, int count1, int[] array2, int count2) {
    456         if (count1 != count2) {
    457             return false;
    458         }
    459 
    460         for (int i = 0; i < count1; i++) {
    461             if (array1[i] != array2[i])
    462                 return false;
    463         }
    464 
    465         return true;
    466     }
    467 
    468     @Override
    469     public boolean equals(Object obj) {
    470         if (this == obj) {
    471             return true;
    472         }
    473         if (!(obj instanceof EventRecurrence)) {
    474             return false;
    475         }
    476 
    477         EventRecurrence er = (EventRecurrence) obj;
    478         return  (startDate == null ?
    479                         er.startDate == null : Time.compare(startDate, er.startDate) == 0) &&
    480                 freq == er.freq &&
    481                 (until == null ? er.until == null : until.equals(er.until)) &&
    482                 count == er.count &&
    483                 interval == er.interval &&
    484                 wkst == er.wkst &&
    485                 arraysEqual(bysecond, bysecondCount, er.bysecond, er.bysecondCount) &&
    486                 arraysEqual(byminute, byminuteCount, er.byminute, er.byminuteCount) &&
    487                 arraysEqual(byhour, byhourCount, er.byhour, er.byhourCount) &&
    488                 arraysEqual(byday, bydayCount, er.byday, er.bydayCount) &&
    489                 arraysEqual(bydayNum, bydayCount, er.bydayNum, er.bydayCount) &&
    490                 arraysEqual(bymonthday, bymonthdayCount, er.bymonthday, er.bymonthdayCount) &&
    491                 arraysEqual(byyearday, byyeardayCount, er.byyearday, er.byyeardayCount) &&
    492                 arraysEqual(byweekno, byweeknoCount, er.byweekno, er.byweeknoCount) &&
    493                 arraysEqual(bymonth, bymonthCount, er.bymonth, er.bymonthCount) &&
    494                 arraysEqual(bysetpos, bysetposCount, er.bysetpos, er.bysetposCount);
    495     }
    496 
    497     @Override public int hashCode() {
    498         // We overrode equals, so we must override hashCode().  Nobody seems to need this though.
    499         throw new UnsupportedOperationException();
    500     }
    501 
    502     /**
    503      * Resets parser-modified fields to their initial state.  Does not alter startDate.
    504      * <p>
    505      * The original parser always set all of the "count" fields, "wkst", and "until",
    506      * essentially allowing the same object to be used multiple times by calling parse().
    507      * It's unclear whether this behavior was intentional.  For now, be paranoid and
    508      * preserve the existing behavior by resetting the fields.
    509      * <p>
    510      * We don't need to touch the integer arrays; they will either be ignored or
    511      * overwritten.  The "startDate" field is not set by the parser, so we ignore it here.
    512      */
    513     private void resetFields() {
    514         until = null;
    515         freq = count = interval = bysecondCount = byminuteCount = byhourCount =
    516             bydayCount = bymonthdayCount = byyeardayCount = byweeknoCount = bymonthCount =
    517             bysetposCount = 0;
    518     }
    519 
    520     /**
    521      * Parses an rfc2445 recurrence rule string into its component pieces.  Attempting to parse
    522      * malformed input will result in an EventRecurrence.InvalidFormatException.
    523      *
    524      * @param recur The recurrence rule to parse (in un-folded form).
    525      */
    526     public void parse(String recur) {
    527         /*
    528          * From RFC 2445 section 4.3.10:
    529          *
    530          * recur = "FREQ"=freq *(
    531          *       ; either UNTIL or COUNT may appear in a 'recur',
    532          *       ; but UNTIL and COUNT MUST NOT occur in the same 'recur'
    533          *
    534          *       ( ";" "UNTIL" "=" enddate ) /
    535          *       ( ";" "COUNT" "=" 1*DIGIT ) /
    536          *
    537          *       ; the rest of these keywords are optional,
    538          *       ; but MUST NOT occur more than once
    539          *
    540          *       ( ";" "INTERVAL" "=" 1*DIGIT )          /
    541          *       ( ";" "BYSECOND" "=" byseclist )        /
    542          *       ( ";" "BYMINUTE" "=" byminlist )        /
    543          *       ( ";" "BYHOUR" "=" byhrlist )           /
    544          *       ( ";" "BYDAY" "=" bywdaylist )          /
    545          *       ( ";" "BYMONTHDAY" "=" bymodaylist )    /
    546          *       ( ";" "BYYEARDAY" "=" byyrdaylist )     /
    547          *       ( ";" "BYWEEKNO" "=" bywknolist )       /
    548          *       ( ";" "BYMONTH" "=" bymolist )          /
    549          *       ( ";" "BYSETPOS" "=" bysplist )         /
    550          *       ( ";" "WKST" "=" weekday )              /
    551          *       ( ";" x-name "=" text )
    552          *       )
    553          *
    554          *  The rule parts are not ordered in any particular sequence.
    555          *
    556          * Examples:
    557          *   FREQ=MONTHLY;INTERVAL=2;COUNT=10;BYDAY=1SU,-1SU
    558          *   FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8
    559          *
    560          * Strategy:
    561          * (1) Split the string at ';' boundaries to get an array of rule "parts".
    562          * (2) For each part, find substrings for left/right sides of '=' (name/value).
    563          * (3) Call a <name>-specific parsing function to parse the <value> into an
    564          *     output field.
    565          *
    566          * By keeping track of which names we've seen in a bit vector, we can verify the
    567          * constraints indicated above (FREQ appears first, none of them appear more than once --
    568          * though x-[name] would require special treatment), and we have either UNTIL or COUNT
    569          * but not both.
    570          *
    571          * In general, RFC 2445 property names (e.g. "FREQ") and enumerations ("TU") must
    572          * be handled in a case-insensitive fashion, but case may be significant for other
    573          * properties.  We don't have any case-sensitive values in RRULE, except possibly
    574          * for the custom "X-" properties, but we ignore those anyway.  Thus, we can trivially
    575          * convert the entire string to upper case and then use simple comparisons.
    576          *
    577          * Differences from previous version:
    578          * - allows lower-case property and enumeration values [optional]
    579          * - enforces that FREQ appears first
    580          * - enforces that only one of UNTIL and COUNT may be specified
    581          * - allows (but ignores) X-* parts
    582          * - improved validation on various values (e.g. UNTIL timestamps)
    583          * - error messages are more specific
    584          *
    585          * TODO: enforce additional constraints listed in RFC 5545, notably the "N/A" entries
    586          * in section 3.3.10.  For example, if FREQ=WEEKLY, we should reject a rule that
    587          * includes a BYMONTHDAY part.
    588          */
    589 
    590         /* TODO: replace with "if (freq != 0) throw" if nothing requires this */
    591         resetFields();
    592 
    593         int parseFlags = 0;
    594         String[] parts;
    595         if (ALLOW_LOWER_CASE) {
    596             parts = recur.toUpperCase().split(";");
    597         } else {
    598             parts = recur.split(";");
    599         }
    600         for (String part : parts) {
    601             // allow empty part (e.g., double semicolon ";;")
    602             if (TextUtils.isEmpty(part)) {
    603                 continue;
    604             }
    605             int equalIndex = part.indexOf('=');
    606             if (equalIndex <= 0) {
    607                 /* no '=' or no LHS */
    608                 throw new InvalidFormatException("Missing LHS in " + part);
    609             }
    610 
    611             String lhs = part.substring(0, equalIndex);
    612             String rhs = part.substring(equalIndex + 1);
    613             if (rhs.length() == 0) {
    614                 throw new InvalidFormatException("Missing RHS in " + part);
    615             }
    616 
    617             /*
    618              * In lieu of a "switch" statement that allows string arguments, we use a
    619              * map from strings to parsing functions.
    620              */
    621             PartParser parser = sParsePartMap.get(lhs);
    622             if (parser == null) {
    623                 if (lhs.startsWith("X-")) {
    624                     //Log.d(TAG, "Ignoring custom part " + lhs);
    625                     continue;
    626                 }
    627                 throw new InvalidFormatException("Couldn't find parser for " + lhs);
    628             } else {
    629                 int flag = parser.parsePart(rhs, this);
    630                 if ((parseFlags & flag) != 0) {
    631                     throw new InvalidFormatException("Part " + lhs + " was specified twice");
    632                 }
    633                 parseFlags |= flag;
    634             }
    635         }
    636 
    637         // If not specified, week starts on Monday.
    638         if ((parseFlags & PARSED_WKST) == 0) {
    639             wkst = MO;
    640         }
    641 
    642         // FREQ is mandatory.
    643         if ((parseFlags & PARSED_FREQ) == 0) {
    644             throw new InvalidFormatException("Must specify a FREQ value");
    645         }
    646 
    647         // Can't have both UNTIL and COUNT.
    648         if ((parseFlags & (PARSED_UNTIL | PARSED_COUNT)) == (PARSED_UNTIL | PARSED_COUNT)) {
    649             if (ONLY_ONE_UNTIL_COUNT) {
    650                 throw new InvalidFormatException("Must not specify both UNTIL and COUNT: " + recur);
    651             } else {
    652                 Log.w(TAG, "Warning: rrule has both UNTIL and COUNT: " + recur);
    653             }
    654         }
    655     }
    656 
    657     /**
    658      * Base class for the RRULE part parsers.
    659      */
    660     abstract static class PartParser {
    661         /**
    662          * Parses a single part.
    663          *
    664          * @param value The right-hand-side of the part.
    665          * @param er The EventRecurrence into which the result is stored.
    666          * @return A bit value indicating which part was parsed.
    667          */
    668         public abstract int parsePart(String value, EventRecurrence er);
    669 
    670         /**
    671          * Parses an integer, with range-checking.
    672          *
    673          * @param str The string to parse.
    674          * @param minVal Minimum allowed value.
    675          * @param maxVal Maximum allowed value.
    676          * @param allowZero Is 0 allowed?
    677          * @return The parsed value.
    678          */
    679         public static int parseIntRange(String str, int minVal, int maxVal, boolean allowZero) {
    680             try {
    681                 if (str.charAt(0) == '+') {
    682                     // Integer.parseInt does not allow a leading '+', so skip it manually.
    683                     str = str.substring(1);
    684                 }
    685                 int val = Integer.parseInt(str);
    686                 if (val < minVal || val > maxVal || (val == 0 && !allowZero)) {
    687                     throw new InvalidFormatException("Integer value out of range: " + str);
    688                 }
    689                 return val;
    690             } catch (NumberFormatException nfe) {
    691                 throw new InvalidFormatException("Invalid integer value: " + str);
    692             }
    693         }
    694 
    695         /**
    696          * Parses a comma-separated list of integers, with range-checking.
    697          *
    698          * @param listStr The string to parse.
    699          * @param minVal Minimum allowed value.
    700          * @param maxVal Maximum allowed value.
    701          * @param allowZero Is 0 allowed?
    702          * @return A new array with values, sized to hold the exact number of elements.
    703          */
    704         public static int[] parseNumberList(String listStr, int minVal, int maxVal,
    705                 boolean allowZero) {
    706             int[] values;
    707 
    708             if (listStr.indexOf(",") < 0) {
    709                 // Common case: only one entry, skip split() overhead.
    710                 values = new int[1];
    711                 values[0] = parseIntRange(listStr, minVal, maxVal, allowZero);
    712             } else {
    713                 String[] valueStrs = listStr.split(",");
    714                 int len = valueStrs.length;
    715                 values = new int[len];
    716                 for (int i = 0; i < len; i++) {
    717                     values[i] = parseIntRange(valueStrs[i], minVal, maxVal, allowZero);
    718                 }
    719             }
    720             return values;
    721         }
    722    }
    723 
    724     /** parses FREQ={SECONDLY,MINUTELY,...} */
    725     private static class ParseFreq extends PartParser {
    726         @Override public int parsePart(String value, EventRecurrence er) {
    727             Integer freq = sParseFreqMap.get(value);
    728             if (freq == null) {
    729                 throw new InvalidFormatException("Invalid FREQ value: " + value);
    730             }
    731             er.freq = freq;
    732             return PARSED_FREQ;
    733         }
    734     }
    735     /** parses UNTIL=enddate, e.g. "19970829T021400" */
    736     private static class ParseUntil extends PartParser {
    737         @Override public int parsePart(String value, EventRecurrence er) {
    738             if (VALIDATE_UNTIL) {
    739                 try {
    740                     // Parse the time to validate it.  The result isn't retained.
    741                     Time until = new Time();
    742                     until.parse(value);
    743                 } catch (TimeFormatException tfe) {
    744                     throw new InvalidFormatException("Invalid UNTIL value: " + value);
    745                 }
    746             }
    747             er.until = value;
    748             return PARSED_UNTIL;
    749         }
    750     }
    751     /** parses COUNT=[non-negative-integer] */
    752     private static class ParseCount extends PartParser {
    753         @Override public int parsePart(String value, EventRecurrence er) {
    754             er.count = parseIntRange(value, Integer.MIN_VALUE, Integer.MAX_VALUE, true);
    755             if (er.count < 0) {
    756                 Log.d(TAG, "Invalid Count. Forcing COUNT to 1 from " + value);
    757                 er.count = 1; // invalid count. assume one time recurrence.
    758             }
    759             return PARSED_COUNT;
    760         }
    761     }
    762     /** parses INTERVAL=[non-negative-integer] */
    763     private static class ParseInterval extends PartParser {
    764         @Override public int parsePart(String value, EventRecurrence er) {
    765             er.interval = parseIntRange(value, Integer.MIN_VALUE, Integer.MAX_VALUE, true);
    766             if (er.interval < 1) {
    767                 Log.d(TAG, "Invalid Interval. Forcing INTERVAL to 1 from " + value);
    768                 er.interval = 1;
    769             }
    770             return PARSED_INTERVAL;
    771         }
    772     }
    773     /** parses BYSECOND=byseclist */
    774     private static class ParseBySecond extends PartParser {
    775         @Override public int parsePart(String value, EventRecurrence er) {
    776             int[] bysecond = parseNumberList(value, 0, 59, true);
    777             er.bysecond = bysecond;
    778             er.bysecondCount = bysecond.length;
    779             return PARSED_BYSECOND;
    780         }
    781     }
    782     /** parses BYMINUTE=byminlist */
    783     private static class ParseByMinute extends PartParser {
    784         @Override public int parsePart(String value, EventRecurrence er) {
    785             int[] byminute = parseNumberList(value, 0, 59, true);
    786             er.byminute = byminute;
    787             er.byminuteCount = byminute.length;
    788             return PARSED_BYMINUTE;
    789         }
    790     }
    791     /** parses BYHOUR=byhrlist */
    792     private static class ParseByHour extends PartParser {
    793         @Override public int parsePart(String value, EventRecurrence er) {
    794             int[] byhour = parseNumberList(value, 0, 23, true);
    795             er.byhour = byhour;
    796             er.byhourCount = byhour.length;
    797             return PARSED_BYHOUR;
    798         }
    799     }
    800     /** parses BYDAY=bywdaylist, e.g. "1SU,-1SU" */
    801     private static class ParseByDay extends PartParser {
    802         @Override public int parsePart(String value, EventRecurrence er) {
    803             int[] byday;
    804             int[] bydayNum;
    805             int bydayCount;
    806 
    807             if (value.indexOf(",") < 0) {
    808                 /* only one entry, skip split() overhead */
    809                 bydayCount = 1;
    810                 byday = new int[1];
    811                 bydayNum = new int[1];
    812                 parseWday(value, byday, bydayNum, 0);
    813             } else {
    814                 String[] wdays = value.split(",");
    815                 int len = wdays.length;
    816                 bydayCount = len;
    817                 byday = new int[len];
    818                 bydayNum = new int[len];
    819                 for (int i = 0; i < len; i++) {
    820                     parseWday(wdays[i], byday, bydayNum, i);
    821                 }
    822             }
    823             er.byday = byday;
    824             er.bydayNum = bydayNum;
    825             er.bydayCount = bydayCount;
    826             return PARSED_BYDAY;
    827         }
    828 
    829         /** parses [int]weekday, putting the pieces into parallel array entries */
    830         private static void parseWday(String str, int[] byday, int[] bydayNum, int index) {
    831             int wdayStrStart = str.length() - 2;
    832             String wdayStr;
    833 
    834             if (wdayStrStart > 0) {
    835                 /* number is included; parse it out and advance to weekday */
    836                 String numPart = str.substring(0, wdayStrStart);
    837                 int num = parseIntRange(numPart, -53, 53, false);
    838                 bydayNum[index] = num;
    839                 wdayStr = str.substring(wdayStrStart);
    840             } else {
    841                 /* just the weekday string */
    842                 wdayStr = str;
    843             }
    844             Integer wday = sParseWeekdayMap.get(wdayStr);
    845             if (wday == null) {
    846                 throw new InvalidFormatException("Invalid BYDAY value: " + str);
    847             }
    848             byday[index] = wday;
    849         }
    850     }
    851     /** parses BYMONTHDAY=bymodaylist */
    852     private static class ParseByMonthDay extends PartParser {
    853         @Override public int parsePart(String value, EventRecurrence er) {
    854             int[] bymonthday = parseNumberList(value, -31, 31, false);
    855             er.bymonthday = bymonthday;
    856             er.bymonthdayCount = bymonthday.length;
    857             return PARSED_BYMONTHDAY;
    858         }
    859     }
    860     /** parses BYYEARDAY=byyrdaylist */
    861     private static class ParseByYearDay extends PartParser {
    862         @Override public int parsePart(String value, EventRecurrence er) {
    863             int[] byyearday = parseNumberList(value, -366, 366, false);
    864             er.byyearday = byyearday;
    865             er.byyeardayCount = byyearday.length;
    866             return PARSED_BYYEARDAY;
    867         }
    868     }
    869     /** parses BYWEEKNO=bywknolist */
    870     private static class ParseByWeekNo extends PartParser {
    871         @Override public int parsePart(String value, EventRecurrence er) {
    872             int[] byweekno = parseNumberList(value, -53, 53, false);
    873             er.byweekno = byweekno;
    874             er.byweeknoCount = byweekno.length;
    875             return PARSED_BYWEEKNO;
    876         }
    877     }
    878     /** parses BYMONTH=bymolist */
    879     private static class ParseByMonth extends PartParser {
    880         @Override public int parsePart(String value, EventRecurrence er) {
    881             int[] bymonth = parseNumberList(value, 1, 12, false);
    882             er.bymonth = bymonth;
    883             er.bymonthCount = bymonth.length;
    884             return PARSED_BYMONTH;
    885         }
    886     }
    887     /** parses BYSETPOS=bysplist */
    888     private static class ParseBySetPos extends PartParser {
    889         @Override public int parsePart(String value, EventRecurrence er) {
    890             int[] bysetpos = parseNumberList(value, Integer.MIN_VALUE, Integer.MAX_VALUE, true);
    891             er.bysetpos = bysetpos;
    892             er.bysetposCount = bysetpos.length;
    893             return PARSED_BYSETPOS;
    894         }
    895     }
    896     /** parses WKST={SU,MO,...} */
    897     private static class ParseWkst extends PartParser {
    898         @Override public int parsePart(String value, EventRecurrence er) {
    899             Integer wkst = sParseWeekdayMap.get(value);
    900             if (wkst == null) {
    901                 throw new InvalidFormatException("Invalid WKST value: " + value);
    902             }
    903             er.wkst = wkst;
    904             return PARSED_WKST;
    905         }
    906     }
    907 }
    908