Beispiel #1
0
 /**
  * Creates a <code>Weeks</code> representing the number of whole weeks between the two specified
  * partial datetimes.
  *
  * <p>The two partials must contain the same fields, for example you can specify two <code>
  * LocalDate</code> objects.
  *
  * @param start the start partial date, must not be null
  * @param end the end partial date, must not be null
  * @return the period in weeks
  * @throws IllegalArgumentException if the partials are null or invalid
  */
 public static Weeks weeksBetween(ReadablePartial start, ReadablePartial end) {
   if (start instanceof LocalDate && end instanceof LocalDate) {
     Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
     int weeks =
         chrono
             .weeks()
             .getDifference(
                 ((LocalDate) end).getLocalMillis(), ((LocalDate) start).getLocalMillis());
     return Weeks.weeks(weeks);
   }
   int amount = BaseSingleFieldPeriod.between(start, end, ZERO);
   return Weeks.weeks(amount);
 }
Beispiel #2
0
 /**
  * 计算两个日期之间的时间间隔(不计算毫秒数)
  *
  * @param date1,date2
  * @param timeType
  * @return int
  */
 public static int periodBtDate(Date date1, Date date2, TimeType timeType) {
   if (date1 == null || date2 == null) {
     throw new IllegalArgumentException("date param can not be null");
   }
   DateTime start = fromDate(date1);
   DateTime end = fromDate(date2);
   int period = 0;
   switch (timeType.getCode()) {
     case "Y":
       period = Years.yearsBetween(start, end).getYears();
       break;
     case "M":
       period = Months.monthsBetween(start, end).getMonths();
       break;
     case "W":
       period = Weeks.weeksBetween(start, end).getWeeks();
       break;
     case "D":
       period = Days.daysBetween(start, end).getDays();
       break;
     case "H":
       period = Hours.hoursBetween(start, end).getHours();
       break;
     case "MIN":
       period = Minutes.minutesBetween(start, end).getMinutes();
       break;
     case "S":
       period = Seconds.secondsBetween(start, end).getSeconds();
       break;
     default:
       break;
   }
   return Math.abs(period);
 }
Beispiel #3
0
 /**
  * Creates a new <code>Weeks</code> by parsing a string in the ISO8601 format 'PnW'.
  *
  * <p>The parse will accept the full ISO syntax of PnYnMnWnDTnHnMnS however only the weeks
  * component may be non-zero. If any other component is non-zero, an exception will be thrown.
  *
  * @param periodStr the period string, null returns zero
  * @return the period in weeks
  * @throws IllegalArgumentException if the string format is invalid
  */
 @FromString
 public static Weeks parseWeeks(String periodStr) {
   if (periodStr == null) {
     return Weeks.ZERO;
   }
   Period p = PARSER.parsePeriod(periodStr);
   return Weeks.weeks(p.getWeeks());
 }
Beispiel #4
0
 /**
  * Creates a <code>Weeks</code> representing the number of whole weeks in the specified interval.
  *
  * @param interval the interval to extract weeks from, null returns zero
  * @return the period in weeks
  * @throws IllegalArgumentException if the partials are null or invalid
  */
 public static Weeks weeksIn(ReadableInterval interval) {
   if (interval == null) {
     return Weeks.ZERO;
   }
   int amount =
       BaseSingleFieldPeriod.between(
           interval.getStart(), interval.getEnd(), DurationFieldType.weeks());
   return Weeks.weeks(amount);
 }
 private DateTime nextRepeatWeekly(DateTime midnightNextDay) {
   if (schedule.getRepeatRate() == 1) {
     return midnightNextDay;
   }
   int distanceBetweenStartAndTomorrow =
       Weeks.weeksBetween(new DateTime(schedule.getBeginDate()).toDateMidnight(), midnightNextDay)
           .getWeeks();
   if (distanceBetweenStartAndTomorrow == 0
       || distanceBetweenStartAndTomorrow == schedule.getRepeatRate()) {
     if ((distanceBetweenStartAndTomorrow == 0
         && midnightNextDay.getDayOfWeek()
             <= new DateMidnight(schedule.getBeginDate()).getDayOfWeek())) {
       // we crossed a week boundary, so add one week.
       return midnightNextDay.plusWeeks(schedule.getRepeatRate() - 1);
     }
     return midnightNextDay;
   } else if (distanceBetweenStartAndTomorrow > schedule.getRepeatRate()) {
     int remainder = distanceBetweenStartAndTomorrow % schedule.getRepeatRate();
     return midnightNextDay.plusWeeks(schedule.getRepeatRate() - remainder);
   } else {
     return midnightNextDay.plusWeeks(schedule.getRepeatRate() - distanceBetweenStartAndTomorrow);
   }
 }
Beispiel #6
0
 /**
  * Creates a <code>Weeks</code> representing the number of whole weeks between the two specified
  * datetimes.
  *
  * @param start the start instant, must not be null
  * @param end the end instant, must not be null
  * @return the period in weeks
  * @throws IllegalArgumentException if the instants are null or invalid
  */
 public static Weeks weeksBetween(ReadableInstant start, ReadableInstant end) {
   int amount = BaseSingleFieldPeriod.between(start, end, DurationFieldType.weeks());
   return Weeks.weeks(amount);
 }
Beispiel #7
0
 /**
  * Is this weeks instance less than the specified number of weeks.
  *
  * @param other the other period, null means zero
  * @return true if this weeks instance is less than the specified one
  */
 public boolean isLessThan(Weeks other) {
   if (other == null) {
     return getValue() < 0;
   }
   return getValue() < other.getValue();
 }
Beispiel #8
0
 /**
  * Is this weeks instance greater than the specified number of weeks.
  *
  * @param other the other period, null means zero
  * @return true if this weeks instance is greater than the specified one
  */
 public boolean isGreaterThan(Weeks other) {
   if (other == null) {
     return getValue() > 0;
   }
   return getValue() > other.getValue();
 }
Beispiel #9
0
 /**
  * Returns a new instance with the weeks value negated.
  *
  * @return the new period with a negated value
  * @throws ArithmeticException if the result overflows an int
  */
 public Weeks negated() {
   return Weeks.weeks(FieldUtils.safeNegate(getValue()));
 }
Beispiel #10
0
 /**
  * Returns a new instance with the weeks divided by the specified divisor. The calculation uses
  * integer division, thus 3 divided by 2 is 1.
  *
  * <p>This instance is immutable and unaffected by this method call.
  *
  * @param divisor the amount to divide by, may be negative
  * @return the new period divided by the specified divisor
  * @throws ArithmeticException if the divisor is zero
  */
 public Weeks dividedBy(int divisor) {
   if (divisor == 1) {
     return this;
   }
   return Weeks.weeks(getValue() / divisor);
 }
Beispiel #11
0
 /**
  * Returns a new instance with the weeks multiplied by the specified scalar.
  *
  * <p>This instance is immutable and unaffected by this method call.
  *
  * @param scalar the amount to multiply by, may be negative
  * @return the new period multiplied by the specified scalar
  * @throws ArithmeticException if the result overflows an int
  */
 public Weeks multipliedBy(int scalar) {
   return Weeks.weeks(FieldUtils.safeMultiply(getValue(), scalar));
 }
Beispiel #12
0
 /**
  * Returns a new instance with the specified number of weeks taken away.
  *
  * <p>This instance is immutable and unaffected by this method call.
  *
  * @param weeks the amount of weeks to take away, may be negative, null means zero
  * @return the new period minus the specified number of weeks
  * @throws ArithmeticException if the result overflows an int
  */
 public Weeks minus(Weeks weeks) {
   if (weeks == null) {
     return this;
   }
   return minus(weeks.getValue());
 }
Beispiel #13
0
 /**
  * Returns a new instance with the specified number of weeks added.
  *
  * <p>This instance is immutable and unaffected by this method call.
  *
  * @param weeks the amount of weeks to add, may be negative
  * @return the new period plus the specified number of weeks
  * @throws ArithmeticException if the result overflows an int
  */
 public Weeks plus(int weeks) {
   if (weeks == 0) {
     return this;
   }
   return Weeks.weeks(FieldUtils.safeAdd(getValue(), weeks));
 }
Beispiel #14
0
 /**
  * Resolves singletons.
  *
  * @return the singleton instance
  */
 private Object readResolve() {
   return Weeks.weeks(getValue());
 }
Beispiel #15
0
 /**
  * Creates a new <code>Weeks</code> representing the number of complete standard length weeks in
  * the specified period.
  *
  * <p>This factory method converts all fields from the period to hours using standardised
  * durations for each field. Only those fields which have a precise duration in the ISO UTC
  * chronology can be converted.
  *
  * <ul>
  *   <li>One week consists of 7 days.
  *   <li>One day consists of 24 hours.
  *   <li>One hour consists of 60 minutes.
  *   <li>One minute consists of 60 weeks.
  *   <li>One second consists of 1000 milliseconds.
  * </ul>
  *
  * Months and Years are imprecise and periods containing these values cannot be converted.
  *
  * @param period the period to get the number of hours from, null returns zero
  * @return the period in weeks
  * @throws IllegalArgumentException if the period contains imprecise duration values
  */
 public static Weeks standardWeeksIn(ReadablePeriod period) {
   int amount = BaseSingleFieldPeriod.standardPeriodIn(period, DateTimeConstants.MILLIS_PER_WEEK);
   return Weeks.weeks(amount);
 }
 // -----------------------------------------------------------------------
 public void testToStandardWeeks() {
   Minutes test = Minutes.minutes(60 * 24 * 7 * 2);
   Weeks expected = Weeks.weeks(2);
   assertEquals(expected, test.toStandardWeeks());
 }