/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
/*
*
*
*
*
*
* Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* * Neither the name of JSR-310 nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package java.time.format;
import java.time.
ZoneId;
import java.time.chrono.
Chronology;
import java.time.chrono.
IsoChronology;
import java.time.temporal.
TemporalAccessor;
import java.time.temporal.
TemporalField;
import java.util.
ArrayList;
import java.util.
Locale;
import java.util.
Objects;
import java.util.
Set;
import java.util.function.
Consumer;
/**
* Context object used during date and time parsing.
* <p>
* This class represents the current state of the parse.
* It has the ability to store and retrieve the parsed values and manage optional segments.
* It also provides key information to the parsing methods.
* <p>
* Once parsing is complete, the {@link #toUnresolved()} is used to obtain the unresolved
* result data. The {@link #toResolved()} is used to obtain the resolved result.
*
* @implSpec
* This class is a mutable context intended for use from a single thread.
* Usage of the class is thread-safe within standard parsing as a new instance of this class
* is automatically created for each parse and parsing is single-threaded
*
* @since 1.8
*/
final class
DateTimeParseContext {
/**
* The formatter, not null.
*/
private
DateTimeFormatter formatter;
/**
* Whether to parse using case sensitively.
*/
private boolean
caseSensitive = true;
/**
* Whether to parse using strict rules.
*/
private boolean
strict = true;
/**
* The list of parsed data.
*/
private final
ArrayList<
Parsed>
parsed = new
ArrayList<>();
/**
* List of Consumers<Chronology> to be notified if the Chronology changes.
*/
private
ArrayList<
Consumer<
Chronology>>
chronoListeners = null;
/**
* Creates a new instance of the context.
*
* @param formatter the formatter controlling the parse, not null
*/
DateTimeParseContext(
DateTimeFormatter formatter) {
super();
this.
formatter =
formatter;
parsed.
add(new
Parsed());
}
/**
* Creates a copy of this context.
* This retains the case sensitive and strict flags.
*/
DateTimeParseContext copy() {
DateTimeParseContext newContext = new
DateTimeParseContext(
formatter);
newContext.
caseSensitive =
caseSensitive;
newContext.
strict =
strict;
return
newContext;
}
//-----------------------------------------------------------------------
/**
* Gets the locale.
* <p>
* This locale is used to control localization in the parse except
* where localization is controlled by the DecimalStyle.
*
* @return the locale, not null
*/
Locale getLocale() {
return
formatter.
getLocale();
}
/**
* Gets the DecimalStyle.
* <p>
* The DecimalStyle controls the numeric parsing.
*
* @return the DecimalStyle, not null
*/
DecimalStyle getDecimalStyle() {
return
formatter.
getDecimalStyle();
}
/**
* Gets the effective chronology during parsing.
*
* @return the effective parsing chronology, not null
*/
Chronology getEffectiveChronology() {
Chronology chrono =
currentParsed().
chrono;
if (
chrono == null) {
chrono =
formatter.
getChronology();
if (
chrono == null) {
chrono =
IsoChronology.
INSTANCE;
}
}
return
chrono;
}
//-----------------------------------------------------------------------
/**
* Checks if parsing is case sensitive.
*
* @return true if parsing is case sensitive, false if case insensitive
*/
boolean
isCaseSensitive() {
return
caseSensitive;
}
/**
* Sets whether the parsing is case sensitive or not.
*
* @param caseSensitive changes the parsing to be case sensitive or not from now on
*/
void
setCaseSensitive(boolean
caseSensitive) {
this.
caseSensitive =
caseSensitive;
}
//-----------------------------------------------------------------------
/**
* Helper to compare two {@code CharSequence} instances.
* This uses {@link #isCaseSensitive()}.
*
* @param cs1 the first character sequence, not null
* @param offset1 the offset into the first sequence, valid
* @param cs2 the second character sequence, not null
* @param offset2 the offset into the second sequence, valid
* @param length the length to check, valid
* @return true if equal
*/
boolean
subSequenceEquals(
CharSequence cs1, int
offset1,
CharSequence cs2, int
offset2, int
length) {
if (
offset1 +
length >
cs1.
length() ||
offset2 +
length >
cs2.
length()) {
return false;
}
if (
isCaseSensitive()) {
for (int
i = 0;
i <
length;
i++) {
char
ch1 =
cs1.
charAt(
offset1 +
i);
char
ch2 =
cs2.
charAt(
offset2 +
i);
if (
ch1 !=
ch2) {
return false;
}
}
} else {
for (int
i = 0;
i <
length;
i++) {
char
ch1 =
cs1.
charAt(
offset1 +
i);
char
ch2 =
cs2.
charAt(
offset2 +
i);
if (
ch1 !=
ch2 &&
Character.
toUpperCase(
ch1) !=
Character.
toUpperCase(
ch2) &&
Character.
toLowerCase(
ch1) !=
Character.
toLowerCase(
ch2)) {
return false;
}
}
}
return true;
}
/**
* Helper to compare two {@code char}.
* This uses {@link #isCaseSensitive()}.
*
* @param ch1 the first character
* @param ch2 the second character
* @return true if equal
*/
boolean
charEquals(char
ch1, char
ch2) {
if (
isCaseSensitive()) {
return
ch1 ==
ch2;
}
return
charEqualsIgnoreCase(
ch1,
ch2);
}
/**
* Compares two characters ignoring case.
*
* @param c1 the first
* @param c2 the second
* @return true if equal
*/
static boolean
charEqualsIgnoreCase(char
c1, char
c2) {
return
c1 ==
c2 ||
Character.
toUpperCase(
c1) ==
Character.
toUpperCase(
c2) ||
Character.
toLowerCase(
c1) ==
Character.
toLowerCase(
c2);
}
//-----------------------------------------------------------------------
/**
* Checks if parsing is strict.
* <p>
* Strict parsing requires exact matching of the text and sign styles.
*
* @return true if parsing is strict, false if lenient
*/
boolean
isStrict() {
return
strict;
}
/**
* Sets whether parsing is strict or lenient.
*
* @param strict changes the parsing to be strict or lenient from now on
*/
void
setStrict(boolean
strict) {
this.
strict =
strict;
}
//-----------------------------------------------------------------------
/**
* Starts the parsing of an optional segment of the input.
*/
void
startOptional() {
parsed.
add(
currentParsed().
copy());
}
/**
* Ends the parsing of an optional segment of the input.
*
* @param successful whether the optional segment was successfully parsed
*/
void
endOptional(boolean
successful) {
if (
successful) {
parsed.
remove(
parsed.
size() - 2);
} else {
parsed.
remove(
parsed.
size() - 1);
}
}
//-----------------------------------------------------------------------
/**
* Gets the currently active temporal objects.
*
* @return the current temporal objects, not null
*/
private
Parsed currentParsed() {
return
parsed.
get(
parsed.
size() - 1);
}
/**
* Gets the unresolved result of the parse.
*
* @return the result of the parse, not null
*/
Parsed toUnresolved() {
return
currentParsed();
}
/**
* Gets the resolved result of the parse.
*
* @return the result of the parse, not null
*/
TemporalAccessor toResolved(
ResolverStyle resolverStyle,
Set<
TemporalField>
resolverFields) {
Parsed parsed =
currentParsed();
parsed.
chrono =
getEffectiveChronology();
parsed.
zone = (
parsed.
zone != null ?
parsed.
zone :
formatter.
getZone());
return
parsed.
resolve(
resolverStyle,
resolverFields);
}
//-----------------------------------------------------------------------
/**
* Gets the first value that was parsed for the specified field.
* <p>
* This searches the results of the parse, returning the first value found
* for the specified field. No attempt is made to derive a value.
* The field may have an out of range value.
* For example, the day-of-month might be set to 50, or the hour to 1000.
*
* @param field the field to query from the map, null returns null
* @return the value mapped to the specified field, null if field was not parsed
*/
Long getParsed(
TemporalField field) {
return
currentParsed().
fieldValues.
get(
field);
}
/**
* Stores the parsed field.
* <p>
* This stores a field-value pair that has been parsed.
* The value stored may be out of range for the field - no checks are performed.
*
* @param field the field to set in the field-value map, not null
* @param value the value to set in the field-value map
* @param errorPos the position of the field being parsed
* @param successPos the position after the field being parsed
* @return the new position
*/
int
setParsedField(
TemporalField field, long
value, int
errorPos, int
successPos) {
Objects.
requireNonNull(
field, "field");
Long old =
currentParsed().
fieldValues.
put(
field,
value);
return (
old != null &&
old.
longValue() !=
value) ? ~
errorPos :
successPos;
}
/**
* Stores the parsed chronology.
* <p>
* This stores the chronology that has been parsed.
* No validation is performed other than ensuring it is not null.
* <p>
* The list of listeners is copied and cleared so that each
* listener is called only once. A listener can add itself again
* if it needs to be notified of future changes.
*
* @param chrono the parsed chronology, not null
*/
void
setParsed(
Chronology chrono) {
Objects.
requireNonNull(
chrono, "chrono");
currentParsed().
chrono =
chrono;
if (
chronoListeners != null && !
chronoListeners.
isEmpty()) {
@
SuppressWarnings({"rawtypes", "unchecked"})
Consumer<
Chronology>[]
tmp = new
Consumer[1];
Consumer<
Chronology>[]
listeners =
chronoListeners.
toArray(
tmp);
chronoListeners.
clear();
for (
Consumer<
Chronology>
l :
listeners) {
l.
accept(
chrono);
}
}
}
/**
* Adds a Consumer<Chronology> to the list of listeners to be notified
* if the Chronology changes.
* @param listener a Consumer<Chronology> to be called when Chronology changes
*/
void
addChronoChangedListener(
Consumer<
Chronology>
listener) {
if (
chronoListeners == null) {
chronoListeners = new
ArrayList<
Consumer<
Chronology>>();
}
chronoListeners.
add(
listener);
}
/**
* Stores the parsed zone.
* <p>
* This stores the zone that has been parsed.
* No validation is performed other than ensuring it is not null.
*
* @param zone the parsed zone, not null
*/
void
setParsed(
ZoneId zone) {
Objects.
requireNonNull(
zone, "zone");
currentParsed().
zone =
zone;
}
/**
* Stores the parsed leap second.
*/
void
setParsedLeapSecond() {
currentParsed().
leapSecond = true;
}
//-----------------------------------------------------------------------
/**
* Returns a string version of the context for debugging.
*
* @return a string representation of the context data, not null
*/
@
Override
public
String toString() {
return
currentParsed().
toString();
}
}