Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.base.jmod - Base Module
JDK 11 java.base.jmod is the JMOD file for JDK 11 Base module.
JDK 11 Base module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.base.jmod.
JDK 11 Base module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Base module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.base.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ java/time/format/DateTimeParseContext.java
/* * 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<>(); } 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(); } }
⏎ java/time/format/DateTimeParseContext.java
Or download all of them as a single archive file:
File name: java.base-11.0.1-src.zip File size: 8740354 bytes Release date: 2018-11-04 Download
2020-05-29, 205088👍, 0💬
Popular Posts:
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module. JDK 17 Base module compiled class fil...
Commons VFS provides a single API for accessing various different file systems. It presents a unifor...
What is jxl.jar 2.6.12? jxl.jar 2.6.12 is the JAR file for Java Excel API 2.6.12, which is a Java li...
JDK 11 jdk.localedata.jmod is the JMOD file for JDK 11 Localedata module. JDK 11 Locale Data module ...
Where Can I see Java Source Code files for Xerces Java 2.11.2? Here are Java Source Code files for X...