PeriodicEvent


1   /*
2    * Copyright (C) 2001 - 2005 ScalAgent Distributed Technologies
3    *
4    * This library is free software; you can redistribute it and/or
5    * modify it under the terms of the GNU Lesser General Public
6    * License as published by the Free Software Foundation; either
7    * version 2.1 of the License, or any later version.
8    * 
9    * This library is distributed in the hope that it will be useful,
10   * but WITHOUT ANY WARRANTY; without even the implied warranty of
11   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12   * Lesser General Public License for more details.
13   * 
14   * You should have received a copy of the GNU Lesser General Public
15   * License along with this library; if not, write to the Free Software
16   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
17   * USA.
18   *
19   * Initial developer(s): ScalAgent Distributed Technologies
20   * Contributor(s): 
21   */
22  package com.scalagent.scheduler.event;
23  
24  import java.util.Date  ;
25  import java.util.Calendar  ;
26  import java.util.TimeZone  ;
27  import java.text.DateFormat  ;
28  
29  import fr.dyade.aaa.util.Strings;
30  
31  /**
32   * A <code>PeriodicEvent</code> object implements a repetitive event defined
33   * by a reference date and a time period. The time period is qualified with
34   * a time unit, so that user meaningful periods may be defined, even though
35   * they are variable in length (such as a day, a month, and so on).
36   * <p>
37   * The reference date is used internally to keep track of the last computed
38   * event occurrence.
39   */
40  public class PeriodicEvent implements DiaryEvent {
41    /**
42     * Provides an internal computation facility to others, unrelated to
43     * any specific <code>PeriodicEvent</code> object.
44     *
45     * @param refDate reference date from which the result date is computed
46     * @param period  period definition to add to <code>refDate</code>
47     * @return        <code>refDate + period</code>
48     */
49    public static long getDate(long refDate, DiaryPeriod period) {
50      if ((refDate == -1) ||
51      (period.value == 0))
52        return -1;
53      PeriodicEvent pevt = new PeriodicEvent(refDate, period);
54      return pevt.getNextDate(refDate);
55    }
56  
57    /**
58     * Checks a field value of a calendar against a reference value.
59     * Handles some special -1 cases.
60     *
61     * @param calendar    reference date to check
62     * @param field   field identifier, as a <code>Calendar</code> constant
63     * @param value   reference value, may be negative
64     * @return        <code>true</code> if values match
65     */
66    public static boolean checkField(
67      Calendar   calendar, int field, int value) {
68  
69      if (value >= 0) {
70        if (calendar.get(field) != value)
71      return false;
72        return true;
73      }
74  
75      // keeps the parameter calendar as it is
76      Calendar   clone = (Calendar  ) calendar.clone();
77      switch (field) {
78      case Calendar.DAY_OF_MONTH:
79        clone.add(Calendar.DAY_OF_MONTH, -value);
80        if (clone.get(Calendar.DAY_OF_MONTH) != 1)
81      return false;
82        return true;
83      case Calendar.DAY_OF_WEEK_IN_MONTH:
84        clone.add(Calendar.DAY_OF_MONTH, -7 * value);
85        if (clone.get(Calendar.DAY_OF_MONTH) >= 7)
86      return false;
87        return true;
88      default:
89        // not accepted
90        break;
91      }
92  
93      return false;
94    }
95  
96    /**
97     * ID of the time zone to be used when computing dates.
98     * A <code>null</code> value stands for the local time zone.
99     * <p>
100    * Defaults to <code>null</code>.
101    */
102   protected String   timeZoneId = null;
103 
104   /**
105    * Reference date from which event dates are computed by adding a multiple
106    * of the period length. A <code>-1</code> value means that no reference date
107    * is set.
108    * <p>
109    * Defaults to <code>-1</code>.
110    */
111   protected long refDate = -1;
112   
113   /**
114    * Period definition. A <code>null</code> value stands for a no repetitive
115    * event.
116    * <p>
117    * Defaults to <code>null</code>.
118    */
119   protected DiaryPeriod period = null;
120 
121   /**
122    * Mask of fields to match event dates, as <code>Calendar</code> constants.
123    * <p>
124    * Some values for the <code>period</code> field accept a logical definition
125    * of the event date, in addition to the reference date. There are only a
126    * small set of <code>(period/maskField)</code> legal combinations that may
127    * be validated using {@link validateMask}.
128    * <p>
129    * The fields are ordered according to the following:
130    * <code>YEAR, MONTH, WEEK_OF_YEAR, WEEK_OF_MONTH,
131    * DAY_OF_YEAR, DAY_OF_MONTH, DAY_OF_WEEK_IN_MONTH, DAY_OF_WEEK</code>.
132    */
133   protected int[] maskField = null;
134 
135   /**
136    * Values of corresponding fields in <code>maskField</code>.
137    * May be set from <code>refDate</code> using {@link validateMask}.
138    * <p>
139    * Positive values require an exact match, while negative values are
140    * interpreted either by the <code>Calendar</code> class or directly by
141    * this class. Negative values are accepted for the <code>DAY_OF_MONTH</code>
142    * and <code>DAY_OF_WEEK_IN_MONTH</code> fields.
143    */
144   protected int[] maskValue = null;
145 
146   /**
147    * Object used internally to compute dates. It is created from the
148    * <code>timeZoneId</code> field when this object is created, and initialized
149    * with the reference date.
150    * <p>
151    * A <code>Calendar</code> object holds two descriptions of a date, as a
152    * <code>long</code> value, and as a number of fields. Those two descriptions
153    * are always synced in <code>calendar</code>.
154    */
155   protected Calendar   calendar;
156 
157   /**
158    * Constructor setting all fields. May need a call to {@link validateMask}
159    * if <code>maskField</code> is not <code>null</code>.
160    *
161    * @param timeZoneId
162    *    id of the time zone to be used when computing dates
163    * @param refDate
164    *    reference date from which event dates are computed
165    * @param period
166    *    period definition
167    * @param maskField
168    *    mask of fields to match event dates, as <code>Calendar</code> constants
169    * @param maskValue
170    *    values of corresponding fields in <code>maskField</code>
171    */
172   public PeriodicEvent(String   timeZoneId, long refDate, DiaryPeriod period,
173                int[] maskField, int[] maskValue) {
174     this.timeZoneId = timeZoneId;
175     this.refDate = refDate;
176     this.period = period;
177     this.maskField = maskField;
178     this.maskValue = maskValue;
179 
180     if (timeZoneId == null) {
181       calendar = Calendar.getInstance();
182     } else {
183       TimeZone   tz = TimeZone.getTimeZone(timeZoneId);
184       if (tz == null)
185     calendar = Calendar.getInstance();
186       else
187     calendar = Calendar.getInstance(tz);
188     }
189 
190     if (refDate != -1)
191       calendar.setTime(new Date  (refDate));
192   }
193 
194   /**
195    * Constructor with no mask.
196    *
197    * @param timeZoneId  id of the time zone to be used when computing dates
198    * @param refDate reference date from which event dates are computed
199    * @param period  period definition
200    */
201   public PeriodicEvent(String   timeZoneId, long refDate, DiaryPeriod period) {
202     this(timeZoneId, refDate, period, null, null);
203   }
204 
205   /**
206    * Constructor with default time zone.
207    *
208    * @param refDate reference date from which event dates are computed
209    * @param period  period definition
210    */
211   public PeriodicEvent(long refDate, DiaryPeriod period) {
212     this(null, refDate, period);
213   }
214 
215   /**
216    * Default constructor.
217    * Creates an event with a null date and no repeat period.
218    */
219   public PeriodicEvent() {
220     this(-1, null);
221   }
222 
223   /**
224    * Field accessor.
225    *
226    * @param timeZoneId  id of the time zone to be used when computing dates
227    */
228   public void setTimeZoneId(String   timeZoneId) {
229     this.timeZoneId = timeZoneId;
230   }
231 
232   /**
233    * Field accessor.
234    *
235    * @return    id of the time zone to be used when computing dates
236    */
237   public String   getTimeZoneId() {
238     return timeZoneId;
239   }
240 
241   /**
242    * Field accessor. May need an additional call to {@link validateMask}.
243    *
244    * @param refDate reference date from which event dates are computed
245    */
246   public void setRefDate(long refDate) {
247     this.refDate = refDate;
248     if (refDate != -1)
249       calendar.setTime(new Date  (refDate));
250   }
251 
252   /**
253    * Field accessor.
254    *
255    * @return    reference date from which event dates are computed
256    */
257   public long getRefDate() {
258     return refDate;
259   }
260 
261   /**
262    * Field accessor.
263    *
264    * @param period  period definition
265    */
266   public void setPeriod(DiaryPeriod period) {
267     this.period = period;
268   }
269 
270   /**
271    * Field accessor.
272    *
273    * @return    period definition
274    */
275   public DiaryPeriod getPeriod() {
276     return period;
277   }
278 
279   /**
280    * Field accessor.
281    *
282    * @param maskField
283    *    mask of fields to match event dates, as <code>Calendar</code> constants
284    */
285   public void setMaskField(int[] maskField) {
286     if ((maskField != null) && (maskField.length == 0))
287       this.maskField = null;
288     else
289       this.maskField = maskField;
290   }
291 
292   /**
293    * Field accessor.
294    *
295    * @return    mask of fields to match event dates
296    */
297   public int[] getMaskField() {
298     return maskField;
299   }
300 
301   /**
302    * Field accessor.
303    *
304    * @param maskValue
305    *    values of corresponding fields in <code>maskField</code>
306    */
307   public void setMaskValue(int[] maskValue) {
308     if ((maskValue != null) && (maskValue.length == 0))
309       this.maskValue = null;
310     else
311       this.maskValue = maskValue;
312   }
313 
314   /**
315    * Field accessor.
316    *
317    * @return    values of corresponding fields in <code>maskField</code>
318    */
319   public int[] getMaskValue() {
320     return maskValue;
321   }
322 
323   /**
324    * Checks the consistency of the four fields <code>refDate</code>,
325    * <code>period</code>, <code>maskField</code>, and <code>maskValue</code>.
326    * Updates <code>maskValue</code> when <code>null</code>.
327    * <p>
328    * Legal <code>(period/maskField)</code> combinations are
329    * <code>(YEAR/DAY_OF_YEAR)</code>,
330    * <code>(YEAR/WEEK_OF_YEAR(&DAY_OF_WEEK))</code>,
331    * <code>(YEAR/MONTH&DAY_OF_MONTH)</code>,
332    * <code>(YEAR/MONTH&WEEK_OF_MONTH(&DAY_OF_WEEK))</code>,
333    * <code>(YEAR/MONTH&DAY_OF_WEEK_IN_MONTH(&DAY_OF_WEEK))</code>,
334    * <code>(MONTH/DAY_OF_MONTH)</code>,
335    * <code>(MONTH/WEEK_OF_MONTH(&DAY_OF_WEEK))</code>,
336    * <code>(MONTH/DAY_OF_WEEK_IN_MONTH(&DAY_OF_WEEK))</code>.
337    * The optional <code>DAY_OF_WEEK</code> mask value may be retrieved from
338    * the reference date.
339    *
340    * @return
341    *    <code>true</code> when all three values are consistent,
342    *    <code>false</code> otherwise.
343    */
344   public boolean validateMask() {
345     if ((maskField == null) ||
346     (maskField.length == 0))
347       return true;
348 
349     if (period == null) {
350       // a sensible configuration should also set maskField to null
351       return false;
352     }
353 
354     boolean fillValue = false;
355     if (maskValue == null) {
356       fillValue = true;
357       maskValue = new int[maskField.length];
358     }
359 
360     // checks the reference date
361     if (refDate != -1)
362       calendar.setTime(new Date  (refDate));
363 
364     if (maskField[0] == Calendar.YEAR)
365       return false;
366     int index = 0;
367     switch (period.unit) {
368     case Calendar.YEAR:
369       switch (maskField[index]) {
370       case Calendar.MONTH:
371     if (fillValue) {
372       if (refDate == -1)
373         return false;
374       maskValue[index] = calendar.get(Calendar.MONTH);
375     } else if (refDate != -1) {
376       if (! checkField(calendar, Calendar.MONTH, maskValue[index]))
377         return false;
378     }
379     index ++;
380     if (index >= maskField.length)
381       return false;
382     switch (maskField[index]) {
383     case Calendar.WEEK_OF_MONTH:
384       if (fillValue) {
385         if (refDate == -1)
386           return false;
387         maskValue[index] = calendar.get(Calendar.WEEK_OF_MONTH);
388       } else if (refDate != -1) {
389         if (! checkField(calendar,
390                  Calendar.WEEK_OF_MONTH,
391                  maskValue[index]))
392           return false;
393       }
394       index ++;
395       if (index < maskField.length) {
396         switch (maskField[index]) {
397         case Calendar.DAY_OF_WEEK:
398           if (fillValue) {
399         if (refDate == -1)
400           return false;
401         maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
402           } else if (refDate != -1) {
403         if (! checkField(calendar, Calendar.DAY_OF_WEEK, maskValue[index]))
404           return false;
405           }
406           index ++;
407           if (index >= maskField.length)
408         return true;
409           return false;
410         default:
411           return false;
412         }
413       } else {
414         // gets the DAY_OF_WEEK value from the reference date
415         if (refDate == -1)
416           return false;
417         int mask[] = new int[index];
418         System.arraycopy(maskField, 0, mask, 0, maskField.length);
419         maskField = mask;
420         maskField[index] = Calendar.DAY_OF_WEEK;
421         mask = new int[index];
422         System.arraycopy(maskValue, 0, mask, 0, maskValue.length);
423         maskValue = mask;
424         maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
425         return true;
426       }
427     case Calendar.DAY_OF_MONTH:
428       if (fillValue) {
429         if (refDate == -1)
430           return false;
431         maskValue[index] = calendar.get(Calendar.DAY_OF_MONTH);
432       } else if (refDate != -1) {
433         if (! checkField(calendar, Calendar.DAY_OF_MONTH, maskValue[index]))
434           return false;
435       }
436       index ++;
437       if (index >= maskField.length)
438         return true;
439       return false;
440     case Calendar.DAY_OF_WEEK_IN_MONTH:
441       if (fillValue) {
442         if (refDate == -1)
443           return false;
444         maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);
445       } else if (refDate != -1) {
446         if (! checkField(calendar, Calendar.DAY_OF_WEEK_IN_MONTH, maskValue[index]))
447           return false;
448       }
449       index ++;
450       if (index < maskField.length) {
451         switch (maskField[index]) {
452         case Calendar.DAY_OF_WEEK:
453           if (fillValue) {
454         if (refDate == -1)
455           return false;
456         maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
457           } else if (refDate != -1) {
458         if (! checkField(calendar, Calendar.DAY_OF_WEEK, maskValue[index]))
459           return false;
460           }
461           index ++;
462           if (index >= maskField.length)
463         return true;
464           return false;
465         default:
466           return false;
467         }
468       } else {
469         // gets the DAY_OF_WEEK value from the reference date
470         if (refDate == -1)
471           return false;
472         int mask[] = new int[index];
473         System.arraycopy(maskField, 0, mask, 0, maskField.length);
474         maskField = mask;
475         maskField[index] = Calendar.DAY_OF_WEEK;
476         mask = new int[index];
477         System.arraycopy(maskValue, 0, mask, 0, maskValue.length);
478         maskValue = mask;
479         maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
480         return true;
481       }
482     default:
483       return false;
484     }
485       case Calendar.WEEK_OF_YEAR:
486     if (fillValue) {
487       if (refDate == -1)
488         return false;
489       maskValue[index] = calendar.get(Calendar.WEEK_OF_YEAR);
490     } else if (refDate != -1) {
491       if (! checkField(calendar, Calendar.WEEK_OF_YEAR, maskValue[index]))
492         return false;
493     }
494     index ++;
495     if (index < maskField.length) {
496       switch (maskField[index]) {
497       case Calendar.DAY_OF_WEEK:
498         if (fillValue) {
499           if (refDate == -1)
500         return false;
501           maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
502         } else if (refDate != -1) {
503           if (! checkField(calendar, Calendar.DAY_OF_WEEK, maskValue[index]))
504         return false;
505         }
506         index ++;
507         if (index >= maskField.length)
508           return true;
509         return false;
510       default:
511         return false;
512       }
513     } else {
514       // gets the DAY_OF_WEEK value from the reference date
515       if (refDate == -1)
516         return false;
517       int mask[] = new int[index];
518       System.arraycopy(maskField, 0, mask, 0, maskField.length);
519       maskField = mask;
520       maskField[index] = Calendar.DAY_OF_WEEK;
521       mask = new int[index];
522       System.arraycopy(maskValue, 0, mask, 0, maskValue.length);
523       maskValue = mask;
524       maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
525       return true;
526     }
527       case Calendar.DAY_OF_YEAR:
528     if (fillValue) {
529       if (refDate == -1)
530         return false;
531       maskValue[index] = calendar.get(Calendar.DAY_OF_YEAR);
532     } else if (refDate != -1) {
533       if (! checkField(calendar, Calendar.DAY_OF_YEAR, maskValue[index]))
534         return false;
535     }
536     index ++;
537     if (index >= maskField.length)
538       return true;
539     return false;
540       }
541       break;
542     case Calendar.MONTH:
543       switch (maskField[index]) {
544       case Calendar.WEEK_OF_MONTH:
545     if (fillValue) {
546       if (refDate == -1)
547         return false;
548       maskValue[index] = calendar.get(Calendar.WEEK_OF_MONTH);
549     } else if (refDate != -1) {
550       if (! checkField(calendar, Calendar.WEEK_OF_MONTH, maskValue[index]))
551         return false;
552     }
553     index ++;
554     if (index < maskField.length) {
555       switch (maskField[index]) {
556       case Calendar.DAY_OF_WEEK:
557         if (fillValue) {
558           if (refDate == -1)
559         return false;
560           maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
561         } else if (refDate != -1) {
562           if (! checkField(calendar, Calendar.DAY_OF_WEEK, maskValue[index]))
563         return false;
564         }
565         index ++;
566         if (index >= maskField.length)
567           return true;
568         return false;
569       default:
570         return false;
571       }
572     } else {
573       // gets the DAY_OF_WEEK value from the reference date
574       if (refDate == -1)
575         return false;
576       int mask[] = new int[index];
577       System.arraycopy(maskField, 0, mask, 0, maskField.length);
578       maskField = mask;
579       maskField[index] = Calendar.DAY_OF_WEEK;
580       mask = new int[index];
581       System.arraycopy(maskValue, 0, mask, 0, maskValue.length);
582       maskValue = mask;
583       maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
584       return true;
585     }
586       case Calendar.DAY_OF_MONTH:
587     if (fillValue) {
588       if (refDate == -1)
589         return false;
590       maskValue[index] = calendar.get(Calendar.DAY_OF_MONTH);
591     } else if (refDate != -1) {
592       if (! checkField(calendar, Calendar.DAY_OF_MONTH, maskValue[index]))
593         return false;
594     }
595     index ++;
596     if (index >= maskField.length)
597       return true;
598     return false;
599       case Calendar.DAY_OF_WEEK_IN_MONTH:
600     if (fillValue) {
601       if (refDate == -1)
602         return false;
603       maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK_IN_MONTH);
604     } else if (refDate != -1) {
605       if (! checkField(calendar, Calendar.DAY_OF_WEEK_IN_MONTH, maskValue[index]))
606         return false;
607     }
608     index ++;
609     if (index < maskField.length) {
610       switch (maskField[index]) {
611       case Calendar.DAY_OF_WEEK:
612         if (fillValue) {
613           if (refDate == -1)
614         return false;
615           maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
616         } else if (refDate != -1) {
617           if (! checkField(calendar, Calendar.DAY_OF_WEEK, maskValue[index]))
618         return false;
619         }
620         index ++;
621         if (index >= maskField.length)
622           return true;
623         return false;
624       default:
625         return false;
626       }
627     } else {
628       // gets the DAY_OF_WEEK value from the reference date
629       if (refDate == -1)
630         return false;
631       int mask[] = new int[index];
632       System.arraycopy(maskField, 0, mask, 0, maskField.length);
633       maskField = mask;
634       maskField[index] = Calendar.DAY_OF_WEEK;
635       mask = new int[index];
636       System.arraycopy(maskValue, 0, mask, 0, maskValue.length);
637       maskValue = mask;
638       maskValue[index] = calendar.get(Calendar.DAY_OF_WEEK);
639       return true;
640     }
641       default:
642     return false;
643       }
644     default:
645       // when period is the day or lower, no mask is allowed
646       return false;
647     }
648 
649     // not reached
650     return false;
651   }
652 
653   /**
654    * Provides a string image for this object.
655    *
656    * @return    string image for this object
657    */
658   public String   toString() {
659     StringBuffer   output = new StringBuffer  ();
660     output.append("(");
661     output.append(super.toString());
662     output.append(",timeZoneId=");
663     Strings.toString(output, timeZoneId);
664     output.append(",refDate=");
665     output.append(refDate);
666     if (refDate > 0) {
667       output.append("(");
668       output.append(DateFormat.getDateTimeInstance().format(
669     new Date  (refDate)));
670       output.append(")");
671     }
672     output.append(",period=");
673     output.append(period);
674     output.append(",maskField=");
675     Strings.toStringArray(output, maskField);
676     output.append(",maskValue=");
677     Strings.toStringArray(output, maskValue);
678     output.append(")");
679     return output.toString();
680   }
681 
682   /**
683    * Applies the mask on the calendar.
684    */
685   protected void applyMask() {
686     if (maskField == null)
687       return;
688 
689     int lastDayInMonth = 0;
690 
691     for (int i = 0; i < maskField.length; i ++) {
692       // negative values for DAY_OF_MONTH are not handled by the Calendar
693       if ((maskField[i] == Calendar.DAY_OF_MONTH) &&
694       (maskValue[i] < 0)) {
695     lastDayInMonth = maskValue[i];
696     calendar.set(Calendar.DAY_OF_MONTH, 33);
697       } else {
698     calendar.set(maskField[i], maskValue[i]);
699       }
700     }
701 
702     if (lastDayInMonth != 0) {
703       // resolve the calendar date.
704 //    calendar.getTime();
705       // Work-around calendar jdk1.4 bug (Id: 4685354).
706       calendar.get(Calendar.MONTH);
707       calendar.set(Calendar.DAY_OF_MONTH, lastDayInMonth + 1);
708     }
709   }
710 
711   /**
712    * Checks that the calendar conforms to the mask.
713    */
714   protected boolean checkMask() {
715     if (maskField == null)
716       return true;
717 
718     for (int i = 0; i < maskField.length; i ++) {
719       if ((maskValue[i] > 0) &&
720       (calendar.get(maskField[i]) != maskValue[i]))
721     return false;
722     }
723 
724     return true;
725   }
726 
727   /**
728    * Gets the next event date after the parameter date. Returns
729    * <code>-1</code> if there is no such date.
730    *
731    * @param now
732    *    starting date for the lookup
733    * @param inclusive
734    *    if <code>true</code> checks <code>now</code> as an answer
735    * @return
736    *    the next event date after now,
737    *    <code>-1</code> if there is no such date
738    */
739   public long getNextDate(long now, boolean inclusive) {
740     return getNextDate(now, 1, inclusive);
741   }
742 
743   /**
744    * Gets the next event date after the parameter date. Returns
745    * <code>-1</code> if there is no such date.
746    * Calls {@link getNextDate(long, boolean) getNextDate} with the
747    * <code>inclusive</code> parameter set to <code>false</code>.
748    *
749    * @param now
750    *    starting date for the lookup
751    * @return
752    *    the next event date after now,
753    *    <code>-1</code> if there is no such date
754    */
755   public long getNextDate(long now) {
756     return getNextDate(now, false);
757   }
758 
759   /**
760    * Gets the last event date before the parameter date. Returns
761    * <code>-1</code> if there is no such date.
762    *
763    * @param now
764    *    starting date for the backward lookup
765    * @param inclusive
766    *    if <code>true</code> checks <code>now</code> as an answer
767    * @return
768    *    the last event date before now,
769    *    <code>-1</code> if there is no such date
770    */
771   public long getLastDate(long now, boolean inclusive) {
772     return getNextDate(now, -1, inclusive);
773   }
774 
775   /**
776    * Gets the last event date before the parameter date. Returns
777    * <code>-1</code> if there is no such date.
778    * Calls {@link getLastDate(long, boolean) getLastDate} with the
779    * <code>inclusive</code> parameter set to <code>false</code>.
780    *
781    * @param now
782    *    starting date for the backward lookup
783    * @return
784    *    the last event date before now,
785    *    <code>-1</code> if there is no such date
786    */
787   public long getLastDate(long now) {
788     return getLastDate(now, false);
789   }
790 
791   /**
792    * Gets the next event date before or after the parameter date. Returns
793    * <code>-1</code> if there is no such date.
794    *
795    * @param now
796    *    starting date for the lookup
797    * @param dir
798    *    direction of lookup, forward when positive, backward when negative
799    * @param inclusive
800    *    if <code>true</code> checks <code>now</code> as an answer
801    * @return
802    *    the next event date before/after now,
803    *    <code>-1</code> if there is no such date
804    */
805   private long getNextDate(long now, int dir, boolean inclusive) {
806     if (dir == 0)
807       return -1;
808     if (dir > 0)
809       dir = 1;
810     else
811       dir = -1;
812 
813     if (refDate == -1)
814       return -1;
815 
816     // the calendar date is always set to the reference date, which is
817     // a valid event date, or to the last valid event date returned
818     long date = calendar.getTime().getTime();
819     if (inclusive && (date == now))
820       return date;
821 
822     if (period.value == 0)
823       return -1;
824 
825     Calendar   clone = (Calendar  ) calendar.clone();
826 
827     // gets a rough estimate of the number of periods between date and now
828     long pnum = now - date;
829     int sign = 1;
830     if (pnum > 0) {
831       sign = dir;
832     } else {
833       pnum = -pnum;
834       sign = -dir;
835     }
836     switch (period.unit) {
837     case Calendar.YEAR:
838       pnum /= 12;
839     case Calendar.MONTH:
840       pnum /= 30;
841     case Calendar.DAY_OF_MONTH:
842       pnum /= 24;
843     case Calendar.HOUR_OF_DAY:
844       pnum /= 60;
845     case Calendar.MINUTE:
846       pnum /= 60;
847     case Calendar.SECOND:
848       pnum /= 1000;
849     }
850     pnum /= period.value;
851 
852     // tries to skip a large period
853     pnum_loop:
854     while (pnum > 3) {
855       calendar.add(period.unit, (int) (pnum * period.value * dir * sign));
856 
857       // sets all fields before evaluating the calendar
858       applyMask();
859       if (! checkMask()) {
860     // this is not a valid event date
861     calendar = clone;
862     clone = (Calendar  ) calendar.clone();
863     pnum --;
864     continue pnum_loop;
865       }
866 
867       // this is a valid event date
868       clone = (Calendar  ) calendar.clone();
869       break pnum_loop;
870     }
871 
872     date = calendar.getTime().getTime();
873     if (now == date) {
874       if (inclusive)
875     return date;
876       sign = 1;
877     } else if (now > date) {
878       sign = dir;
879     } else {
880       sign = -dir;
881     }
882     pnum = 1;
883 
884     main_loop:
885     while (true) {
886       calendar.add(period.unit, (int) (pnum * period.value * dir * sign));
887 
888       applyMask();
889 
890       date = calendar.getTime().getTime();
891       if ((sign == -1) &&
892       ((((date - now) * dir) < 0) ||
893        (!inclusive && (date == now)))) {
894     calendar = clone;
895     return calendar.getTime().getTime();
896       }
897 
898       if (! checkMask()) {
899     // this is not a valid event date
900     calendar = clone;
901     clone = (Calendar  ) calendar.clone();
902     pnum ++;
903     continue main_loop;
904       }
905 
906       // this is a valid event date
907       if ((sign == 1) &&
908       ((((date - now) * dir) > 0) ||
909        (inclusive && (date == now)))) {
910     return date;
911       }
912 
913       clone = (Calendar  ) calendar.clone();
914       pnum = 1;
915     }
916 
917     // never reached
918   }
919 }
920
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags