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:
JRE 8 rt.jar - com.* Package Source Code
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime environment included in JDK 8. JRE 8 rt.jar libraries are divided into 6 packages:
com.* - Internal Oracle and Sun Microsystems libraries java.* - Standard Java API libraries. javax.* - Extended Java API libraries. jdk.* - JDK supporting libraries. org.* - Third party libraries. sun.* - Old libraries developed by Sun Microsystems.
JAR File Information:
Directory of C:\fyicenter\jdk-1.8.0_191\jre\lib 63,596,151 rt.jar
Here is the list of Java classes of the com.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ com/sun/org/apache/xerces/internal/impl/dv/xs/PrecisionDecimalDV.java
/* * Copyright (c) 2007, 2018, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ /* * Copyright 2004 The Apache Software Foundation. * * 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.sun.org.apache.xerces.internal.impl.dv.xs; import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException; import com.sun.org.apache.xerces.internal.impl.dv.ValidationContext; /** * Validator for <precisionDecimal> datatype (W3C Schema 1.1) * * @xerces.experimental * * @author Ankit Pasricha, IBM * */ class PrecisionDecimalDV extends TypeValidator { static final class XPrecisionDecimal { // sign: 0 for absent; 1 for positive values; -1 for negative values (except in case of INF, -INF) int sign = 1; // total digits. >= 1 int totalDigits = 0; // integer digits when sign != 0 int intDigits = 0; // fraction digits when sign != 0 int fracDigits = 0; //precision //int precision = 0; // the string representing the integer part String ivalue = ""; // the string representing the fraction part String fvalue = ""; int pvalue = 0; XPrecisionDecimal(String content) throws NumberFormatException { if(content.equals("NaN")) { ivalue = content; sign = 0; } if(content.equals("+INF") || content.equals("INF") || content.equals("-INF")) { ivalue = content.charAt(0) == '+' ? content.substring(1) : content; return; } initD(content); } void initD(String content) throws NumberFormatException { int len = content.length(); if (len == 0) throw new NumberFormatException(); // these 4 variables are used to indicate where the integre/fraction // parts start/end. int intStart = 0, intEnd = 0, fracStart = 0, fracEnd = 0; // Deal with leading sign symbol if present if (content.charAt(0) == '+') { // skip '+', so intStart should be 1 intStart = 1; } else if (content.charAt(0) == '-') { intStart = 1; sign = -1; } // skip leading zeroes in integer part int actualIntStart = intStart; while (actualIntStart < len && content.charAt(actualIntStart) == '0') { actualIntStart++; } // Find the ending position of the integer part for (intEnd = actualIntStart; intEnd < len && TypeValidator.isDigit(content.charAt(intEnd)); intEnd++); // Not reached the end yet if (intEnd < len) { // the remaining part is not ".DDD" or "EDDD" or "eDDD", error if (content.charAt(intEnd) != '.' && content.charAt(intEnd) != 'E' && content.charAt(intEnd) != 'e') throw new NumberFormatException(); if(content.charAt(intEnd) == '.') { // fraction part starts after '.', and ends at the end of the input fracStart = intEnd + 1; // find location of E or e (if present) // Find the ending position of the fracion part for (fracEnd = fracStart; fracEnd < len && TypeValidator.isDigit(content.charAt(fracEnd)); fracEnd++); } else { pvalue = Integer.parseInt(content.substring(intEnd + 1, len)); } } // no integer part, no fraction part, error. if (intStart == intEnd && fracStart == fracEnd) throw new NumberFormatException(); // ignore trailing zeroes in fraction part /*while (fracEnd > fracStart && content.charAt(fracEnd-1) == '0') { fracEnd--; }*/ // check whether there is non-digit characters in the fraction part for (int fracPos = fracStart; fracPos < fracEnd; fracPos++) { if (!TypeValidator.isDigit(content.charAt(fracPos))) throw new NumberFormatException(); } intDigits = intEnd - actualIntStart; fracDigits = fracEnd - fracStart; if (intDigits > 0) { ivalue = content.substring(actualIntStart, intEnd); } if (fracDigits > 0) { fvalue = content.substring(fracStart, fracEnd); if(fracEnd < len) { pvalue = Integer.parseInt(content.substring(fracEnd + 1, len)); } } totalDigits = intDigits + fracDigits; } // Construct a canonical String representation of this number // for the purpose of deriving a hashCode value compliant with // equals. // The toString representation will be: // NaN for NaN, INF for +infinity, -INF for -infinity, 0 for zero, // and [1-9].[0-9]*[1-9]?(E[1-9][0-9]*)? for other numbers. private static String canonicalToStringForHashCode(String ivalue, String fvalue, int sign, int pvalue) { if ("NaN".equals(ivalue)) { return "NaN"; } if ("INF".equals(ivalue)) { return sign < 0 ? "-INF" : "INF"; } final StringBuilder builder = new StringBuilder(); final int ilen = ivalue.length(); final int flen0 = fvalue.length(); int lastNonZero; for (lastNonZero = flen0; lastNonZero > 0 ; lastNonZero--) { if (fvalue.charAt(lastNonZero -1 ) != '0') break; } final int flen = lastNonZero; int iStart; int exponent = pvalue; for (iStart = 0; iStart < ilen; iStart++) { if (ivalue.charAt(iStart) != '0') break; } int fStart = 0; if (iStart < ivalue.length()) { builder.append(sign == -1 ? "-" : ""); builder.append(ivalue.charAt(iStart)); iStart++; } else { if (flen > 0) { for (fStart = 0; fStart < flen; fStart++) { if (fvalue.charAt(fStart) != '0') break; } if (fStart < flen) { builder.append(sign == -1 ? "-" : ""); builder.append(fvalue.charAt(fStart)); exponent -= ++fStart; } else { return "0"; } } else { return "0"; } } if (iStart < ilen || fStart < flen) { builder.append('.'); } while (iStart < ilen) { builder.append(ivalue.charAt(iStart++)); exponent++; } while (fStart < flen) { builder.append(fvalue.charAt(fStart++)); } if (exponent != 0) { builder.append("E").append(exponent); } return builder.toString(); } @Override public boolean equals(Object val) { if (val == this) return true; if (!(val instanceof XPrecisionDecimal)) return false; XPrecisionDecimal oval = (XPrecisionDecimal)val; return this.compareTo(oval) == EQUAL; } @Override public int hashCode() { // There's nothing else we can use easily, because equals could // return true for widely different representation of the // same number - and we don't have any canonical representation. // The problem here is that we must ensure that if two numbers // are equals then their hash code must also be equals. // hashCode for 1.01E1 should be the same as hashCode for 0.101E2 // So we call cannonicalToStringForHashCode - which implements an // algorithm that invents a normalized string representation // for this number, and we return a hash for that. return canonicalToStringForHashCode(ivalue, fvalue, sign, pvalue).hashCode(); } /** * @return */ private int compareFractionalPart(XPrecisionDecimal oval) { if(fvalue.equals(oval.fvalue)) return EQUAL; StringBuffer temp1 = new StringBuffer(fvalue); StringBuffer temp2 = new StringBuffer(oval.fvalue); truncateTrailingZeros(temp1, temp2); return temp1.toString().compareTo(temp2.toString()); } private void truncateTrailingZeros(StringBuffer fValue, StringBuffer otherFValue) { for(int i = fValue.length() - 1;i >= 0; i--) if(fValue.charAt(i) == '0') fValue.deleteCharAt(i); else break; for(int i = otherFValue.length() - 1;i >= 0; i--) if(otherFValue.charAt(i) == '0') otherFValue.deleteCharAt(i); else break; } public int compareTo(XPrecisionDecimal val) { // seen NaN if(sign == 0) return INDETERMINATE; //INF is greater than everything and equal to itself if(ivalue.equals("INF") || val.ivalue.equals("INF")) { if(ivalue.equals(val.ivalue)) return EQUAL; else if(ivalue.equals("INF")) return GREATER_THAN; return LESS_THAN; } //-INF is smaller than everything and equal itself if(ivalue.equals("-INF") || val.ivalue.equals("-INF")) { if(ivalue.equals(val.ivalue)) return EQUAL; else if(ivalue.equals("-INF")) return LESS_THAN; return GREATER_THAN; } if (sign != val.sign) return sign > val.sign ? GREATER_THAN : LESS_THAN; return sign * compare(val); } // To enable comparison - the exponent part of the decimal will be limited // to the max value of int. private int compare(XPrecisionDecimal val) { if(pvalue != 0 || val.pvalue != 0) { if(pvalue == val.pvalue) return intComp(val); else { if(intDigits + pvalue != val.intDigits + val.pvalue) return intDigits + pvalue > val.intDigits + val.pvalue ? GREATER_THAN : LESS_THAN; //otherwise the 2 combined values are the same if(pvalue > val.pvalue) { int expDiff = pvalue - val.pvalue; StringBuffer buffer = new StringBuffer(ivalue); StringBuffer fbuffer = new StringBuffer(fvalue); for(int i = 0;i < expDiff; i++) { if(i < fracDigits) { buffer.append(fvalue.charAt(i)); fbuffer.deleteCharAt(i); } else buffer.append('0'); } return compareDecimal(buffer.toString(), val.ivalue, fbuffer.toString(), val.fvalue); } else { int expDiff = val.pvalue - pvalue; StringBuffer buffer = new StringBuffer(val.ivalue); StringBuffer fbuffer = new StringBuffer(val.fvalue); for(int i = 0;i < expDiff; i++) { if(i < val.fracDigits) { buffer.append(val.fvalue.charAt(i)); fbuffer.deleteCharAt(i); } else buffer.append('0'); } return compareDecimal(ivalue, buffer.toString(), fvalue, fbuffer.toString()); } } } else { return intComp(val); } } /** * @param val * @return */ private int intComp(XPrecisionDecimal val) { if (intDigits != val.intDigits) return intDigits > val.intDigits ? GREATER_THAN : LESS_THAN; return compareDecimal(ivalue, val.ivalue, fvalue, val.fvalue); } /** * @param val * @return */ private int compareDecimal(String iValue, String fValue, String otherIValue, String otherFValue) { int ret = iValue.compareTo(otherIValue); if (ret != 0) return ret > 0 ? GREATER_THAN : LESS_THAN; if(fValue.equals(otherFValue)) return EQUAL; StringBuffer temp1=new StringBuffer(fValue); StringBuffer temp2=new StringBuffer(otherFValue); truncateTrailingZeros(temp1, temp2); ret = temp1.toString().compareTo(temp2.toString()); return ret == 0 ? EQUAL : (ret > 0 ? GREATER_THAN : LESS_THAN); } private String canonical; @Override public synchronized String toString() { if (canonical == null) { makeCanonical(); } return canonical; } private void makeCanonical() { // REVISIT: to be determined by working group canonical = "TBD by Working Group"; } /** * @param decimal * @return */ public boolean isIdentical(XPrecisionDecimal decimal) { if(ivalue.equals(decimal.ivalue) && (ivalue.equals("INF") || ivalue.equals("-INF") || ivalue.equals("NaN"))) return true; if(sign == decimal.sign && intDigits == decimal.intDigits && fracDigits == decimal.fracDigits && pvalue == decimal.pvalue && ivalue.equals(decimal.ivalue) && fvalue.equals(decimal.fvalue)) return true; return false; } } /* (non-Javadoc) * @see com.sun.org.apache.xerces.internal.impl.dv.xs.TypeValidator#getAllowedFacets() */ @Override public short getAllowedFacets() { return ( XSSimpleTypeDecl.FACET_PATTERN | XSSimpleTypeDecl.FACET_WHITESPACE | XSSimpleTypeDecl.FACET_ENUMERATION |XSSimpleTypeDecl.FACET_MAXINCLUSIVE |XSSimpleTypeDecl.FACET_MININCLUSIVE | XSSimpleTypeDecl.FACET_MAXEXCLUSIVE | XSSimpleTypeDecl.FACET_MINEXCLUSIVE | XSSimpleTypeDecl.FACET_TOTALDIGITS | XSSimpleTypeDecl.FACET_FRACTIONDIGITS); } /* (non-Javadoc) * @see com.sun.org.apache.xerces.internal.impl.dv.xs.TypeValidator#getActualValue(java.lang.String, com.sun.org.apache.xerces.internal.impl.dv.ValidationContext) */ @Override public Object getActualValue(String content, ValidationContext context) throws InvalidDatatypeValueException { try { return new XPrecisionDecimal(content); } catch (NumberFormatException nfe) { throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", new Object[]{content, "precisionDecimal"}); } } @Override public int compare(Object value1, Object value2) { return ((XPrecisionDecimal)value1).compareTo((XPrecisionDecimal)value2); } @Override public int getFractionDigits(Object value) { return ((XPrecisionDecimal)value).fracDigits; } @Override public int getTotalDigits(Object value) { return ((XPrecisionDecimal)value).totalDigits; } @Override public boolean isIdentical(Object value1, Object value2) { if(!(value2 instanceof XPrecisionDecimal) || !(value1 instanceof XPrecisionDecimal)) return false; return ((XPrecisionDecimal)value1).isIdentical((XPrecisionDecimal)value2); } }
⏎ com/sun/org/apache/xerces/internal/impl/dv/xs/PrecisionDecimalDV.java
Or download all of them as a single archive file:
File name: jre-rt-com-1.8.0_191-src.zip File size: 8099783 bytes Release date: 2018-10-28 Download
⇒ Backup JDK 8 Installation Directory
2023-02-07, 255110👍, 3💬
Popular Posts:
What Is fop.jar? I got it from the fop-2.7-bin.zip. fop.jar in fop-2.7-bin.zip is the JAR file for F...
commons-fileupload-1.3.3 -sources.jaris the source JAR file for Apache Commons FileUpload 1.3., whic...
io.jar is a component in iText Java library to provide input/output functionalities. iText Java libr...
What Is activation.jar? I heard it's related to JAF (JavaBeans Activation Framework) 1.0.2? The if y...
commons-net-1.4.1.jar is the JAR file for Apache Commons Net 1.4.1, which implements the client side...