コード例 #1
0
  /**
   * Parses a date-time from the given text, returning a new MutableDateTime.
   *
   * <p>The parse will use the zone and chronology specified on this formatter.
   *
   * <p>If the text contains a time zone string then that will be taken into account in adjusting
   * the time of day as follows. If the {@link #withOffsetParsed()} has been called, then the
   * resulting DateTime will have a fixed offset based on the parsed time zone. Otherwise the
   * resulting DateTime will have the zone of this formatter, but the parsed zone may have caused
   * the time to be adjusted.
   *
   * @param text the text to parse, not null
   * @return the parsed date-time, never null
   * @throws UnsupportedOperationException if parsing is not supported
   * @throws IllegalArgumentException if the text to parse is invalid
   */
  public MutableDateTime parseMutableDateTime(String text) {
    InternalParser parser = requireParser();

    Chronology chrono = selectChronology(null);
    DateTimeParserBucket bucket =
        new DateTimeParserBucket(0, chrono, iLocale, iPivotYear, iDefaultYear);
    int newPos = parser.parseInto(bucket, text, 0);
    if (newPos >= 0) {
      if (newPos >= text.length()) {
        long millis = bucket.computeMillis(true, text);
        if (iOffsetParsed && bucket.getOffsetInteger() != null) {
          int parsedOffset = bucket.getOffsetInteger();
          DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset);
          chrono = chrono.withZone(parsedZone);
        } else if (bucket.getZone() != null) {
          chrono = chrono.withZone(bucket.getZone());
        }
        MutableDateTime dt = new MutableDateTime(millis, chrono);
        if (iZone != null) {
          dt.setZone(iZone);
        }
        return dt;
      }
    } else {
      newPos = ~newPos;
    }
    throw new IllegalArgumentException(FormatUtils.createErrorMessage(text, newPos));
  }
コード例 #2
0
 /**
  * Parses a datetime from the given text, returning the number of milliseconds since the epoch,
  * 1970-01-01T00:00:00Z.
  *
  * <p>The parse will use the ISO chronology, and the default time zone. If the text contains a
  * time zone string then that will be taken into account.
  *
  * @param text the text to parse, not null
  * @return parsed value expressed in milliseconds since the epoch
  * @throws UnsupportedOperationException if parsing is not supported
  * @throws IllegalArgumentException if the text to parse is invalid
  */
 public long parseMillis(String text) {
   InternalParser parser = requireParser();
   Chronology chrono = selectChronology(iChrono);
   DateTimeParserBucket bucket =
       new DateTimeParserBucket(0, chrono, iLocale, iPivotYear, iDefaultYear);
   return bucket.doParseMillis(parser, text);
 }
コード例 #3
0
  /**
   * Parses a datetime from the given text, at the given position, saving the result into the fields
   * of the given ReadWritableInstant. If the parse succeeds, the return value is the new text
   * position. Note that the parse may succeed without fully reading the text and in this case those
   * fields that were read will be set.
   *
   * <p>Only those fields present in the string will be changed in the specified instant. All other
   * fields will remain unaltered. Thus if the string only contains a year and a month, then the day
   * and time will be retained from the input instant. If this is not the behaviour you want, then
   * reset the fields before calling this method, or use {@link #parseDateTime(String)} or {@link
   * #parseMutableDateTime(String)}.
   *
   * <p>If it fails, the return value is negative, but the instant may still be modified. To
   * determine the position where the parse failed, apply the one's complement operator (~) on the
   * return value.
   *
   * <p>This parse method ignores the {@link #getDefaultYear() default year} and parses using the
   * year from the supplied instant based on the chronology and time-zone of the supplied instant.
   *
   * <p>The parse will use the chronology of the instant.
   *
   * @param instant an instant that will be modified, not null
   * @param text the text to parse
   * @param position position to start parsing from
   * @return new position, negative value means parse failed - apply complement operator (~) to get
   *     position of failure
   * @throws UnsupportedOperationException if parsing is not supported
   * @throws IllegalArgumentException if the instant is null
   * @throws IllegalArgumentException if any field is out of range
   */
  public int parseInto(ReadWritableInstant instant, String text, int position) {
    InternalParser parser = requireParser();
    if (instant == null) {
      throw new IllegalArgumentException("Instant must not be null");
    }

    long instantMillis = instant.getMillis();
    Chronology chrono = instant.getChronology();
    int defaultYear = DateTimeUtils.getChronology(chrono).year().get(instantMillis);
    long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis);
    chrono = selectChronology(chrono);

    DateTimeParserBucket bucket =
        new DateTimeParserBucket(instantLocal, chrono, iLocale, iPivotYear, defaultYear);
    int newPos = parser.parseInto(bucket, text, position);
    instant.setMillis(bucket.computeMillis(false, text));
    if (iOffsetParsed && bucket.getOffsetInteger() != null) {
      int parsedOffset = bucket.getOffsetInteger();
      DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset);
      chrono = chrono.withZone(parsedZone);
    } else if (bucket.getZone() != null) {
      chrono = chrono.withZone(bucket.getZone());
    }
    instant.setChronology(chrono);
    if (iZone != null) {
      instant.setZone(iZone);
    }
    return newPos;
  }
コード例 #4
0
ファイル: TypeUtil.java プロジェクト: nkhuyu/jpmml
  @SuppressWarnings(value = {"deprecation"})
  private static Seconds parseSeconds(String value) {
    DateTimeFormatter format = SecondsSinceMidnight.getFormat();

    DateTimeParser parser = format.getParser();

    DateTimeParserBucket bucket = new DateTimeParserBucket(0, null, null);
    bucket.setZone(null);

    int result = parser.parseInto(bucket, value, 0);
    if (result >= 0 && result >= value.length()) {
      long millis = bucket.computeMillis(true);

      return Seconds.seconds((int) (millis / 1000L));
    }

    throw new IllegalArgumentException(value);
  }
コード例 #5
0
  /**
   * Parses only the local date-time from the given text, returning a new LocalDateTime.
   *
   * <p>This will parse the text fully according to the formatter, using the UTC zone. Once parsed,
   * only the local date-time will be used. This means that any parsed time-zone or offset field is
   * completely ignored. It also means that the zone and offset-parsed settings are ignored.
   *
   * @param text the text to parse, not null
   * @return the parsed date-time, never null
   * @throws UnsupportedOperationException if parsing is not supported
   * @throws IllegalArgumentException if the text to parse is invalid
   * @since 2.0
   */
  public LocalDateTime parseLocalDateTime(String text) {
    InternalParser parser = requireParser();

    Chronology chrono = selectChronology(null).withUTC(); // always use UTC, avoiding DST gaps
    DateTimeParserBucket bucket =
        new DateTimeParserBucket(0, chrono, iLocale, iPivotYear, iDefaultYear);
    int newPos = parser.parseInto(bucket, text, 0);
    if (newPos >= 0) {
      if (newPos >= text.length()) {
        long millis = bucket.computeMillis(true, text);
        if (bucket.getOffsetInteger() != null) { // treat withOffsetParsed() as being true
          int parsedOffset = bucket.getOffsetInteger();
          DateTimeZone parsedZone = DateTimeZone.forOffsetMillis(parsedOffset);
          chrono = chrono.withZone(parsedZone);
        } else if (bucket.getZone() != null) {
          chrono = chrono.withZone(bucket.getZone());
        }
        return new LocalDateTime(millis, chrono);
      }
    } else {
      newPos = ~newPos;
    }
    throw new IllegalArgumentException(FormatUtils.createErrorMessage(text, newPos));
  }
コード例 #6
0
 public int parseInto(DateTimeParserBucket bucket, String text, int position) {
   DateTimeParser p = getFormatter(bucket.getLocale()).getParser();
   return p.parseInto(bucket, text, position);
 }