Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Copyright 2001-2011 Stephen Colebourne
   *
   *  Licensed under the Apache License, Version 2.0 (the "License");
   *  you may not use this file except in compliance with the License.
   *  You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
 package org.joda.time.format;
 
 import java.io.Writer;
 
Controls the printing and parsing of a datetime to and from a string.

This class is the main API for printing and parsing used by most applications. Instances of this class are created via one of three factory classes:

An instance of this class holds a reference internally to one printer and one parser. It is possible that one of these may be null, in which case the formatter cannot print/parse. This can be checked via the isPrinter() and isParser() methods.

The underlying printer/parser can be altered to behave exactly as required by using one of the decorator modifiers:

Each of these returns a new formatter (instances of this class are immutable).

The main methods of the class are the printXxx and parseXxx methods. These are used as follows:

 // print using the defaults (default locale, chronology/zone of the datetime)
 String dateStr = formatter.print(dt);
 // print using the French locale
 String dateStr = formatter.withLocale(Locale.FRENCH).print(dt);
 // print using the UTC zone
 String dateStr = formatter.withZone(DateTimeZone.UTC).print(dt);
 
 // parse using the Paris zone
 DateTime date = formatter.withZone(DateTimeZone.forID("Europe/Paris")).parseDateTime(str);
 

Author(s):
Brian S O'Neill
Stephen Colebourne
Fredrik Borgh
Since:
1.0
 
 public class DateTimeFormatter {

    
The internal printer used to output the datetime.
 
     private final DateTimePrinter iPrinter;
    
The internal parser used to output the datetime.
 
     private final DateTimeParser iParser;
    
The locale to use for printing and parsing.
 
     private final Locale iLocale;
    
Whether the offset is parsed.
 
     private final boolean iOffsetParsed;
    
The chronology to use as an override.
 
     private final Chronology iChrono;
    
The zone to use as an override.
 
     private final DateTimeZone iZone;
    
The pivot year to use for two-digit year parsing.
 
     private final Integer iPivotYear;
    
The default year for parsing month/day without year.
 
     private final int iDefaultYear;

    
Creates a new formatter, however you will normally use the factory or the builder.

Parameters:
printer the internal printer, null if cannot print
parser the internal parser, null if cannot parse
    public DateTimeFormatter(
            DateTimePrinter printerDateTimeParser parser) {
        super();
         = printer;
         = parser;
         = null;
         = false;
         = null;
         = null;
         = null;
         = 2000;
    }

    
Constructor.
    private DateTimeFormatter(
            DateTimePrinter printerDateTimeParser parser,
            Locale localeboolean offsetParsed,
            Chronology chronoDateTimeZone zone,
            Integer pivotYearint defaultYear) {
        super();
         = printer;
         = parser;
         = locale;
         = offsetParsed;
         = chrono;
         = zone;
         = pivotYear;
         = defaultYear;
    }
    //-----------------------------------------------------------------------
    
Is this formatter capable of printing.

Returns:
true if this is a printer
    public boolean isPrinter() {
        return ( != null);
    }

    
Gets the internal printer object that performs the real printing work.

Returns:
the internal printer; is null if printing not supported
    public DateTimePrinter getPrinter() {
        return ;
    }

    
Is this formatter capable of parsing.

Returns:
true if this is a parser
    public boolean isParser() {
        return ( != null);
    }

    
Gets the internal parser object that performs the real parsing work.

Returns:
the internal parser; is null if parsing not supported
    public DateTimeParser getParser() {
        return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter with a different locale that will be used for printing and parsing.

A DateTimeFormatter is immutable, so a new instance is returned, and the original is unaltered and still usable.

Parameters:
locale the locale to use; if null, formatter uses default locale at invocation time
Returns:
the new formatter
    public DateTimeFormatter withLocale(Locale locale) {
        if (locale == getLocale() || (locale != null && locale.equals(getLocale()))) {
            return this;
        }
        return new DateTimeFormatter(locale,
                );
    }

    
Gets the locale that will be used for printing and parsing.

Returns:
the locale to use; if null, formatter uses default locale at invocation time
    public Locale getLocale() {
        return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter that will create a datetime with a time zone equal to that of the offset of the parsed string.

After calling this method, a string '2004-06-09T10:20:30-08:00' will create a datetime with a zone of -08:00 (a fixed zone, with no daylight savings rules). If the parsed string represents a local time (no zone offset) the parsed datetime will be in the default zone.

Calling this method sets the override zone to null. Calling the override zone method sets this flag off.

Returns:
the new formatter
        if ( == true) {
            return this;
        }
        return new DateTimeFormatter(,
                truenull);
    }

    
Checks whether the offset from the string is used as the zone of the parsed datetime.

Returns:
true if the offset from the string is used as the zone
    public boolean isOffsetParsed() {
        return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter that will use the specified chronology in preference to that of the printed object, or ISO on a parse.

When printing, this chronolgy will be used in preference to the chronology from the datetime that would otherwise be used.

When parsing, this chronology will be set on the parsed datetime.

A null chronology means no-override. If both an override chronology and an override zone are set, the override zone will take precedence over the zone in the chronology.

Parameters:
chrono the chronology to use as an override
Returns:
the new formatter
    public DateTimeFormatter withChronology(Chronology chrono) {
        if ( == chrono) {
            return this;
        }
        return new DateTimeFormatter(,
                chrono);
    }

    
Gets the chronology to use as an override.

Returns:
the chronology to use as an override
    public Chronology getChronology() {
        return ;
    }

    
Gets the chronology to use as an override.

Deprecated:
Use the method with the correct spelling
Returns:
the chronology to use as an override
    @Deprecated
    public Chronology getChronolgy() {
        return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter that will use the UTC zone in preference to the zone of the printed object, or default zone on a parse.

When printing, UTC will be used in preference to the zone from the datetime that would otherwise be used.

When parsing, UTC will be set on the parsed datetime.

If both an override chronology and an override zone are set, the override zone will take precedence over the zone in the chronology.

Returns:
the new formatter, never null
Since:
2.0
    public DateTimeFormatter withZoneUTC() {
        return withZone(.);
    }

    
Returns a new formatter that will use the specified zone in preference to the zone of the printed object, or default zone on a parse.

When printing, this zone will be used in preference to the zone from the datetime that would otherwise be used.

When parsing, this zone will be set on the parsed datetime.

A null zone means of no-override. If both an override chronology and an override zone are set, the override zone will take precedence over the zone in the chronology.

Parameters:
zone the zone to use as an override
Returns:
the new formatter
    public DateTimeFormatter withZone(DateTimeZone zone) {
        if ( == zone) {
            return this;
        }
        return new DateTimeFormatter(,
                falsezone);
    }

    
Gets the zone to use as an override.

Returns:
the zone to use as an override
    public DateTimeZone getZone() {
        return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter that will use the specified pivot year for two digit year parsing in preference to that stored in the parser.

This setting is useful for changing the pivot year of formats built using a pattern - DateTimeFormat.forPattern(java.lang.String).

When parsing, this pivot year is used. Null means no-override. There is no effect when printing.

The pivot year enables a two digit year to be converted to a four digit year. The pivot represents the year in the middle of the supported range of years. Thus the full range of years that will be built is (pivot - 50) .. (pivot + 49).

 pivot   supported range   00 is   20 is   40 is   60 is   80 is
 ---------------------------------------------------------------
 1950      1900..1999      1900    1920    1940    1960    1980
 1975      1925..2024      2000    2020    1940    1960    1980
 2000      1950..2049      2000    2020    2040    1960    1980
 2025      1975..2074      2000    2020    2040    2060    1980
 2050      2000..2099      2000    2020    2040    2060    2080
 

Parameters:
pivotYear the pivot year to use as an override when parsing
Returns:
the new formatter
Since:
1.1
    public DateTimeFormatter withPivotYear(Integer pivotYear) {
        if ( == pivotYear || ( != null && .equals(pivotYear))) {
            return this;
        }
        return new DateTimeFormatter(,
                pivotYear);
    }

    
Returns a new formatter that will use the specified pivot year for two digit year parsing in preference to that stored in the parser.

This setting is useful for changing the pivot year of formats built using a pattern - DateTimeFormat.forPattern(java.lang.String).

When parsing, this pivot year is used. There is no effect when printing.

The pivot year enables a two digit year to be converted to a four digit year. The pivot represents the year in the middle of the supported range of years. Thus the full range of years that will be built is (pivot - 50) .. (pivot + 49).

 pivot   supported range   00 is   20 is   40 is   60 is   80 is
 ---------------------------------------------------------------
 1950      1900..1999      1900    1920    1940    1960    1980
 1975      1925..2024      2000    2020    1940    1960    1980
 2000      1950..2049      2000    2020    2040    1960    1980
 2025      1975..2074      2000    2020    2040    2060    1980
 2050      2000..2099      2000    2020    2040    2060    2080
 

Parameters:
pivotYear the pivot year to use as an override when parsing
Returns:
the new formatter
Since:
1.1
    public DateTimeFormatter withPivotYear(int pivotYear) {
        return withPivotYear(Integer.valueOf(pivotYear));
    }

    
Gets the pivot year to use as an override.

Returns:
the pivot year to use as an override
Since:
1.1
    public Integer getPivotYear() {
      return ;
    }
    //-----------------------------------------------------------------------
    
Returns a new formatter that will use the specified default year.

The default year is used when parsing in the case where there is a month or a day but not a year. Specifically, it is used if there is a field parsed with a duration between the length of a month and the length of a day inclusive.

This value is typically used to move the year from 1970 to a leap year to enable February 29th to be parsed. Unless customised, the year 2000 is used.

This setting has no effect when printing.

Parameters:
defaultYear the default year to use
Returns:
the new formatter, not null
Since:
2.0
    public DateTimeFormatter withDefaultYear(int defaultYear) {
        return new DateTimeFormatter(,
                defaultYear);
    }

    
Gets the default year for parsing months and days.

Returns:
the default year for parsing months and days
Since:
2.0
    public int getDefaultYear() {
      return ;
    }
    //-----------------------------------------------------------------------
    
Prints a ReadableInstant, using the chronology supplied by the instant.

Parameters:
buf the destination to format to, not null
instant instant to format, null means now
    public void printTo(StringBuffer bufReadableInstant instant) {
        long millis = DateTimeUtils.getInstantMillis(instant);
        Chronology chrono = DateTimeUtils.getInstantChronology(instant);
        printTo(bufmillischrono);
    }

    
Prints a ReadableInstant, using the chronology supplied by the instant.

Parameters:
out the destination to format to, not null
instant instant to format, null means now
    public void printTo(Writer outReadableInstant instantthrows IOException {
        long millis = DateTimeUtils.getInstantMillis(instant);
        Chronology chrono = DateTimeUtils.getInstantChronology(instant);
        printTo(outmillischrono);
    }

    
Prints a ReadableInstant, using the chronology supplied by the instant.

Parameters:
appendable the destination to format to, not null
instant instant to format, null means now
Since:
2.0
    public void printTo(Appendable appendableReadableInstant instantthrows IOException {
        appendable.append(print(instant));
    }
    //-----------------------------------------------------------------------
    
Prints an instant from milliseconds since 1970-01-01T00:00:00Z, using ISO chronology in the default DateTimeZone.

Parameters:
buf the destination to format to, not null
instant millis since 1970-01-01T00:00:00Z
    public void printTo(StringBuffer buflong instant) {
        printTo(bufinstantnull);
    }

    
Prints an instant from milliseconds since 1970-01-01T00:00:00Z, using ISO chronology in the default DateTimeZone.

Parameters:
out the destination to format to, not null
instant millis since 1970-01-01T00:00:00Z
    public void printTo(Writer outlong instantthrows IOException {
        printTo(outinstantnull);
    }

    
Prints an instant from milliseconds since 1970-01-01T00:00:00Z, using ISO chronology in the default DateTimeZone.

Parameters:
appendable the destination to format to, not null
instant millis since 1970-01-01T00:00:00Z
Since:
2.0
    public void printTo(Appendable appendablelong instantthrows IOException {
        appendable.append(print(instant));
    }
    //-----------------------------------------------------------------------
    
Prints a ReadablePartial.

Neither the override chronology nor the override zone are used by this method.

Parameters:
buf the destination to format to, not null
partial partial to format
    public void printTo(StringBuffer bufReadablePartial partial) {
        DateTimePrinter printer = requirePrinter();
        if (partial == null) {
            throw new IllegalArgumentException("The partial must not be null");
        }
        printer.printTo(bufpartial);
    }

    
Prints a ReadablePartial.

Neither the override chronology nor the override zone are used by this method.

Parameters:
out the destination to format to, not null
partial partial to format
    public void printTo(Writer outReadablePartial partialthrows IOException {
        DateTimePrinter printer = requirePrinter();
        if (partial == null) {
            throw new IllegalArgumentException("The partial must not be null");
        }
        printer.printTo(outpartial);
    }

    
Prints a ReadablePartial.

Neither the override chronology nor the override zone are used by this method.

Parameters:
appendable the destination to format to, not null
partial partial to format
Since:
2.0
    public void printTo(Appendable appendableReadablePartial partialthrows IOException {
        appendable.append(print(partial));
    }
    //-----------------------------------------------------------------------
    
Prints a ReadableInstant to a String.

This method will use the override zone and the override chronololgy if they are set. Otherwise it will use the chronology and zone of the instant.

Parameters:
instant instant to format, null means now
Returns:
the printed result
    public String print(ReadableInstant instant) {
        printTo(bufinstant);
        return buf.toString();
    }

    
Prints a millisecond instant to a String.

This method will use the override zone and the override chronololgy if they are set. Otherwise it will use the ISO chronology and default zone.

Parameters:
instant millis since 1970-01-01T00:00:00Z
Returns:
the printed result
    public String print(long instant) {
        printTo(bufinstant);
        return buf.toString();
    }

    
Prints a ReadablePartial to a new String.

Neither the override chronology nor the override zone are used by this method.

Parameters:
partial partial to format
Returns:
the printed result
    public String print(ReadablePartial partial) {
        printTo(bufpartial);
        return buf.toString();
    }
    private void printTo(StringBuffer buflong instantChronology chrono) {
        DateTimePrinter printer = requirePrinter();
        chrono = selectChronology(chrono);
        // Shift instant into local time (UTC) to avoid excessive offset
        // calculations when printing multiple fields in a composite printer.
        DateTimeZone zone = chrono.getZone();
        int offset = zone.getOffset(instant);
        long adjustedInstant = instant + offset;
        if ((instant ^ adjustedInstant) < 0 && (instant ^ offset) >= 0) {
            // Time zone offset overflow, so revert to UTC.
            zone = .;
            offset = 0;
            adjustedInstant = instant;
        }
        printer.printTo(bufadjustedInstantchrono.withUTC(), offsetzone);
    }
    private void printTo(Writer buflong instantChronology chronothrows IOException {
        DateTimePrinter printer = requirePrinter();
        chrono = selectChronology(chrono);
        // Shift instant into local time (UTC) to avoid excessive offset
        // calculations when printing multiple fields in a composite printer.
        DateTimeZone zone = chrono.getZone();
        int offset = zone.getOffset(instant);
        long adjustedInstant = instant + offset;
        if ((instant ^ adjustedInstant) < 0 && (instant ^ offset) >= 0) {
            // Time zone offset overflow, so revert to UTC.
            zone = .;
            offset = 0;
            adjustedInstant = instant;
        }
        printer.printTo(bufadjustedInstantchrono.withUTC(), offsetzone);
    }

    
Checks whether printing is supported.

Throws:
java.lang.UnsupportedOperationException if printing is not supported
    private DateTimePrinter requirePrinter() {
        DateTimePrinter printer = ;
        if (printer == null) {
            throw new UnsupportedOperationException("Printing not supported");
        }
        return printer;
    }
    //-----------------------------------------------------------------------
    
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.

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 parseDateTime(java.lang.String) or parseMutableDateTime(java.lang.String).

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.

The parse will use the chronology of the instant.

Parameters:
instant an instant that will be modified, not null
text the text to parse
position position to start parsing from
Returns:
new position, negative value means parse failed - apply complement operator (~) to get position of failure
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the instant is null
java.lang.IllegalArgumentException if any field is out of range
    public int parseInto(ReadWritableInstant instantString textint position) {
        DateTimeParser parser = requireParser();
        if (instant == null) {
            throw new IllegalArgumentException("Instant must not be null");
        }
        
        long instantMillis = instant.getMillis();
        Chronology chrono = instant.getChronology();
        long instantLocal = instantMillis + chrono.getZone().getOffset(instantMillis);
        chrono = selectChronology(chrono);
        
        DateTimeParserBucket bucket = new DateTimeParserBucket(
            instantLocalchrono);
        int newPos = parser.parseInto(buckettextposition);
        instant.setMillis(bucket.computeMillis(falsetext));
        if ( && 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 ( != null) {
            instant.setZone();
        }
        return newPos;
    }

    
Parses a datetime from the given text, returning the number of milliseconds since the epoch, 1970-01-01T00:00:00Z.

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.

Parameters:
text text to parse
Returns:
parsed value expressed in milliseconds since the epoch
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
    public long parseMillis(String text) {
        DateTimeParser parser = requireParser();
        
        Chronology chrono = selectChronology();
        DateTimeParserBucket bucket = new DateTimeParserBucket(0, chrono);
        int newPos = parser.parseInto(buckettext, 0);
        if (newPos >= 0) {
            if (newPos >= text.length()) {
                return bucket.computeMillis(truetext);
            }
        } else {
            newPos = ~newPos;
        }
        throw new IllegalArgumentException(FormatUtils.createErrorMessage(textnewPos));
    }

    
Parses only the local date from the given text, returning a new LocalDate.

This will parse the text fully according to the formatter, using the UTC zone. Once parsed, only the local date will be used. This means that any parsed time, time-zone or offset field is completely ignored. It also means that the zone and offset-parsed settings are ignored.

Parameters:
text the text to parse, not null
Returns:
the parsed date, never null
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
Since:
2.0
    public LocalDate parseLocalDate(String text) {
        return parseLocalDateTime(text).toLocalDate();
    }

    
Parses only the local time from the given text, returning a new LocalDate.

This will parse the text fully according to the formatter, using the UTC zone. Once parsed, only the local time will be used. This means that any parsed date, time-zone or offset field is completely ignored. It also means that the zone and offset-parsed settings are ignored.

Parameters:
text the text to parse, not null
Returns:
the parsed time, never null
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
Since:
2.0
    public LocalTime parseLocalTime(String text) {
        return parseLocalDateTime(text).toLocalTime();
    }

    
Parses only the local date-time from the given text, returning a new LocalDate.

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.

Parameters:
text the text to parse, not null
Returns:
the parsed date-time, never null
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
Since:
2.0
    public LocalDateTime parseLocalDateTime(String text) {
        DateTimeParser parser = requireParser();
        
        Chronology chrono = selectChronology(null).withUTC();  // always use UTC, avoiding DST gaps
        DateTimeParserBucket bucket = new DateTimeParserBucket(0, chrono);
        int newPos = parser.parseInto(buckettext, 0);
        if (newPos >= 0) {
            if (newPos >= text.length()) {
                long millis = bucket.computeMillis(truetext);
                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(millischrono);
            }
        } else {
            newPos = ~newPos;
        }
        throw new IllegalArgumentException(FormatUtils.createErrorMessage(textnewPos));
    }

    
Parses a date-time from the given text, returning a new DateTime.

The parse will use the zone and chronology specified on this formatter.

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 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.

Parameters:
text the text to parse, not null
Returns:
the parsed date-time, never null
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
    public DateTime parseDateTime(String text) {
        DateTimeParser parser = requireParser();
        
        Chronology chrono = selectChronology(null);
        DateTimeParserBucket bucket = new DateTimeParserBucket(0, chrono);
        int newPos = parser.parseInto(buckettext, 0);
        if (newPos >= 0) {
            if (newPos >= text.length()) {
                long millis = bucket.computeMillis(truetext);
                if ( && 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());
                }
                DateTime dt = new DateTime(millischrono);
                if ( != null) {
                    dt = dt.withZone();
                }
                return dt;
            }
        } else {
            newPos = ~newPos;
        }
        throw new IllegalArgumentException(FormatUtils.createErrorMessage(textnewPos));
    }

    
Parses a date-time from the given text, returning a new MutableDateTime.

The parse will use the zone and chronology specified on this formatter.

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 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.

Parameters:
text the text to parse, not null
Returns:
the parsed date-time, never null
Throws:
java.lang.UnsupportedOperationException if parsing is not supported
java.lang.IllegalArgumentException if the text to parse is invalid
        DateTimeParser parser = requireParser();
        
        Chronology chrono = selectChronology(null);
        DateTimeParserBucket bucket = new DateTimeParserBucket(0, chrono);
        int newPos = parser.parseInto(buckettext, 0);
        if (newPos >= 0) {
            if (newPos >= text.length()) {
                long millis = bucket.computeMillis(truetext);
                if ( && 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(millischrono);
                if ( != null) {
                    dt.setZone();
                }
                return dt;
            }
        } else {
            newPos = ~newPos;
        }
        throw new IllegalArgumentException(FormatUtils.createErrorMessage(textnewPos));
    }

    
Checks whether parsing is supported.

Throws:
java.lang.UnsupportedOperationException if parsing is not supported
    private DateTimeParser requireParser() {
        DateTimeParser parser = ;
        if (parser == null) {
            throw new UnsupportedOperationException("Parsing not supported");
        }
        return parser;
    }
    //-----------------------------------------------------------------------
    
Determines the correct chronology to use.

Parameters:
chrono the proposed chronology
Returns:
the actual chronology
    private Chronology selectChronology(Chronology chrono) {
        chrono = DateTimeUtils.getChronology(chrono);
        if ( != null) {
            chrono = ;
        }
        if ( != null) {
            chrono = chrono.withZone();
        }
        return chrono;
    }
New to GrepCode? Check out our FAQ X