コード例 #1
0
  public void testWithFieldAdded_DurationFieldType_int_6() {
    LocalTime test = new LocalTime(10, 20, 30, 40);
    LocalTime result = test.withFieldAdded(DurationFieldType.hours(), 16);

    assertEquals(new LocalTime(10, 20, 30, 40), test);
    assertEquals(new LocalTime(2, 20, 30, 40), result);
  }
コード例 #2
0
 /**
  * Gets a type that defines the year and day fields.
  *
  * <ul>
  *   <li>years
  *   <li>days
  * </ul>
  *
  * @return the period type
  * @since 1.1
  */
 public static PeriodType yearDay() {
   PeriodType type = cYD;
   if (type == null) {
     type =
         new PeriodType(
             "YearDay",
             new DurationFieldType[] {
               DurationFieldType.years(), DurationFieldType.days(),
             },
             new int[] {
               0, -1, -1, 1, -1, -1, -1, -1,
             });
     cYD = type;
   }
   return type;
 }
コード例 #3
0
 /**
  * Gets a type that defines all standard time fields.
  *
  * <ul>
  *   <li>hours
  *   <li>minutes
  *   <li>seconds
  *   <li>milliseconds
  * </ul>
  *
  * @return the period type
  */
 public static PeriodType time() {
   PeriodType type = cTime;
   if (type == null) {
     type =
         new PeriodType(
             "Time",
             new DurationFieldType[] {
               DurationFieldType.hours(), DurationFieldType.minutes(),
               DurationFieldType.seconds(), DurationFieldType.millis(),
             },
             new int[] {
               -1, -1, -1, -1, 0, 1, 2, 3,
             });
     cTime = type;
   }
   return type;
 }
コード例 #4
0
 public void testWithFieldAdded_DurationFieldType_int_5() {
   LocalTime test = new LocalTime(10, 20, 30, 40);
   try {
     test.withFieldAdded(DurationFieldType.days(), 6);
     fail();
   } catch (IllegalArgumentException ex) {
   }
 }
コード例 #5
0
  public void testWithFieldAdded_DurationFieldType_int_8() {
    LocalTime test = new LocalTime(0, 0, 0, 0);
    LocalTime result = test.withFieldAdded(DurationFieldType.millis(), -1);
    assertEquals(new LocalTime(23, 59, 59, 999), result);

    test = new LocalTime(0, 0, 0, 0);
    result = test.withFieldAdded(DurationFieldType.seconds(), -1);
    assertEquals(new LocalTime(23, 59, 59, 0), result);

    test = new LocalTime(0, 0, 0, 0);
    result = test.withFieldAdded(DurationFieldType.minutes(), -1);
    assertEquals(new LocalTime(23, 59, 0, 0), result);

    test = new LocalTime(0, 0, 0, 0);
    result = test.withFieldAdded(DurationFieldType.hours(), -1);
    assertEquals(new LocalTime(23, 0, 0, 0), result);
  }
コード例 #6
0
ファイル: Weeks.java プロジェクト: 272152441/joda-time
 /**
  * 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);
 }
コード例 #7
0
 /**
  * Gets a type that defines just the months field.
  *
  * @return the period type
  */
 public static PeriodType months() {
   PeriodType type = cMonths;
   if (type == null) {
     type =
         new PeriodType(
             "Months",
             new DurationFieldType[] {DurationFieldType.months()},
             new int[] {
               -1, 0, -1, -1, -1, -1, -1, -1,
             });
     cMonths = type;
   }
   return type;
 }
コード例 #8
0
 /**
  * Gets a type that defines just the hours field.
  *
  * @return the period type
  */
 public static PeriodType hours() {
   PeriodType type = cHours;
   if (type == null) {
     type =
         new PeriodType(
             "Hours",
             new DurationFieldType[] {DurationFieldType.hours()},
             new int[] {
               -1, -1, -1, -1, 0, -1, -1, -1,
             });
     cHours = type;
   }
   return type;
 }
コード例 #9
0
 /**
  * Gets a type that defines just the weeks field.
  *
  * @return the period type
  */
 public static PeriodType weeks() {
   PeriodType type = cWeeks;
   if (type == null) {
     type =
         new PeriodType(
             "Weeks",
             new DurationFieldType[] {DurationFieldType.weeks()},
             new int[] {
               -1, -1, 0, -1, -1, -1, -1, -1,
             });
     cWeeks = type;
   }
   return type;
 }
コード例 #10
0
 /**
  * Gets a type that defines just the years field.
  *
  * @return the period type
  */
 public static PeriodType years() {
   PeriodType type = cYears;
   if (type == null) {
     type =
         new PeriodType(
             "Years",
             new DurationFieldType[] {DurationFieldType.years()},
             new int[] {
               0, -1, -1, -1, -1, -1, -1, -1,
             });
     cYears = type;
   }
   return type;
 }
コード例 #11
0
 /**
  * Gets a type that defines just the millis field.
  *
  * @return the period type
  */
 public static PeriodType millis() {
   PeriodType type = cMillis;
   if (type == null) {
     type =
         new PeriodType(
             "Millis",
             new DurationFieldType[] {DurationFieldType.millis()},
             new int[] {
               -1, -1, -1, -1, -1, -1, -1, 0,
             });
     cMillis = type;
   }
   return type;
 }
コード例 #12
0
 /**
  * Gets a type that defines just the days field.
  *
  * @return the period type
  */
 public static PeriodType days() {
   PeriodType type = cDays;
   if (type == null) {
     type =
         new PeriodType(
             "Days",
             new DurationFieldType[] {DurationFieldType.days()},
             new int[] {
               -1, -1, -1, 0, -1, -1, -1, -1,
             });
     cDays = type;
   }
   return type;
 }
コード例 #13
0
 /**
  * Gets a type that defines just the seconds field.
  *
  * @return the period type
  */
 public static PeriodType seconds() {
   PeriodType type = cSeconds;
   if (type == null) {
     type =
         new PeriodType(
             "Seconds",
             new DurationFieldType[] {DurationFieldType.seconds()},
             new int[] {
               -1, -1, -1, -1, -1, -1, 0, -1,
             });
     cSeconds = type;
   }
   return type;
 }
コード例 #14
0
  public void testIsSupported_DurationFieldType() {
    LocalTime test = new LocalTime(10, 20, 30, 40);
    assertEquals(true, test.isSupported(DurationFieldType.hours()));
    assertEquals(true, test.isSupported(DurationFieldType.minutes()));
    assertEquals(true, test.isSupported(DurationFieldType.seconds()));
    assertEquals(true, test.isSupported(DurationFieldType.millis()));
    assertEquals(true, test.isSupported(DurationFieldType.halfdays()));

    assertEquals(false, test.isSupported(DurationFieldType.days()));
    assertEquals(false, test.isSupported((DurationFieldType) null));
  }
コード例 #15
0
 /**
  * Gets a type that defines all standard fields.
  *
  * <ul>
  *   <li>years
  *   <li>months
  *   <li>weeks
  *   <li>days
  *   <li>hours
  *   <li>minutes
  *   <li>seconds
  *   <li>milliseconds
  * </ul>
  *
  * @return the period type
  */
 public static PeriodType standard() {
   PeriodType type = cStandard;
   if (type == null) {
     type =
         new PeriodType(
             "Standard",
             new DurationFieldType[] {
               DurationFieldType.years(), DurationFieldType.months(),
               DurationFieldType.weeks(), DurationFieldType.days(),
               DurationFieldType.hours(), DurationFieldType.minutes(),
               DurationFieldType.seconds(), DurationFieldType.millis(),
             },
             new int[] {
               0, 1, 2, 3, 4, 5, 6, 7,
             });
     cStandard = type;
   }
   return type;
 }
コード例 #16
0
 /**
  * Gets a type that defines all standard fields except months and weeks.
  *
  * <ul>
  *   <li>years
  *   <li>days
  *   <li>hours
  *   <li>minutes
  *   <li>seconds
  *   <li>milliseconds
  * </ul>
  *
  * @return the period type
  */
 public static PeriodType yearDayTime() {
   PeriodType type = cYDTime;
   if (type == null) {
     type =
         new PeriodType(
             "YearDayTime",
             new DurationFieldType[] {
               DurationFieldType.years(), DurationFieldType.days(),
               DurationFieldType.hours(), DurationFieldType.minutes(),
               DurationFieldType.seconds(), DurationFieldType.millis(),
             },
             new int[] {
               0, -1, -1, 1, 2, 3, 4, 5,
             });
     cYDTime = type;
   }
   return type;
 }
コード例 #17
0
ファイル: Years.java プロジェクト: ZihaoAllen/gwt-time
 /**
  * Gets the duration field type, which is <code>years</code>.
  *
  * @return the period type
  */
 public DurationFieldType getFieldType() {
   return DurationFieldType.years();
 }
コード例 #18
0
ファイル: MutableDateTime.java プロジェクト: tbaum/gwt-time
 /**
  * Adds to the instant specifying the duration and multiple to add.
  *
  * @param type a field type, usually obtained from DateTimeFieldType, not null
  * @param amount the amount to add of this duration
  * @throws IllegalArgumentException if the value is null or invalid
  * @throws ArithmeticException if the result exceeds the capacity of the instant
  */
 public void add(DurationFieldType type, int amount) {
   if (type == null) {
     throw new IllegalArgumentException("Field must not be null");
   }
   setMillis(type.getField(getChronology()).add(getMillis(), amount));
 }
コード例 #19
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time plus the specified number of millis.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay added = dt.plusMillis(6);
  * TimeOfDay added = dt.plus(Period.millis(6));
  * TimeOfDay added = dt.withFieldAdded(DurationFieldType.millis(), 6);
  * </pre>
  *
  * @param millis the amount of millis to add, may be negative
  * @return the new time plus the increased millis
  * @since 1.1
  */
 public TimeOfDay plusMillis(int millis) {
   return withFieldAdded(DurationFieldType.millis(), millis);
 }
コード例 #20
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time minus the specified number of hours.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay subtracted = dt.minusHours(6);
  * TimeOfDay subtracted = dt.minus(Period.hours(6));
  * TimeOfDay subtracted = dt.withFieldAdded(DurationFieldType.hours(), -6);
  * </pre>
  *
  * @param hours the amount of hours to subtract, may be negative
  * @return the new time minus the increased hours
  * @since 1.1
  */
 public TimeOfDay minusHours(int hours) {
   return withFieldAdded(DurationFieldType.hours(), FieldUtils.safeNegate(hours));
 }
コード例 #21
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time minus the specified number of seconds.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay subtracted = dt.minusSeconds(6);
  * TimeOfDay subtracted = dt.minus(Period.seconds(6));
  * TimeOfDay subtracted = dt.withFieldAdded(DurationFieldType.seconds(), -6);
  * </pre>
  *
  * @param seconds the amount of seconds to subtract, may be negative
  * @return the new time minus the increased seconds
  * @since 1.1
  */
 public TimeOfDay minusSeconds(int seconds) {
   return withFieldAdded(DurationFieldType.seconds(), FieldUtils.safeNegate(seconds));
 }
コード例 #22
0
 public void testWithFieldAdded_DurationFieldType_int_4() {
   LocalTime test = new LocalTime(10, 20, 30, 40);
   LocalTime result = test.withFieldAdded(DurationFieldType.hours(), 0);
   assertSame(test, result);
 }
コード例 #23
0
  /**
   * Constructs a Partial with the specified fields and values. The fields must be specified in the
   * order largest to smallest. For year and weekyear fields with equal duration, year is defined as
   * being larger than weekyear.
   *
   * <p>The constructor uses the specified chronology.
   *
   * @param types the types to create the partial from, not null
   * @param values the values to store, not null
   * @param chronology the chronology, null means ISO
   * @throws IllegalArgumentException if the types or values are invalid
   */
  public Partial(DateTimeFieldType[] types, int[] values, Chronology chronology) {
    super();
    chronology = DateTimeUtils.getChronology(chronology).withUTC();
    iChronology = chronology;
    if (types == null) {
      throw new IllegalArgumentException("Types array must not be null");
    }
    if (values == null) {
      throw new IllegalArgumentException("Values array must not be null");
    }
    if (values.length != types.length) {
      throw new IllegalArgumentException("Values array must be the same length as the types array");
    }
    if (types.length == 0) {
      iTypes = types;
      iValues = values;
      return;
    }
    for (int i = 0; i < types.length; i++) {
      if (types[i] == null) {
        throw new IllegalArgumentException("Types array must not contain null: index " + i);
      }
    }
    DurationField lastUnitField = null;
    for (int i = 0; i < types.length; i++) {
      DateTimeFieldType loopType = types[i];
      DurationField loopUnitField = loopType.getDurationType().getField(iChronology);
      if (i > 0) {
        if (loopUnitField.isSupported() == false) {
          if (lastUnitField.isSupported()) {
            throw new IllegalArgumentException(
                "Types array must be in order largest-smallest: "
                    + types[i - 1].getName()
                    + " < "
                    + loopType.getName());
          } else {
            throw new IllegalArgumentException(
                "Types array must not contain duplicate unsupported: "
                    + types[i - 1].getName()
                    + " and "
                    + loopType.getName());
          }
        }
        int compare = lastUnitField.compareTo(loopUnitField);
        if (compare < 0) {
          throw new IllegalArgumentException(
              "Types array must be in order largest-smallest: "
                  + types[i - 1].getName()
                  + " < "
                  + loopType.getName());
        } else if (compare == 0) {
          if (lastUnitField.equals(loopUnitField)) {
            DurationFieldType lastRangeType = types[i - 1].getRangeDurationType();
            DurationFieldType loopRangeType = loopType.getRangeDurationType();
            if (lastRangeType == null) {
              if (loopRangeType == null) {
                throw new IllegalArgumentException(
                    "Types array must not contain duplicate: "
                        + types[i - 1].getName()
                        + " and "
                        + loopType.getName());
              }
            } else {
              if (loopRangeType == null) {
                throw new IllegalArgumentException(
                    "Types array must be in order largest-smallest: "
                        + types[i - 1].getName()
                        + " < "
                        + loopType.getName());
              }
              DurationField lastRangeField = lastRangeType.getField(iChronology);
              DurationField loopRangeField = loopRangeType.getField(iChronology);
              if (lastRangeField.compareTo(loopRangeField) < 0) {
                throw new IllegalArgumentException(
                    "Types array must be in order largest-smallest: "
                        + types[i - 1].getName()
                        + " < "
                        + loopType.getName());
              }
              if (lastRangeField.compareTo(loopRangeField) == 0) {
                throw new IllegalArgumentException(
                    "Types array must not contain duplicate: "
                        + types[i - 1].getName()
                        + " and "
                        + loopType.getName());
              }
            }
          } else {
            if (lastUnitField.isSupported()
                && lastUnitField.getType() != DurationFieldType.YEARS_TYPE) {
              throw new IllegalArgumentException(
                  "Types array must be in order largest-smallest,"
                      + " for year-based fields, years is defined as being largest: "
                      + types[i - 1].getName()
                      + " < "
                      + loopType.getName());
            }
          }
        }
      }
      lastUnitField = loopUnitField;
    }

    iTypes = (DateTimeFieldType[]) types.clone();
    chronology.validate(this, values);
    iValues = (int[]) values.clone();
  }
コード例 #24
0
 /**
  * Gets a period type that contains the duration types of the array.
  *
  * <p>Only the 8 standard duration field types are supported.
  *
  * @param types the types to include in the array.
  * @return the period type
  * @since 1.1
  */
 public static synchronized PeriodType forFields(DurationFieldType[] types) {
   if (types == null || types.length == 0) {
     throw new IllegalArgumentException("Types array must not be null or empty");
   }
   for (int i = 0; i < types.length; i++) {
     if (types[i] == null) {
       throw new IllegalArgumentException("Types array must not contain null");
     }
   }
   Map<PeriodType, PeriodType> cache = cTypes;
   if (cTypes.isEmpty()) {
     cache.put(standard(), standard());
     cache.put(yearMonthDayTime(), yearMonthDayTime());
     cache.put(yearMonthDay(), yearMonthDay());
     cache.put(yearWeekDayTime(), yearWeekDayTime());
     cache.put(yearWeekDay(), yearWeekDay());
     cache.put(yearDayTime(), yearDayTime());
     cache.put(yearDay(), yearDay());
     cache.put(dayTime(), dayTime());
     cache.put(time(), time());
     cache.put(years(), years());
     cache.put(months(), months());
     cache.put(weeks(), weeks());
     cache.put(days(), days());
     cache.put(hours(), hours());
     cache.put(minutes(), minutes());
     cache.put(seconds(), seconds());
     cache.put(millis(), millis());
   }
   PeriodType inPartType = new PeriodType(null, types, null);
   Object cached = cache.get(inPartType);
   if (cached instanceof PeriodType) {
     return (PeriodType) cached;
   }
   if (cached != null) {
     throw new IllegalArgumentException("PeriodType does not support fields: " + cached);
   }
   PeriodType type = standard();
   List<DurationFieldType> list = new ArrayList<DurationFieldType>(Arrays.asList(types));
   if (list.remove(DurationFieldType.years()) == false) {
     type = type.withYearsRemoved();
   }
   if (list.remove(DurationFieldType.months()) == false) {
     type = type.withMonthsRemoved();
   }
   if (list.remove(DurationFieldType.weeks()) == false) {
     type = type.withWeeksRemoved();
   }
   if (list.remove(DurationFieldType.days()) == false) {
     type = type.withDaysRemoved();
   }
   if (list.remove(DurationFieldType.hours()) == false) {
     type = type.withHoursRemoved();
   }
   if (list.remove(DurationFieldType.minutes()) == false) {
     type = type.withMinutesRemoved();
   }
   if (list.remove(DurationFieldType.seconds()) == false) {
     type = type.withSecondsRemoved();
   }
   if (list.remove(DurationFieldType.millis()) == false) {
     type = type.withMillisRemoved();
   }
   if (list.size() > 0) {
     //            cache.put(inPartType, list);
     throw new IllegalArgumentException("PeriodType does not support fields: " + list);
   }
   // recheck cache in case initial array order was wrong
   PeriodType checkPartType = new PeriodType(null, type.iTypes, null);
   PeriodType checkedType = (PeriodType) cache.get(checkPartType);
   if (checkedType != null) {
     cache.put(inPartType, checkedType);
     return checkedType;
   }
   cache.put(inPartType, type);
   return type;
 }
コード例 #25
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time minus the specified number of millis.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay subtracted = dt.minusMillis(6);
  * TimeOfDay subtracted = dt.minus(Period.millis(6));
  * TimeOfDay subtracted = dt.withFieldAdded(DurationFieldType.millis(), -6);
  * </pre>
  *
  * @param millis the amount of millis to subtract, may be negative
  * @return the new time minus the increased millis
  * @since 1.1
  */
 public TimeOfDay minusMillis(int millis) {
   return withFieldAdded(DurationFieldType.millis(), FieldUtils.safeNegate(millis));
 }
コード例 #26
0
ファイル: Years.java プロジェクト: ZihaoAllen/gwt-time
 /**
  * Creates a <code>Years</code> representing the number of whole years between the two specified
  * datetimes. This method corectly handles any daylight savings time changes that may occur during
  * the interval.
  *
  * @param start the start instant, must not be null
  * @param end the end instant, must not be null
  * @return the period in years
  * @throws IllegalArgumentException if the instants are null or invalid
  */
 public static Years yearsBetween(ReadableInstant start, ReadableInstant end) {
   int amount = BaseSingleFieldPeriod.between(start, end, DurationFieldType.years());
   return Years.years(amount);
 }
コード例 #27
0
ファイル: Weeks.java プロジェクト: 272152441/joda-time
 /**
  * Gets the duration field type, which is <code>weeks</code>.
  *
  * @return the period type
  */
 public DurationFieldType getFieldType() {
   return DurationFieldType.weeks();
 }
コード例 #28
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time plus the specified number of seconds.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay added = dt.plusSeconds(6);
  * TimeOfDay added = dt.plus(Period.seconds(6));
  * TimeOfDay added = dt.withFieldAdded(DurationFieldType.seconds(), 6);
  * </pre>
  *
  * @param seconds the amount of seconds to add, may be negative
  * @return the new time plus the increased seconds
  * @since 1.1
  */
 public TimeOfDay plusSeconds(int seconds) {
   return withFieldAdded(DurationFieldType.seconds(), seconds);
 }
コード例 #29
0
ファイル: Weeks.java プロジェクト: 272152441/joda-time
 /**
  * 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);
 }
コード例 #30
0
ファイル: TimeOfDay.java プロジェクト: kebernet/goda-cronic
 /**
  * Returns a copy of this time plus the specified number of hours.
  *
  * <p>This time instance is immutable and unaffected by this method call.
  *
  * <p>The following three lines are identical in effect:
  *
  * <pre>
  * TimeOfDay added = dt.plusHours(6);
  * TimeOfDay added = dt.plus(Period.hours(6));
  * TimeOfDay added = dt.withFieldAdded(DurationFieldType.hours(), 6);
  * </pre>
  *
  * @param hours the amount of hours to add, may be negative
  * @return the new time plus the increased hours
  * @since 1.1
  */
 public TimeOfDay plusHours(int hours) {
   return withFieldAdded(DurationFieldType.hours(), hours);
 }