/*
* 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 com.facebook.presto.jdbc.internal.joda.time.format;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import com.facebook.presto.jdbc.internal.joda.time.Chronology;
import com.facebook.presto.jdbc.internal.joda.time.DateTimeConstants;
import com.facebook.presto.jdbc.internal.joda.time.DateTimeField;
import com.facebook.presto.jdbc.internal.joda.time.DateTimeFieldType;
import com.facebook.presto.jdbc.internal.joda.time.DateTimeZone;
import com.facebook.presto.jdbc.internal.joda.time.MutableDateTime;
import com.facebook.presto.jdbc.internal.joda.time.ReadablePartial;
import com.facebook.presto.jdbc.internal.joda.time.MutableDateTime.Property;
import com.facebook.presto.jdbc.internal.joda.time.field.MillisDurationField;
import com.facebook.presto.jdbc.internal.joda.time.field.PreciseDateTimeField;
/**
* Factory that creates complex instances of DateTimeFormatter via method calls.
* <p>
* Datetime formatting is performed by the {@link DateTimeFormatter} class.
* Three classes provide factory methods to create formatters, and this is one.
* The others are {@link DateTimeFormat} and {@link ISODateTimeFormat}.
* <p>
* DateTimeFormatterBuilder is used for constructing formatters which are then
* used to print or parse. The formatters are built by appending specific fields
* or other formatters to an instance of this builder.
* <p>
* For example, a formatter that prints month and year, like "January 1970",
* can be constructed as follows:
* <p>
* <pre>
* DateTimeFormatter monthAndYear = new DateTimeFormatterBuilder()
* .appendMonthOfYearText()
* .appendLiteral(' ')
* .appendYear(4, 4)
* .toFormatter();
* </pre>
* <p>
* DateTimeFormatterBuilder itself is mutable and not thread-safe, but the
* formatters that it builds are thread-safe and immutable.
*
* @author Brian S O'Neill
* @author Stephen Colebourne
* @author Fredrik Borgh
* @since 1.0
* @see DateTimeFormat
* @see ISODateTimeFormat
*/
public class DateTimeFormatterBuilder {
/** Array of printers and parsers (alternating). */
private ArrayList<Object> iElementPairs;
/** Cache of the last returned formatter. */
private Object iFormatter;
//-----------------------------------------------------------------------
/**
* Creates a DateTimeFormatterBuilder.
*/
public DateTimeFormatterBuilder() {
super();
iElementPairs = new ArrayList<Object>();
}
//-----------------------------------------------------------------------
/**
* Constructs a DateTimeFormatter using all the appended elements.
* <p>
* This is the main method used by applications at the end of the build
* process to create a usable formatter.
* <p>
* Subsequent changes to this builder do not affect the returned formatter.
* <p>
* The returned formatter may not support both printing and parsing.
* The methods {@link DateTimeFormatter#isPrinter()} and
* {@link DateTimeFormatter#isParser()} will help you determine the state
* of the formatter.
*
* @throws UnsupportedOperationException if neither printing nor parsing is supported
*/
public DateTimeFormatter toFormatter() {
Object f = getFormatter();
DateTimePrinter printer = null;
if (isPrinter(f)) {
printer = (DateTimePrinter) f;
}
DateTimeParser parser = null;
if (isParser(f)) {
parser = (DateTimeParser) f;
}
if (printer != null || parser != null) {
return new DateTimeFormatter(printer, parser);
}
throw new UnsupportedOperationException("Both printing and parsing not supported");
}
/**
* Internal method to create a DateTimePrinter instance using all the
* appended elements.
* <p>
* Most applications will not use this method.
* If you want a printer in an application, call {@link #toFormatter()}
* and just use the printing API.
* <p>
* Subsequent changes to this builder do not affect the returned printer.
*
* @throws UnsupportedOperationException if printing is not supported
*/
public DateTimePrinter toPrinter() {
Object f = getFormatter();
if (isPrinter(f)) {
return (DateTimePrinter) f;
}
throw new UnsupportedOperationException("Printing is not supported");
}
/**
* Internal method to create a DateTimeParser instance using all the
* appended elements.
* <p>
* Most applications will not use this method.
* If you want a parser in an application, call {@link #toFormatter()}
* and just use the parsing API.
* <p>
* Subsequent changes to this builder do not affect the returned parser.
*
* @throws UnsupportedOperationException if parsing is not supported
*/
public DateTimeParser toParser() {
Object f = getFormatter();
if (isParser(f)) {
return (DateTimeParser) f;
}
throw new UnsupportedOperationException("Parsing is not supported");
}
//-----------------------------------------------------------------------
/**
* Returns true if toFormatter can be called without throwing an
* UnsupportedOperationException.
*
* @return true if a formatter can be built
*/
public boolean canBuildFormatter() {
return isFormatter(getFormatter());
}
/**
* Returns true if toPrinter can be called without throwing an
* UnsupportedOperationException.
*
* @return true if a printer can be built
*/
public boolean canBuildPrinter() {
return isPrinter(getFormatter());
}
/**
* Returns true if toParser can be called without throwing an
* UnsupportedOperationException.
*
* @return true if a parser can be built
*/
public boolean canBuildParser() {
return isParser(getFormatter());
}
//-----------------------------------------------------------------------
/**
* Clears out all the appended elements, allowing this builder to be
* reused.
*/
public void clear() {
iFormatter = null;
iElementPairs.clear();
}
//-----------------------------------------------------------------------
/**
* Appends another formatter.
*
* @param formatter the formatter to add
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if formatter is null or of an invalid type
*/
public DateTimeFormatterBuilder append(DateTimeFormatter formatter) {
if (formatter == null) {
throw new IllegalArgumentException("No formatter supplied");
}
return append0(formatter.getPrinter(), formatter.getParser());
}
/**
* Appends just a printer. With no matching parser, a parser cannot be
* built from this DateTimeFormatterBuilder.
*
* @param printer the printer to add
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if printer is null or of an invalid type
*/
public DateTimeFormatterBuilder append(DateTimePrinter printer) {
checkPrinter(printer);
return append0(printer, null);
}
/**
* Appends just a parser. With no matching printer, a printer cannot be
* built from this builder.
*
* @param parser the parser to add
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if parser is null or of an invalid type
*/
public DateTimeFormatterBuilder append(DateTimeParser parser) {
checkParser(parser);
return append0(null, parser);
}
/**
* Appends a printer/parser pair.
*
* @param printer the printer to add
* @param parser the parser to add
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if printer or parser is null or of an invalid type
*/
public DateTimeFormatterBuilder append(DateTimePrinter printer, DateTimeParser parser) {
checkPrinter(printer);
checkParser(parser);
return append0(printer, parser);
}
/**
* Appends a printer and a set of matching parsers. When parsing, the first
* parser in the list is selected for parsing. If it fails, the next is
* chosen, and so on. If none of these parsers succeeds, then the failed
* position of the parser that made the greatest progress is returned.
* <p>
* Only the printer is optional. In addition, it is illegal for any but the
* last of the parser array elements to be null. If the last element is
* null, this represents the empty parser. The presence of an empty parser
* indicates that the entire array of parse formats is optional.
*
* @param printer the printer to add
* @param parsers the parsers to add
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if any printer or parser is of an invalid type
* @throws IllegalArgumentException if any parser element but the last is null
*/
public DateTimeFormatterBuilder append(DateTimePrinter printer, DateTimeParser[] parsers) {
if (printer != null) {
checkPrinter(printer);
}
if (parsers == null) {
throw new IllegalArgumentException("No parsers supplied");
}
int length = parsers.length;
if (length == 1) {
if (parsers[0] == null) {
throw new IllegalArgumentException("No parser supplied");
}
return append0(printer, parsers[0]);
}
DateTimeParser[] copyOfParsers = new DateTimeParser[length];
int i;
for (i = 0; i < length - 1; i++) {
if ((copyOfParsers[i] = parsers[i]) == null) {
throw new IllegalArgumentException("Incomplete parser array");
}
}
copyOfParsers[i] = parsers[i];
return append0(printer, new MatchingParser(copyOfParsers));
}
/**
* Appends just a parser element which is optional. With no matching
* printer, a printer cannot be built from this DateTimeFormatterBuilder.
*
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if parser is null or of an invalid type
*/
public DateTimeFormatterBuilder appendOptional(DateTimeParser parser) {
checkParser(parser);
DateTimeParser[] parsers = new DateTimeParser[] {parser, null};
return append0(null, new MatchingParser(parsers));
}
//-----------------------------------------------------------------------
/**
* Checks if the parser is non null and a provider.
*
* @param parser the parser to check
*/
private void checkParser(DateTimeParser parser) {
if (parser == null) {
throw new IllegalArgumentException("No parser supplied");
}
}
/**
* Checks if the printer is non null and a provider.
*
* @param printer the printer to check
*/
private void checkPrinter(DateTimePrinter printer) {
if (printer == null) {
throw new IllegalArgumentException("No printer supplied");
}
}
private DateTimeFormatterBuilder append0(Object element) {
iFormatter = null;
// Add the element as both a printer and parser.
iElementPairs.add(element);
iElementPairs.add(element);
return this;
}
private DateTimeFormatterBuilder append0(
DateTimePrinter printer, DateTimeParser parser) {
iFormatter = null;
iElementPairs.add(printer);
iElementPairs.add(parser);
return this;
}
//-----------------------------------------------------------------------
/**
* Instructs the printer to emit a specific character, and the parser to
* expect it. The parser is case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendLiteral(char c) {
return append0(new CharacterLiteral(c));
}
/**
* Instructs the printer to emit specific text, and the parser to expect
* it. The parser is case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if text is null
*/
public DateTimeFormatterBuilder appendLiteral(String text) {
if (text == null) {
throw new IllegalArgumentException("Literal must not be null");
}
switch (text.length()) {
case 0:
return this;
case 1:
return append0(new CharacterLiteral(text.charAt(0)));
default:
return append0(new StringLiteral(text));
}
}
/**
* Instructs the printer to emit a field value as a decimal number, and the
* parser to expect an unsigned decimal number.
*
* @param fieldType type of field to append
* @param minDigits minimum number of digits to <i>print</i>
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null
*/
public DateTimeFormatterBuilder appendDecimal(
DateTimeFieldType fieldType, int minDigits, int maxDigits) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
if (maxDigits < minDigits) {
maxDigits = minDigits;
}
if (minDigits < 0 || maxDigits <= 0) {
throw new IllegalArgumentException();
}
if (minDigits <= 1) {
return append0(new UnpaddedNumber(fieldType, maxDigits, false));
} else {
return append0(new PaddedNumber(fieldType, maxDigits, false, minDigits));
}
}
/**
* Instructs the printer to emit a field value as a fixed-width decimal
* number (smaller numbers will be left-padded with zeros), and the parser
* to expect an unsigned decimal number with the same fixed width.
*
* @param fieldType type of field to append
* @param numDigits the exact number of digits to parse or print, except if
* printed value requires more digits
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null or if <code>numDigits <= 0</code>
* @since 1.5
*/
public DateTimeFormatterBuilder appendFixedDecimal(
DateTimeFieldType fieldType, int numDigits) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
if (numDigits <= 0) {
throw new IllegalArgumentException("Illegal number of digits: " + numDigits);
}
return append0(new FixedNumber(fieldType, numDigits, false));
}
/**
* Instructs the printer to emit a field value as a decimal number, and the
* parser to expect a signed decimal number.
*
* @param fieldType type of field to append
* @param minDigits minimum number of digits to <i>print</i>
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null
*/
public DateTimeFormatterBuilder appendSignedDecimal(
DateTimeFieldType fieldType, int minDigits, int maxDigits) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
if (maxDigits < minDigits) {
maxDigits = minDigits;
}
if (minDigits < 0 || maxDigits <= 0) {
throw new IllegalArgumentException();
}
if (minDigits <= 1) {
return append0(new UnpaddedNumber(fieldType, maxDigits, true));
} else {
return append0(new PaddedNumber(fieldType, maxDigits, true, minDigits));
}
}
/**
* Instructs the printer to emit a field value as a fixed-width decimal
* number (smaller numbers will be left-padded with zeros), and the parser
* to expect an signed decimal number with the same fixed width.
*
* @param fieldType type of field to append
* @param numDigits the exact number of digits to parse or print, except if
* printed value requires more digits
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null or if <code>numDigits <= 0</code>
* @since 1.5
*/
public DateTimeFormatterBuilder appendFixedSignedDecimal(
DateTimeFieldType fieldType, int numDigits) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
if (numDigits <= 0) {
throw new IllegalArgumentException("Illegal number of digits: " + numDigits);
}
return append0(new FixedNumber(fieldType, numDigits, true));
}
/**
* Instructs the printer to emit a field value as text, and the
* parser to expect text.
*
* @param fieldType type of field to append
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null
*/
public DateTimeFormatterBuilder appendText(DateTimeFieldType fieldType) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
return append0(new TextField(fieldType, false));
}
/**
* Instructs the printer to emit a field value as short text, and the
* parser to expect text.
*
* @param fieldType type of field to append
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null
*/
public DateTimeFormatterBuilder appendShortText(DateTimeFieldType fieldType) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
return append0(new TextField(fieldType, true));
}
/**
* Instructs the printer to emit a remainder of time as a decimal fraction,
* without decimal point. For example, if the field is specified as
* minuteOfHour and the time is 12:30:45, the value printed is 75. A
* decimal point is implied, so the fraction is 0.75, or three-quarters of
* a minute.
*
* @param fieldType type of field to append
* @param minDigits minimum number of digits to print.
* @param maxDigits maximum number of digits to print or parse.
* @return this DateTimeFormatterBuilder, for chaining
* @throws IllegalArgumentException if field type is null
*/
public DateTimeFormatterBuilder appendFraction(
DateTimeFieldType fieldType, int minDigits, int maxDigits) {
if (fieldType == null) {
throw new IllegalArgumentException("Field type must not be null");
}
if (maxDigits < minDigits) {
maxDigits = minDigits;
}
if (minDigits < 0 || maxDigits <= 0) {
throw new IllegalArgumentException();
}
return append0(new Fraction(fieldType, minDigits, maxDigits));
}
/**
* Appends the print/parse of a fractional second.
* <p>
* This reliably handles the case where fractional digits are being handled
* beyond a visible decimal point. The digits parsed will always be treated
* as the most significant (numerically largest) digits.
* Thus '23' will be parsed as 230 milliseconds.
* Contrast this behaviour to {@link #appendMillisOfSecond}.
* This method does not print or parse the decimal point itself.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to print or parse
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendFractionOfSecond(int minDigits, int maxDigits) {
return appendFraction(DateTimeFieldType.secondOfDay(), minDigits, maxDigits);
}
/**
* Appends the print/parse of a fractional minute.
* <p>
* This reliably handles the case where fractional digits are being handled
* beyond a visible decimal point. The digits parsed will always be treated
* as the most significant (numerically largest) digits.
* Thus '23' will be parsed as 0.23 minutes (converted to milliseconds).
* This method does not print or parse the decimal point itself.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to print or parse
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendFractionOfMinute(int minDigits, int maxDigits) {
return appendFraction(DateTimeFieldType.minuteOfDay(), minDigits, maxDigits);
}
/**
* Appends the print/parse of a fractional hour.
* <p>
* This reliably handles the case where fractional digits are being handled
* beyond a visible decimal point. The digits parsed will always be treated
* as the most significant (numerically largest) digits.
* Thus '23' will be parsed as 0.23 hours (converted to milliseconds).
* This method does not print or parse the decimal point itself.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to print or parse
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendFractionOfHour(int minDigits, int maxDigits) {
return appendFraction(DateTimeFieldType.hourOfDay(), minDigits, maxDigits);
}
/**
* Appends the print/parse of a fractional day.
* <p>
* This reliably handles the case where fractional digits are being handled
* beyond a visible decimal point. The digits parsed will always be treated
* as the most significant (numerically largest) digits.
* Thus '23' will be parsed as 0.23 days (converted to milliseconds).
* This method does not print or parse the decimal point itself.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to print or parse
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendFractionOfDay(int minDigits, int maxDigits) {
return appendFraction(DateTimeFieldType.dayOfYear(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a numeric millisOfSecond field.
* <p>
* This method will append a field that prints a three digit value.
* During parsing the value that is parsed is assumed to be three digits.
* If less than three digits are present then they will be counted as the
* smallest parts of the millisecond. This is probably not what you want
* if you are using the field as a fraction. Instead, a fractional
* millisecond should be produced using {@link #appendFractionOfSecond}.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMillisOfSecond(int minDigits) {
return appendDecimal(DateTimeFieldType.millisOfSecond(), minDigits, 3);
}
/**
* Instructs the printer to emit a numeric millisOfDay field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMillisOfDay(int minDigits) {
return appendDecimal(DateTimeFieldType.millisOfDay(), minDigits, 8);
}
/**
* Instructs the printer to emit a numeric secondOfMinute field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendSecondOfMinute(int minDigits) {
return appendDecimal(DateTimeFieldType.secondOfMinute(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric secondOfDay field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendSecondOfDay(int minDigits) {
return appendDecimal(DateTimeFieldType.secondOfDay(), minDigits, 5);
}
/**
* Instructs the printer to emit a numeric minuteOfHour field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMinuteOfHour(int minDigits) {
return appendDecimal(DateTimeFieldType.minuteOfHour(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric minuteOfDay field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMinuteOfDay(int minDigits) {
return appendDecimal(DateTimeFieldType.minuteOfDay(), minDigits, 4);
}
/**
* Instructs the printer to emit a numeric hourOfDay field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendHourOfDay(int minDigits) {
return appendDecimal(DateTimeFieldType.hourOfDay(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric clockhourOfDay field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendClockhourOfDay(int minDigits) {
return appendDecimal(DateTimeFieldType.clockhourOfDay(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric hourOfHalfday field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendHourOfHalfday(int minDigits) {
return appendDecimal(DateTimeFieldType.hourOfHalfday(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric clockhourOfHalfday field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendClockhourOfHalfday(int minDigits) {
return appendDecimal(DateTimeFieldType.clockhourOfHalfday(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric dayOfWeek field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendDayOfWeek(int minDigits) {
return appendDecimal(DateTimeFieldType.dayOfWeek(), minDigits, 1);
}
/**
* Instructs the printer to emit a numeric dayOfMonth field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendDayOfMonth(int minDigits) {
return appendDecimal(DateTimeFieldType.dayOfMonth(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric dayOfYear field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendDayOfYear(int minDigits) {
return appendDecimal(DateTimeFieldType.dayOfYear(), minDigits, 3);
}
/**
* Instructs the printer to emit a numeric weekOfWeekyear field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendWeekOfWeekyear(int minDigits) {
return appendDecimal(DateTimeFieldType.weekOfWeekyear(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric weekyear field.
*
* @param minDigits minimum number of digits to <i>print</i>
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendWeekyear(int minDigits, int maxDigits) {
return appendSignedDecimal(DateTimeFieldType.weekyear(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a numeric monthOfYear field.
*
* @param minDigits minimum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMonthOfYear(int minDigits) {
return appendDecimal(DateTimeFieldType.monthOfYear(), minDigits, 2);
}
/**
* Instructs the printer to emit a numeric year field.
*
* @param minDigits minimum number of digits to <i>print</i>
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendYear(int minDigits, int maxDigits) {
return appendSignedDecimal(DateTimeFieldType.year(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a numeric year field which always prints
* and parses two digits. A pivot year is used during parsing to determine
* the range of supported years as <code>(pivot - 50) .. (pivot + 49)</code>.
*
* <pre>
* 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
* </pre>
*
* @param pivot pivot year to use when parsing
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTwoDigitYear(int pivot) {
return appendTwoDigitYear(pivot, false);
}
/**
* Instructs the printer to emit a numeric year field which always prints
* two digits. A pivot year is used during parsing to determine the range
* of supported years as <code>(pivot - 50) .. (pivot + 49)</code>. If
* parse is instructed to be lenient and the digit count is not two, it is
* treated as an absolute year. With lenient parsing, specifying a positive
* or negative sign before the year also makes it absolute.
*
* @param pivot pivot year to use when parsing
* @param lenientParse when true, if digit count is not two, it is treated
* as an absolute year
* @return this DateTimeFormatterBuilder, for chaining
* @since 1.1
*/
public DateTimeFormatterBuilder appendTwoDigitYear(int pivot, boolean lenientParse) {
return append0(new TwoDigitYear(DateTimeFieldType.year(), pivot, lenientParse));
}
/**
* Instructs the printer to emit a numeric weekyear field which always prints
* and parses two digits. A pivot year is used during parsing to determine
* the range of supported years as <code>(pivot - 50) .. (pivot + 49)</code>.
*
* <pre>
* 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
* </pre>
*
* @param pivot pivot weekyear to use when parsing
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTwoDigitWeekyear(int pivot) {
return appendTwoDigitWeekyear(pivot, false);
}
/**
* Instructs the printer to emit a numeric weekyear field which always prints
* two digits. A pivot year is used during parsing to determine the range
* of supported years as <code>(pivot - 50) .. (pivot + 49)</code>. If
* parse is instructed to be lenient and the digit count is not two, it is
* treated as an absolute weekyear. With lenient parsing, specifying a positive
* or negative sign before the weekyear also makes it absolute.
*
* @param pivot pivot weekyear to use when parsing
* @param lenientParse when true, if digit count is not two, it is treated
* as an absolute weekyear
* @return this DateTimeFormatterBuilder, for chaining
* @since 1.1
*/
public DateTimeFormatterBuilder appendTwoDigitWeekyear(int pivot, boolean lenientParse) {
return append0(new TwoDigitYear(DateTimeFieldType.weekyear(), pivot, lenientParse));
}
/**
* Instructs the printer to emit a numeric yearOfEra field.
*
* @param minDigits minimum number of digits to <i>print</i>
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendYearOfEra(int minDigits, int maxDigits) {
return appendDecimal(DateTimeFieldType.yearOfEra(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a numeric year of century field.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendYearOfCentury(int minDigits, int maxDigits) {
return appendDecimal(DateTimeFieldType.yearOfCentury(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a numeric century of era field.
*
* @param minDigits minimum number of digits to print
* @param maxDigits maximum number of digits to <i>parse</i>, or the estimated
* maximum number of digits to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendCenturyOfEra(int minDigits, int maxDigits) {
return appendSignedDecimal(DateTimeFieldType.centuryOfEra(), minDigits, maxDigits);
}
/**
* Instructs the printer to emit a locale-specific AM/PM text, and the
* parser to expect it. The parser is case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendHalfdayOfDayText() {
return appendText(DateTimeFieldType.halfdayOfDay());
}
/**
* Instructs the printer to emit a locale-specific dayOfWeek text. The
* parser will accept a long or short dayOfWeek text, case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendDayOfWeekText() {
return appendText(DateTimeFieldType.dayOfWeek());
}
/**
* Instructs the printer to emit a short locale-specific dayOfWeek
* text. The parser will accept a long or short dayOfWeek text,
* case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendDayOfWeekShortText() {
return appendShortText(DateTimeFieldType.dayOfWeek());
}
/**
* Instructs the printer to emit a short locale-specific monthOfYear
* text. The parser will accept a long or short monthOfYear text,
* case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMonthOfYearText() {
return appendText(DateTimeFieldType.monthOfYear());
}
/**
* Instructs the printer to emit a locale-specific monthOfYear text. The
* parser will accept a long or short monthOfYear text, case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendMonthOfYearShortText() {
return appendShortText(DateTimeFieldType.monthOfYear());
}
/**
* Instructs the printer to emit a locale-specific era text (BC/AD), and
* the parser to expect it. The parser is case-insensitive.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendEraText() {
return appendText(DateTimeFieldType.era());
}
/**
* Instructs the printer to emit a locale-specific time zone name.
* Using this method prevents parsing, because time zone names are not unique.
* See {@link #appendTimeZoneName(Map)}.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneName() {
return append0(new TimeZoneName(TimeZoneName.LONG_NAME, null), null);
}
/**
* Instructs the printer to emit a locale-specific time zone name, providing a lookup for parsing.
* Time zone names are not unique, thus the API forces you to supply the lookup.
* The names are searched in the order of the map, thus it is strongly recommended
* to use a {@code LinkedHashMap} or similar.
*
* @param parseLookup the table of names, not null
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneName(Map<String, DateTimeZone> parseLookup) {
TimeZoneName pp = new TimeZoneName(TimeZoneName.LONG_NAME, parseLookup);
return append0(pp, pp);
}
/**
* Instructs the printer to emit a short locale-specific time zone name.
* Using this method prevents parsing, because time zone names are not unique.
* See {@link #appendTimeZoneShortName(Map)}.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneShortName() {
return append0(new TimeZoneName(TimeZoneName.SHORT_NAME, null), null);
}
/**
* Instructs the printer to emit a short locale-specific time zone
* name, providing a lookup for parsing.
* Time zone names are not unique, thus the API forces you to supply the lookup.
* The names are searched in the order of the map, thus it is strongly recommended
* to use a {@code LinkedHashMap} or similar.
*
* @param parseLookup the table of names, not null
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneShortName(Map<String, DateTimeZone> parseLookup) {
TimeZoneName pp = new TimeZoneName(TimeZoneName.SHORT_NAME, parseLookup);
return append0(pp, pp);
}
/**
* Instructs the printer to emit the identifier of the time zone.
* From version 2.0, this field can be parsed.
*
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneId() {
return append0(TimeZoneId.INSTANCE, TimeZoneId.INSTANCE);
}
/**
* Instructs the printer to emit text and numbers to display time zone
* offset from UTC. A parser will use the parsed time zone offset to adjust
* the datetime.
* <p>
* If zero offset text is supplied, then it will be printed when the zone is zero.
* During parsing, either the zero offset text, or the offset will be parsed.
*
* @param zeroOffsetText the text to use if time zone offset is zero. If
* null, offset is always shown.
* @param showSeparators if true, prints ':' separator before minute and
* second field and prints '.' separator before fraction field.
* @param minFields minimum number of fields to print, stopping when no
* more precision is required. 1=hours, 2=minutes, 3=seconds, 4=fraction
* @param maxFields maximum number of fields to print
* @return this DateTimeFormatterBuilder, for chaining
*/
public DateTimeFormatterBuilder appendTimeZoneOffset(
String zeroOffsetText, boolean showSeparators,
int minFields, int maxFields) {
return append0(new TimeZoneOffset
(zeroOffsetText, zeroOffsetText, showSeparators, minFields, maxFields));
}
/**
* Instructs the printer to emit text and numbers to display time zone
* offset from UTC. A parser will use the parsed time zone offset to adjust
* the datetime.
* <p>
* If zero offset print text is supplied, then it will be printed when the zone is zero.
* If zero offset parse text is supplied, then either it or the offset will be parsed.
*
* @param zeroOffsetPrintText the text to print if time zone offset is zero. If
* null, offset is always shown.
* @param zeroOffsetParseText the text to optionally parse to indicate that the time
* zone offset is zero. If null, then always use the offset.
* @param showSeparators if true, prints ':' separator before minute and
* second field and prints '.' separator before fraction field.
* @param minFields minimum number of fields to print, stopping when no
* more precision is required. 1=hours, 2=minutes, 3=seconds, 4=fraction
* @param maxFields maximum number of fields to print
* @return this DateTimeFormatterBuilder, for chaining
* @since 2.0
*/
public DateTimeFormatterBuilder appendTimeZoneOffset(
String zeroOffsetPrintText, String zeroOffsetParseText, boolean showSeparators,
int minFields, int maxFields) {
return append0(new TimeZoneOffset
(zeroOffsetPrintText, zeroOffsetParseText, showSeparators, minFields, maxFields));
}
//-----------------------------------------------------------------------
/**
* Calls upon {@link DateTimeFormat} to parse the pattern and append the
* results into this builder.
*
* @param pattern pattern specification
* @throws IllegalArgumentException if the pattern is invalid
* @see DateTimeFormat
*/
public DateTimeFormatterBuilder appendPattern(String pattern) {
DateTimeFormat.appendPatternTo(this, pattern);
return this;
}
//-----------------------------------------------------------------------
private Object getFormatter() {
Object f = iFormatter;
if (f == null) {
if (iElementPairs.size() == 2) {
Object printer = iElementPairs.get(0);
Object parser = iElementPairs.get(1);
if (printer != null) {
if (printer == parser || parser == null) {
f = printer;
}
} else {
f = parser;
}
}
if (f == null) {
f = new Composite(iElementPairs);
}
iFormatter = f;
}
return f;
}
private boolean isPrinter(Object f) {
if (f instanceof DateTimePrinter) {
if (f instanceof Composite) {
return ((Composite)f).isPrinter();
}
return true;
}
return false;
}
private boolean isParser(Object f) {
if (f instanceof DateTimeParser) {
if (f instanceof Composite) {
return ((Composite)f).isParser();
}
return true;
}
return false;
}
private boolean isFormatter(Object f) {
return (isPrinter(f) || isParser(f));
}
static void appendUnknownString(StringBuffer buf, int len) {
for (int i = len; --i >= 0;) {
buf.append('\ufffd');
}
}
static void printUnknownString(Writer out, int len) throws IOException {
for (int i = len; --i >= 0;) {
out.write('\ufffd');
}
}
//-----------------------------------------------------------------------
static class CharacterLiteral
implements DateTimePrinter, DateTimeParser {
private final char iValue;
CharacterLiteral(char value) {
super();
iValue = value;
}
public int estimatePrintedLength() {
return 1;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
buf.append(iValue);
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
out.write(iValue);
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
buf.append(iValue);
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
out.write(iValue);
}
public int estimateParsedLength() {
return 1;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
if (position >= text.length()) {
return ~position;
}
char a = text.charAt(position);
char b = iValue;
if (a != b) {
a = Character.toUpperCase(a);
b = Character.toUpperCase(b);
if (a != b) {
a = Character.toLowerCase(a);
b = Character.toLowerCase(b);
if (a != b) {
return ~position;
}
}
}
return position + 1;
}
}
//-----------------------------------------------------------------------
static class StringLiteral
implements DateTimePrinter, DateTimeParser {
private final String iValue;
StringLiteral(String value) {
super();
iValue = value;
}
public int estimatePrintedLength() {
return iValue.length();
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
buf.append(iValue);
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
out.write(iValue);
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
buf.append(iValue);
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
out.write(iValue);
}
public int estimateParsedLength() {
return iValue.length();
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
if (text.regionMatches(true, position, iValue, 0, iValue.length())) {
return position + iValue.length();
}
return ~position;
}
}
//-----------------------------------------------------------------------
static abstract class NumberFormatter
implements DateTimePrinter, DateTimeParser {
protected final DateTimeFieldType iFieldType;
protected final int iMaxParsedDigits;
protected final boolean iSigned;
NumberFormatter(DateTimeFieldType fieldType,
int maxParsedDigits, boolean signed) {
super();
iFieldType = fieldType;
iMaxParsedDigits = maxParsedDigits;
iSigned = signed;
}
public int estimateParsedLength() {
return iMaxParsedDigits;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
int limit = Math.min(iMaxParsedDigits, text.length() - position);
boolean negative = false;
int length = 0;
while (length < limit) {
char c = text.charAt(position + length);
if (length == 0 && (c == '-' || c == '+') && iSigned) {
negative = c == '-';
// Next character must be a digit.
if (length + 1 >= limit ||
(c = text.charAt(position + length + 1)) < '0' || c > '9')
{
break;
}
if (negative) {
length++;
} else {
// Skip the '+' for parseInt to succeed.
position++;
}
// Expand the limit to disregard the sign character.
limit = Math.min(limit + 1, text.length() - position);
continue;
}
if (c < '0' || c > '9') {
break;
}
length++;
}
if (length == 0) {
return ~position;
}
int value;
if (length >= 9) {
// Since value may exceed integer limits, use stock parser
// which checks for this.
value = Integer.parseInt(text.substring(position, position += length));
} else {
int i = position;
if (negative) {
i++;
}
try {
value = text.charAt(i++) - '0';
} catch (StringIndexOutOfBoundsException e) {
return ~position;
}
position += length;
while (i < position) {
value = ((value << 3) + (value << 1)) + text.charAt(i++) - '0';
}
if (negative) {
value = -value;
}
}
bucket.saveField(iFieldType, value);
return position;
}
}
//-----------------------------------------------------------------------
static class UnpaddedNumber extends NumberFormatter {
protected UnpaddedNumber(DateTimeFieldType fieldType,
int maxParsedDigits, boolean signed)
{
super(fieldType, maxParsedDigits, signed);
}
public int estimatePrintedLength() {
return iMaxParsedDigits;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
try {
DateTimeField field = iFieldType.getField(chrono);
FormatUtils.appendUnpaddedInteger(buf, field.get(instant));
} catch (RuntimeException e) {
buf.append('\ufffd');
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
try {
DateTimeField field = iFieldType.getField(chrono);
FormatUtils.writeUnpaddedInteger(out, field.get(instant));
} catch (RuntimeException e) {
out.write('\ufffd');
}
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
if (partial.isSupported(iFieldType)) {
try {
FormatUtils.appendUnpaddedInteger(buf, partial.get(iFieldType));
} catch (RuntimeException e) {
buf.append('\ufffd');
}
} else {
buf.append('\ufffd');
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
if (partial.isSupported(iFieldType)) {
try {
FormatUtils.writeUnpaddedInteger(out, partial.get(iFieldType));
} catch (RuntimeException e) {
out.write('\ufffd');
}
} else {
out.write('\ufffd');
}
}
}
//-----------------------------------------------------------------------
static class PaddedNumber extends NumberFormatter {
protected final int iMinPrintedDigits;
protected PaddedNumber(DateTimeFieldType fieldType, int maxParsedDigits,
boolean signed, int minPrintedDigits)
{
super(fieldType, maxParsedDigits, signed);
iMinPrintedDigits = minPrintedDigits;
}
public int estimatePrintedLength() {
return iMaxParsedDigits;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
try {
DateTimeField field = iFieldType.getField(chrono);
FormatUtils.appendPaddedInteger(buf, field.get(instant), iMinPrintedDigits);
} catch (RuntimeException e) {
appendUnknownString(buf, iMinPrintedDigits);
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
try {
DateTimeField field = iFieldType.getField(chrono);
FormatUtils.writePaddedInteger(out, field.get(instant), iMinPrintedDigits);
} catch (RuntimeException e) {
printUnknownString(out, iMinPrintedDigits);
}
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
if (partial.isSupported(iFieldType)) {
try {
FormatUtils.appendPaddedInteger(buf, partial.get(iFieldType), iMinPrintedDigits);
} catch (RuntimeException e) {
appendUnknownString(buf, iMinPrintedDigits);
}
} else {
appendUnknownString(buf, iMinPrintedDigits);
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
if (partial.isSupported(iFieldType)) {
try {
FormatUtils.writePaddedInteger(out, partial.get(iFieldType), iMinPrintedDigits);
} catch (RuntimeException e) {
printUnknownString(out, iMinPrintedDigits);
}
} else {
printUnknownString(out, iMinPrintedDigits);
}
}
}
//-----------------------------------------------------------------------
static class FixedNumber extends PaddedNumber {
protected FixedNumber(DateTimeFieldType fieldType, int numDigits, boolean signed) {
super(fieldType, numDigits, signed, numDigits);
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
int newPos = super.parseInto(bucket, text, position);
if (newPos < 0) {
return newPos;
}
int expectedPos = position + iMaxParsedDigits;
if (newPos != expectedPos) {
if (iSigned) {
char c = text.charAt(position);
if (c == '-' || c == '+') {
expectedPos++;
}
}
if (newPos > expectedPos) {
// The failure is at the position of the first extra digit.
return ~(expectedPos + 1);
} else if (newPos < expectedPos) {
// The failure is at the position where the next digit should be.
return ~newPos;
}
}
return newPos;
}
}
//-----------------------------------------------------------------------
static class TwoDigitYear
implements DateTimePrinter, DateTimeParser {
/** The field to print/parse. */
private final DateTimeFieldType iType;
/** The pivot year. */
private final int iPivot;
private final boolean iLenientParse;
TwoDigitYear(DateTimeFieldType type, int pivot, boolean lenientParse) {
super();
iType = type;
iPivot = pivot;
iLenientParse = lenientParse;
}
public int estimateParsedLength() {
return iLenientParse ? 4 : 2;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
int limit = text.length() - position;
if (!iLenientParse) {
limit = Math.min(2, limit);
if (limit < 2) {
return ~position;
}
} else {
boolean hasSignChar = false;
boolean negative = false;
int length = 0;
while (length < limit) {
char c = text.charAt(position + length);
if (length == 0 && (c == '-' || c == '+')) {
hasSignChar = true;
negative = c == '-';
if (negative) {
length++;
} else {
// Skip the '+' for parseInt to succeed.
position++;
limit--;
}
continue;
}
if (c < '0' || c > '9') {
break;
}
length++;
}
if (length == 0) {
return ~position;
}
if (hasSignChar || length != 2) {
int value;
if (length >= 9) {
// Since value may exceed integer limits, use stock
// parser which checks for this.
value = Integer.parseInt(text.substring(position, position += length));
} else {
int i = position;
if (negative) {
i++;
}
try {
value = text.charAt(i++) - '0';
} catch (StringIndexOutOfBoundsException e) {
return ~position;
}
position += length;
while (i < position) {
value = ((value << 3) + (value << 1)) + text.charAt(i++) - '0';
}
if (negative) {
value = -value;
}
}
bucket.saveField(iType, value);
return position;
}
}
int year;
char c = text.charAt(position);
if (c < '0' || c > '9') {
return ~position;
}
year = c - '0';
c = text.charAt(position + 1);
if (c < '0' || c > '9') {
return ~position;
}
year = ((year << 3) + (year << 1)) + c - '0';
int pivot = iPivot;
// If the bucket pivot year is non-null, use that when parsing
if (bucket.getPivotYear() != null) {
pivot = bucket.getPivotYear().intValue();
}
int low = pivot - 50;
int t;
if (low >= 0) {
t = low % 100;
} else {
t = 99 + ((low + 1) % 100);
}
year += low + ((year < t) ? 100 : 0) - t;
bucket.saveField(iType, year);
return position + 2;
}
public int estimatePrintedLength() {
return 2;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
int year = getTwoDigitYear(instant, chrono);
if (year < 0) {
buf.append('\ufffd');
buf.append('\ufffd');
} else {
FormatUtils.appendPaddedInteger(buf, year, 2);
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
int year = getTwoDigitYear(instant, chrono);
if (year < 0) {
out.write('\ufffd');
out.write('\ufffd');
} else {
FormatUtils.writePaddedInteger(out, year, 2);
}
}
private int getTwoDigitYear(long instant, Chronology chrono) {
try {
int year = iType.getField(chrono).get(instant);
if (year < 0) {
year = -year;
}
return year % 100;
} catch (RuntimeException e) {
return -1;
}
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
int year = getTwoDigitYear(partial);
if (year < 0) {
buf.append('\ufffd');
buf.append('\ufffd');
} else {
FormatUtils.appendPaddedInteger(buf, year, 2);
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
int year = getTwoDigitYear(partial);
if (year < 0) {
out.write('\ufffd');
out.write('\ufffd');
} else {
FormatUtils.writePaddedInteger(out, year, 2);
}
}
private int getTwoDigitYear(ReadablePartial partial) {
if (partial.isSupported(iType)) {
try {
int year = partial.get(iType);
if (year < 0) {
year = -year;
}
return year % 100;
} catch (RuntimeException e) {}
}
return -1;
}
}
//-----------------------------------------------------------------------
static class TextField
implements DateTimePrinter, DateTimeParser {
private static Map<Locale, Map<DateTimeFieldType, Object[]>> cParseCache =
new HashMap<Locale, Map<DateTimeFieldType, Object[]>>();
private final DateTimeFieldType iFieldType;
private final boolean iShort;
TextField(DateTimeFieldType fieldType, boolean isShort) {
super();
iFieldType = fieldType;
iShort = isShort;
}
public int estimatePrintedLength() {
return iShort ? 6 : 20;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
try {
buf.append(print(instant, chrono, locale));
} catch (RuntimeException e) {
buf.append('\ufffd');
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
try {
out.write(print(instant, chrono, locale));
} catch (RuntimeException e) {
out.write('\ufffd');
}
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
try {
buf.append(print(partial, locale));
} catch (RuntimeException e) {
buf.append('\ufffd');
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
try {
out.write(print(partial, locale));
} catch (RuntimeException e) {
out.write('\ufffd');
}
}
private String print(long instant, Chronology chrono, Locale locale) {
DateTimeField field = iFieldType.getField(chrono);
if (iShort) {
return field.getAsShortText(instant, locale);
} else {
return field.getAsText(instant, locale);
}
}
private String print(ReadablePartial partial, Locale locale) {
if (partial.isSupported(iFieldType)) {
DateTimeField field = iFieldType.getField(partial.getChronology());
if (iShort) {
return field.getAsShortText(partial, locale);
} else {
return field.getAsText(partial, locale);
}
} else {
return "\ufffd";
}
}
public int estimateParsedLength() {
return estimatePrintedLength();
}
@SuppressWarnings("unchecked")
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
Locale locale = bucket.getLocale();
// handle languages which might have non ASCII A-Z or punctuation
// bug 1788282
Set<String> validValues = null;
int maxLength = 0;
synchronized (cParseCache) {
Map<DateTimeFieldType, Object[]> innerMap = cParseCache.get(locale);
if (innerMap == null) {
innerMap = new HashMap<DateTimeFieldType, Object[]>();
cParseCache.put(locale, innerMap);
}
Object[] array = innerMap.get(iFieldType);
if (array == null) {
validValues = new HashSet<String>(32);
MutableDateTime dt = new MutableDateTime(0L, DateTimeZone.UTC);
Property property = dt.property(iFieldType);
int min = property.getMinimumValueOverall();
int max = property.getMaximumValueOverall();
if (max - min > 32) { // protect against invalid fields
return ~position;
}
maxLength = property.getMaximumTextLength(locale);
for (int i = min; i <= max; i++) {
property.set(i);
validValues.add(property.getAsShortText(locale));
validValues.add(property.getAsShortText(locale).toLowerCase(locale));
validValues.add(property.getAsShortText(locale).toUpperCase(locale));
validValues.add(property.getAsText(locale));
validValues.add(property.getAsText(locale).toLowerCase(locale));
validValues.add(property.getAsText(locale).toUpperCase(locale));
}
if ("en".equals(locale.getLanguage()) && iFieldType == DateTimeFieldType.era()) {
// hack to support for parsing "BCE" and "CE" if the language is English
validValues.add("BCE");
validValues.add("bce");
validValues.add("CE");
validValues.add("ce");
maxLength = 3;
}
array = new Object[] {validValues, Integer.valueOf(maxLength)};
innerMap.put(iFieldType, array);
} else {
validValues = (Set<String>) array[0];
maxLength = ((Integer) array[1]).intValue();
}
}
// match the longest string first using our knowledge of the max length
int limit = Math.min(text.length(), position + maxLength);
for (int i = limit; i > position; i--) {
String match = text.substring(position, i);
if (validValues.contains(match)) {
bucket.saveField(iFieldType, match, locale);
return i;
}
}
return ~position;
}
}
//-----------------------------------------------------------------------
static class Fraction
implements DateTimePrinter, DateTimeParser {
private final DateTimeFieldType iFieldType;
protected int iMinDigits;
protected int iMaxDigits;
protected Fraction(DateTimeFieldType fieldType, int minDigits, int maxDigits) {
super();
iFieldType = fieldType;
// Limit the precision requirements.
if (maxDigits > 18) {
maxDigits = 18;
}
iMinDigits = minDigits;
iMaxDigits = maxDigits;
}
public int estimatePrintedLength() {
return iMaxDigits;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
try {
printTo(buf, null, instant, chrono);
} catch (IOException e) {
// Not gonna happen.
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
printTo(null, out, instant, chrono);
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
// removed check whether field is supported, as input field is typically
// secondOfDay which is unsupported by TimeOfDay
long millis = partial.getChronology().set(partial, 0L);
try {
printTo(buf, null, millis, partial.getChronology());
} catch (IOException e) {
// Not gonna happen.
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
// removed check whether field is supported, as input field is typically
// secondOfDay which is unsupported by TimeOfDay
long millis = partial.getChronology().set(partial, 0L);
printTo(null, out, millis, partial.getChronology());
}
protected void printTo(StringBuffer buf, Writer out, long instant, Chronology chrono)
throws IOException
{
DateTimeField field = iFieldType.getField(chrono);
int minDigits = iMinDigits;
long fraction;
try {
fraction = field.remainder(instant);
} catch (RuntimeException e) {
if (buf != null) {
appendUnknownString(buf, minDigits);
} else {
printUnknownString(out, minDigits);
}
return;
}
if (fraction == 0) {
if (buf != null) {
while (--minDigits >= 0) {
buf.append('0');
}
} else {
while (--minDigits >= 0) {
out.write('0');
}
}
return;
}
String str;
long[] fractionData = getFractionData(fraction, field);
long scaled = fractionData[0];
int maxDigits = (int) fractionData[1];
if ((scaled & 0x7fffffff) == scaled) {
str = Integer.toString((int) scaled);
} else {
str = Long.toString(scaled);
}
int length = str.length();
int digits = maxDigits;
while (length < digits) {
if (buf != null) {
buf.append('0');
} else {
out.write('0');
}
minDigits--;
digits--;
}
if (minDigits < digits) {
// Chop off as many trailing zero digits as necessary.
while (minDigits < digits) {
if (length <= 1 || str.charAt(length - 1) != '0') {
break;
}
digits--;
length--;
}
if (length < str.length()) {
if (buf != null) {
for (int i=0; i<length; i++) {
buf.append(str.charAt(i));
}
} else {
for (int i=0; i<length; i++) {
out.write(str.charAt(i));
}
}
return;
}
}
if (buf != null) {
buf.append(str);
} else {
out.write(str);
}
}
private long[] getFractionData(long fraction, DateTimeField field) {
long rangeMillis = field.getDurationField().getUnitMillis();
long scalar;
int maxDigits = iMaxDigits;
while (true) {
switch (maxDigits) {
default: scalar = 1L; break;
case 1: scalar = 10L; break;
case 2: scalar = 100L; break;
case 3: scalar = 1000L; break;
case 4: scalar = 10000L; break;
case 5: scalar = 100000L; break;
case 6: scalar = 1000000L; break;
case 7: scalar = 10000000L; break;
case 8: scalar = 100000000L; break;
case 9: scalar = 1000000000L; break;
case 10: scalar = 10000000000L; break;
case 11: scalar = 100000000000L; break;
case 12: scalar = 1000000000000L; break;
case 13: scalar = 10000000000000L; break;
case 14: scalar = 100000000000000L; break;
case 15: scalar = 1000000000000000L; break;
case 16: scalar = 10000000000000000L; break;
case 17: scalar = 100000000000000000L; break;
case 18: scalar = 1000000000000000000L; break;
}
if (((rangeMillis * scalar) / scalar) == rangeMillis) {
break;
}
// Overflowed: scale down.
maxDigits--;
}
return new long[] {fraction * scalar / rangeMillis, maxDigits};
}
public int estimateParsedLength() {
return iMaxDigits;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
DateTimeField field = iFieldType.getField(bucket.getChronology());
int limit = Math.min(iMaxDigits, text.length() - position);
long value = 0;
long n = field.getDurationField().getUnitMillis() * 10;
int length = 0;
while (length < limit) {
char c = text.charAt(position + length);
if (c < '0' || c > '9') {
break;
}
length++;
long nn = n / 10;
value += (c - '0') * nn;
n = nn;
}
value /= 10;
if (length == 0) {
return ~position;
}
if (value > Integer.MAX_VALUE) {
return ~position;
}
DateTimeField parseField = new PreciseDateTimeField(
DateTimeFieldType.millisOfSecond(),
MillisDurationField.INSTANCE,
field.getDurationField());
bucket.saveField(parseField, (int) value);
return position + length;
}
}
//-----------------------------------------------------------------------
static class TimeZoneOffset
implements DateTimePrinter, DateTimeParser {
private final String iZeroOffsetPrintText;
private final String iZeroOffsetParseText;
private final boolean iShowSeparators;
private final int iMinFields;
private final int iMaxFields;
TimeZoneOffset(String zeroOffsetPrintText, String zeroOffsetParseText,
boolean showSeparators,
int minFields, int maxFields)
{
super();
iZeroOffsetPrintText = zeroOffsetPrintText;
iZeroOffsetParseText = zeroOffsetParseText;
iShowSeparators = showSeparators;
if (minFields <= 0 || maxFields < minFields) {
throw new IllegalArgumentException();
}
if (minFields > 4) {
minFields = 4;
maxFields = 4;
}
iMinFields = minFields;
iMaxFields = maxFields;
}
public int estimatePrintedLength() {
int est = 1 + iMinFields << 1;
if (iShowSeparators) {
est += iMinFields - 1;
}
if (iZeroOffsetPrintText != null && iZeroOffsetPrintText.length() > est) {
est = iZeroOffsetPrintText.length();
}
return est;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
if (displayZone == null) {
return; // no zone
}
if (displayOffset == 0 && iZeroOffsetPrintText != null) {
buf.append(iZeroOffsetPrintText);
return;
}
if (displayOffset >= 0) {
buf.append('+');
} else {
buf.append('-');
displayOffset = -displayOffset;
}
int hours = displayOffset / DateTimeConstants.MILLIS_PER_HOUR;
FormatUtils.appendPaddedInteger(buf, hours, 2);
if (iMaxFields == 1) {
return;
}
displayOffset -= hours * (int)DateTimeConstants.MILLIS_PER_HOUR;
if (displayOffset == 0 && iMinFields <= 1) {
return;
}
int minutes = displayOffset / DateTimeConstants.MILLIS_PER_MINUTE;
if (iShowSeparators) {
buf.append(':');
}
FormatUtils.appendPaddedInteger(buf, minutes, 2);
if (iMaxFields == 2) {
return;
}
displayOffset -= minutes * DateTimeConstants.MILLIS_PER_MINUTE;
if (displayOffset == 0 && iMinFields <= 2) {
return;
}
int seconds = displayOffset / DateTimeConstants.MILLIS_PER_SECOND;
if (iShowSeparators) {
buf.append(':');
}
FormatUtils.appendPaddedInteger(buf, seconds, 2);
if (iMaxFields == 3) {
return;
}
displayOffset -= seconds * DateTimeConstants.MILLIS_PER_SECOND;
if (displayOffset == 0 && iMinFields <= 3) {
return;
}
if (iShowSeparators) {
buf.append('.');
}
FormatUtils.appendPaddedInteger(buf, displayOffset, 3);
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
if (displayZone == null) {
return; // no zone
}
if (displayOffset == 0 && iZeroOffsetPrintText != null) {
out.write(iZeroOffsetPrintText);
return;
}
if (displayOffset >= 0) {
out.write('+');
} else {
out.write('-');
displayOffset = -displayOffset;
}
int hours = displayOffset / DateTimeConstants.MILLIS_PER_HOUR;
FormatUtils.writePaddedInteger(out, hours, 2);
if (iMaxFields == 1) {
return;
}
displayOffset -= hours * (int)DateTimeConstants.MILLIS_PER_HOUR;
if (displayOffset == 0 && iMinFields == 1) {
return;
}
int minutes = displayOffset / DateTimeConstants.MILLIS_PER_MINUTE;
if (iShowSeparators) {
out.write(':');
}
FormatUtils.writePaddedInteger(out, minutes, 2);
if (iMaxFields == 2) {
return;
}
displayOffset -= minutes * DateTimeConstants.MILLIS_PER_MINUTE;
if (displayOffset == 0 && iMinFields == 2) {
return;
}
int seconds = displayOffset / DateTimeConstants.MILLIS_PER_SECOND;
if (iShowSeparators) {
out.write(':');
}
FormatUtils.writePaddedInteger(out, seconds, 2);
if (iMaxFields == 3) {
return;
}
displayOffset -= seconds * DateTimeConstants.MILLIS_PER_SECOND;
if (displayOffset == 0 && iMinFields == 3) {
return;
}
if (iShowSeparators) {
out.write('.');
}
FormatUtils.writePaddedInteger(out, displayOffset, 3);
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
// no zone info
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
// no zone info
}
public int estimateParsedLength() {
return estimatePrintedLength();
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
int limit = text.length() - position;
zeroOffset:
if (iZeroOffsetParseText != null) {
if (iZeroOffsetParseText.length() == 0) {
// Peek ahead, looking for sign character.
if (limit > 0) {
char c = text.charAt(position);
if (c == '-' || c == '+') {
break zeroOffset;
}
}
bucket.setOffset(Integer.valueOf(0));
return position;
}
if (text.regionMatches(true, position, iZeroOffsetParseText, 0, iZeroOffsetParseText.length())) {
bucket.setOffset(Integer.valueOf(0));
return position + iZeroOffsetParseText.length();
}
}
// Format to expect is sign character followed by at least one digit.
if (limit <= 1) {
return ~position;
}
boolean negative;
char c = text.charAt(position);
if (c == '-') {
negative = true;
} else if (c == '+') {
negative = false;
} else {
return ~position;
}
limit--;
position++;
// Format following sign is one of:
//
// hh
// hhmm
// hhmmss
// hhmmssSSS
// hh:mm
// hh:mm:ss
// hh:mm:ss.SSS
// First parse hours.
if (digitCount(text, position, 2) < 2) {
// Need two digits for hour.
return ~position;
}
int offset;
int hours = FormatUtils.parseTwoDigits(text, position);
if (hours > 23) {
return ~position;
}
offset = hours * DateTimeConstants.MILLIS_PER_HOUR;
limit -= 2;
position += 2;
parse: {
// Need to decide now if separators are expected or parsing
// stops at hour field.
if (limit <= 0) {
break parse;
}
boolean expectSeparators;
c = text.charAt(position);
if (c == ':') {
expectSeparators = true;
limit--;
position++;
} else if (c >= '0' && c <= '9') {
expectSeparators = false;
} else {
break parse;
}
// Proceed to parse minutes.
int count = digitCount(text, position, 2);
if (count == 0 && !expectSeparators) {
break parse;
} else if (count < 2) {
// Need two digits for minute.
return ~position;
}
int minutes = FormatUtils.parseTwoDigits(text, position);
if (minutes > 59) {
return ~position;
}
offset += minutes * DateTimeConstants.MILLIS_PER_MINUTE;
limit -= 2;
position += 2;
// Proceed to parse seconds.
if (limit <= 0) {
break parse;
}
if (expectSeparators) {
if (text.charAt(position) != ':') {
break parse;
}
limit--;
position++;
}
count = digitCount(text, position, 2);
if (count == 0 && !expectSeparators) {
break parse;
} else if (count < 2) {
// Need two digits for second.
return ~position;
}
int seconds = FormatUtils.parseTwoDigits(text, position);
if (seconds > 59) {
return ~position;
}
offset += seconds * DateTimeConstants.MILLIS_PER_SECOND;
limit -= 2;
position += 2;
// Proceed to parse fraction of second.
if (limit <= 0) {
break parse;
}
if (expectSeparators) {
if (text.charAt(position) != '.' && text.charAt(position) != ',') {
break parse;
}
limit--;
position++;
}
count = digitCount(text, position, 3);
if (count == 0 && !expectSeparators) {
break parse;
} else if (count < 1) {
// Need at least one digit for fraction of second.
return ~position;
}
offset += (text.charAt(position++) - '0') * 100;
if (count > 1) {
offset += (text.charAt(position++) - '0') * 10;
if (count > 2) {
offset += text.charAt(position++) - '0';
}
}
}
bucket.setOffset(Integer.valueOf(negative ? -offset : offset));
return position;
}
/**
* Returns actual amount of digits to parse, but no more than original
* 'amount' parameter.
*/
private int digitCount(String text, int position, int amount) {
int limit = Math.min(text.length() - position, amount);
amount = 0;
for (; limit > 0; limit--) {
char c = text.charAt(position + amount);
if (c < '0' || c > '9') {
break;
}
amount++;
}
return amount;
}
}
//-----------------------------------------------------------------------
static class TimeZoneName
implements DateTimePrinter, DateTimeParser {
static final int LONG_NAME = 0;
static final int SHORT_NAME = 1;
private final Map<String, DateTimeZone> iParseLookup;
private final int iType;
TimeZoneName(int type, Map<String, DateTimeZone> parseLookup) {
super();
iType = type;
iParseLookup = parseLookup;
}
public int estimatePrintedLength() {
return (iType == SHORT_NAME ? 4 : 20);
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
buf.append(print(instant - displayOffset, displayZone, locale));
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
out.write(print(instant - displayOffset, displayZone, locale));
}
private String print(long instant, DateTimeZone displayZone, Locale locale) {
if (displayZone == null) {
return ""; // no zone
}
switch (iType) {
case LONG_NAME:
return displayZone.getName(instant, locale);
case SHORT_NAME:
return displayZone.getShortName(instant, locale);
}
return "";
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
// no zone info
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
// no zone info
}
public int estimateParsedLength() {
return (iType == SHORT_NAME ? 4 : 20);
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
String str = text.substring(position);
for (String name : iParseLookup.keySet()) {
if (str.startsWith(name)) {
bucket.setZone(iParseLookup.get(name));
return position + name.length();
}
}
return ~position;
}
}
//-----------------------------------------------------------------------
static enum TimeZoneId
implements DateTimePrinter, DateTimeParser {
INSTANCE;
static final Set<String> ALL_IDS = DateTimeZone.getAvailableIDs();
static final int MAX_LENGTH;
static {
int max = 0;
for (String id : ALL_IDS) {
max = Math.max(max, id.length());
}
MAX_LENGTH = max;
}
public int estimatePrintedLength() {
return MAX_LENGTH;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
buf.append(displayZone != null ? displayZone.getID() : "");
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
out.write(displayZone != null ? displayZone.getID() : "");
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
// no zone info
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
// no zone info
}
public int estimateParsedLength() {
return MAX_LENGTH;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
String str = text.substring(position);
String best = null;
for (String id : ALL_IDS) {
if (str.startsWith(id)) {
if (best == null || id.length() > best.length()) {
best = id;
}
}
}
if (best != null) {
bucket.setZone(DateTimeZone.forID(best));
return position + best.length();
}
return ~position;
}
}
//-----------------------------------------------------------------------
static class Composite
implements DateTimePrinter, DateTimeParser {
private final DateTimePrinter[] iPrinters;
private final DateTimeParser[] iParsers;
private final int iPrintedLengthEstimate;
private final int iParsedLengthEstimate;
Composite(List<Object> elementPairs) {
super();
List<Object> printerList = new ArrayList<Object>();
List<Object> parserList = new ArrayList<Object>();
decompose(elementPairs, printerList, parserList);
if (printerList.size() <= 0) {
iPrinters = null;
iPrintedLengthEstimate = 0;
} else {
int size = printerList.size();
iPrinters = new DateTimePrinter[size];
int printEst = 0;
for (int i=0; i<size; i++) {
DateTimePrinter printer = (DateTimePrinter) printerList.get(i);
printEst += printer.estimatePrintedLength();
iPrinters[i] = printer;
}
iPrintedLengthEstimate = printEst;
}
if (parserList.size() <= 0) {
iParsers = null;
iParsedLengthEstimate = 0;
} else {
int size = parserList.size();
iParsers = new DateTimeParser[size];
int parseEst = 0;
for (int i=0; i<size; i++) {
DateTimeParser parser = (DateTimeParser) parserList.get(i);
parseEst += parser.estimateParsedLength();
iParsers[i] = parser;
}
iParsedLengthEstimate = parseEst;
}
}
public int estimatePrintedLength() {
return iPrintedLengthEstimate;
}
public void printTo(
StringBuffer buf, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) {
DateTimePrinter[] elements = iPrinters;
if (elements == null) {
throw new UnsupportedOperationException();
}
if (locale == null) {
// Guard against default locale changing concurrently.
locale = Locale.getDefault();
}
int len = elements.length;
for (int i = 0; i < len; i++) {
elements[i].printTo(buf, instant, chrono, displayOffset, displayZone, locale);
}
}
public void printTo(
Writer out, long instant, Chronology chrono,
int displayOffset, DateTimeZone displayZone, Locale locale) throws IOException {
DateTimePrinter[] elements = iPrinters;
if (elements == null) {
throw new UnsupportedOperationException();
}
if (locale == null) {
// Guard against default locale changing concurrently.
locale = Locale.getDefault();
}
int len = elements.length;
for (int i = 0; i < len; i++) {
elements[i].printTo(out, instant, chrono, displayOffset, displayZone, locale);
}
}
public void printTo(StringBuffer buf, ReadablePartial partial, Locale locale) {
DateTimePrinter[] elements = iPrinters;
if (elements == null) {
throw new UnsupportedOperationException();
}
if (locale == null) {
// Guard against default locale changing concurrently.
locale = Locale.getDefault();
}
int len = elements.length;
for (int i=0; i<len; i++) {
elements[i].printTo(buf, partial, locale);
}
}
public void printTo(Writer out, ReadablePartial partial, Locale locale) throws IOException {
DateTimePrinter[] elements = iPrinters;
if (elements == null) {
throw new UnsupportedOperationException();
}
if (locale == null) {
// Guard against default locale changing concurrently.
locale = Locale.getDefault();
}
int len = elements.length;
for (int i=0; i<len; i++) {
elements[i].printTo(out, partial, locale);
}
}
public int estimateParsedLength() {
return iParsedLengthEstimate;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
DateTimeParser[] elements = iParsers;
if (elements == null) {
throw new UnsupportedOperationException();
}
int len = elements.length;
for (int i=0; i<len && position >= 0; i++) {
position = elements[i].parseInto(bucket, text, position);
}
return position;
}
boolean isPrinter() {
return iPrinters != null;
}
boolean isParser() {
return iParsers != null;
}
/**
* Processes the element pairs, putting results into the given printer
* and parser lists.
*/
private void decompose(List<Object> elementPairs, List<Object> printerList, List<Object> parserList) {
int size = elementPairs.size();
for (int i=0; i<size; i+=2) {
Object element = elementPairs.get(i);
if (element instanceof DateTimePrinter) {
if (element instanceof Composite) {
addArrayToList(printerList, ((Composite)element).iPrinters);
} else {
printerList.add(element);
}
}
element = elementPairs.get(i + 1);
if (element instanceof DateTimeParser) {
if (element instanceof Composite) {
addArrayToList(parserList, ((Composite)element).iParsers);
} else {
parserList.add(element);
}
}
}
}
private void addArrayToList(List<Object> list, Object[] array) {
if (array != null) {
for (int i=0; i<array.length; i++) {
list.add(array[i]);
}
}
}
}
//-----------------------------------------------------------------------
static class MatchingParser
implements DateTimeParser {
private final DateTimeParser[] iParsers;
private final int iParsedLengthEstimate;
MatchingParser(DateTimeParser[] parsers) {
super();
iParsers = parsers;
int est = 0;
for (int i=parsers.length; --i>=0 ;) {
DateTimeParser parser = parsers[i];
if (parser != null) {
int len = parser.estimateParsedLength();
if (len > est) {
est = len;
}
}
}
iParsedLengthEstimate = est;
}
public int estimateParsedLength() {
return iParsedLengthEstimate;
}
public int parseInto(DateTimeParserBucket bucket, String text, int position) {
DateTimeParser[] parsers = iParsers;
int length = parsers.length;
final Object originalState = bucket.saveState();
boolean isOptional = false;
int bestValidPos = position;
Object bestValidState = null;
int bestInvalidPos = position;
for (int i=0; i<length; i++) {
DateTimeParser parser = parsers[i];
if (parser == null) {
// The empty parser wins only if nothing is better.
if (bestValidPos <= position) {
return position;
}
isOptional = true;
break;
}
int parsePos = parser.parseInto(bucket, text, position);
if (parsePos >= position) {
if (parsePos > bestValidPos) {
if (parsePos >= text.length() ||
(i + 1) >= length || parsers[i + 1] == null) {
// Completely parsed text or no more parsers to
// check. Skip the rest.
return parsePos;
}
bestValidPos = parsePos;
bestValidState = bucket.saveState();
}
} else {
if (parsePos < 0) {
parsePos = ~parsePos;
if (parsePos > bestInvalidPos) {
bestInvalidPos = parsePos;
}
}
}
bucket.restoreState(originalState);
}
if (bestValidPos > position || (bestValidPos == position && isOptional)) {
// Restore the state to the best valid parse.
if (bestValidState != null) {
bucket.restoreState(bestValidState);
}
return bestValidPos;
}
return ~bestInvalidPos;
}
}
}