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 - java.* 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 java.* package in JRE 1.8.0_191 rt.jar. Java source codes are also provided.
✍: FYIcenter
⏎ java/lang/invoke/AbstractValidatingLambdaMetafactory.java
/* * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package java.lang.invoke; import sun.invoke.util.Wrapper; import static sun.invoke.util.Wrapper.forPrimitiveType; import static sun.invoke.util.Wrapper.forWrapperType; import static sun.invoke.util.Wrapper.isWrapperType; /** * Abstract implementation of a lambda metafactory which provides parameter * unrolling and input validation. * * @see LambdaMetafactory */ /* package */ abstract class AbstractValidatingLambdaMetafactory { /* * For context, the comments for the following fields are marked in quotes * with their values, given this program: * interface II<T> { Object foo(T x); } * interface JJ<R extends Number> extends II<R> { } * class CC { String impl(int i) { return "impl:"+i; }} * class X { * public static void main(String[] args) { * JJ<Integer> iii = (new CC())::impl; * System.out.printf(">>> %s\n", iii.foo(44)); * }} */ final Class<?> targetClass; // The class calling the meta-factory via invokedynamic "class X" final MethodType invokedType; // The type of the invoked method "(CC)II" final Class<?> samBase; // The type of the returned instance "interface JJ" final String samMethodName; // Name of the SAM method "foo" final MethodType samMethodType; // Type of the SAM method "(Object)Object" final MethodHandle implMethod; // Raw method handle for the implementation method final MethodHandleInfo implInfo; // Info about the implementation method handle "MethodHandleInfo[5 CC.impl(int)String]" final int implKind; // Invocation kind for implementation "5"=invokevirtual final boolean implIsInstanceMethod; // Is the implementation an instance method "true" final Class<?> implDefiningClass; // Type defining the implementation "class CC" final MethodType implMethodType; // Type of the implementation method "(int)String" final MethodType instantiatedMethodType; // Instantiated erased functional interface method type "(Integer)Object" final boolean isSerializable; // Should the returned instance be serializable final Class<?>[] markerInterfaces; // Additional marker interfaces to be implemented final MethodType[] additionalBridges; // Signatures of additional methods to bridge /** * Meta-factory constructor. * * @param caller Stacked automatically by VM; represents a lookup context * with the accessibility privileges of the caller. * @param invokedType Stacked automatically by VM; the signature of the * invoked method, which includes the expected static * type of the returned lambda object, and the static * types of the captured arguments for the lambda. In * the event that the implementation method is an * instance method, the first argument in the invocation * signature will correspond to the receiver. * @param samMethodName Name of the method in the functional interface to * which the lambda or method reference is being * converted, represented as a String. * @param samMethodType Type of the method in the functional interface to * which the lambda or method reference is being * converted, represented as a MethodType. * @param implMethod The implementation method which should be called * (with suitable adaptation of argument types, return * types, and adjustment for captured arguments) when * methods of the resulting functional interface instance * are invoked. * @param instantiatedMethodType The signature of the primary functional * interface method after type variables are * substituted with their instantiation from * the capture site * @param isSerializable Should the lambda be made serializable? If set, * either the target type or one of the additional SAM * types must extend {@code Serializable}. * @param markerInterfaces Additional interfaces which the lambda object * should implement. * @param additionalBridges Method types for additional signatures to be * bridged to the implementation method * @throws LambdaConversionException If any of the meta-factory protocol * invariants are violated */ AbstractValidatingLambdaMetafactory(MethodHandles.Lookup caller, MethodType invokedType, String samMethodName, MethodType samMethodType, MethodHandle implMethod, MethodType instantiatedMethodType, boolean isSerializable, Class<?>[] markerInterfaces, MethodType[] additionalBridges) throws LambdaConversionException { if ((caller.lookupModes() & MethodHandles.Lookup.PRIVATE) == 0) { throw new LambdaConversionException(String.format( "Invalid caller: %s", caller.lookupClass().getName())); } this.targetClass = caller.lookupClass(); this.invokedType = invokedType; this.samBase = invokedType.returnType(); this.samMethodName = samMethodName; this.samMethodType = samMethodType; this.implMethod = implMethod; this.implInfo = caller.revealDirect(implMethod); this.implKind = implInfo.getReferenceKind(); this.implIsInstanceMethod = implKind == MethodHandleInfo.REF_invokeVirtual || implKind == MethodHandleInfo.REF_invokeSpecial || implKind == MethodHandleInfo.REF_invokeInterface; this.implDefiningClass = implInfo.getDeclaringClass(); this.implMethodType = implInfo.getMethodType(); this.instantiatedMethodType = instantiatedMethodType; this.isSerializable = isSerializable; this.markerInterfaces = markerInterfaces; this.additionalBridges = additionalBridges; if (!samBase.isInterface()) { throw new LambdaConversionException(String.format( "Functional interface %s is not an interface", samBase.getName())); } for (Class<?> c : markerInterfaces) { if (!c.isInterface()) { throw new LambdaConversionException(String.format( "Marker interface %s is not an interface", c.getName())); } } } /** * Build the CallSite. * * @return a CallSite, which, when invoked, will return an instance of the * functional interface * @throws ReflectiveOperationException */ abstract CallSite buildCallSite() throws LambdaConversionException; /** * Check the meta-factory arguments for errors * @throws LambdaConversionException if there are improper conversions */ void validateMetafactoryArgs() throws LambdaConversionException { switch (implKind) { case MethodHandleInfo.REF_invokeInterface: case MethodHandleInfo.REF_invokeVirtual: case MethodHandleInfo.REF_invokeStatic: case MethodHandleInfo.REF_newInvokeSpecial: case MethodHandleInfo.REF_invokeSpecial: break; default: throw new LambdaConversionException(String.format("Unsupported MethodHandle kind: %s", implInfo)); } // Check arity: optional-receiver + captured + SAM == impl final int implArity = implMethodType.parameterCount(); final int receiverArity = implIsInstanceMethod ? 1 : 0; final int capturedArity = invokedType.parameterCount(); final int samArity = samMethodType.parameterCount(); final int instantiatedArity = instantiatedMethodType.parameterCount(); if (implArity + receiverArity != capturedArity + samArity) { throw new LambdaConversionException( String.format("Incorrect number of parameters for %s method %s; %d captured parameters, %d functional interface method parameters, %d implementation parameters", implIsInstanceMethod ? "instance" : "static", implInfo, capturedArity, samArity, implArity)); } if (instantiatedArity != samArity) { throw new LambdaConversionException( String.format("Incorrect number of parameters for %s method %s; %d instantiated parameters, %d functional interface method parameters", implIsInstanceMethod ? "instance" : "static", implInfo, instantiatedArity, samArity)); } for (MethodType bridgeMT : additionalBridges) { if (bridgeMT.parameterCount() != samArity) { throw new LambdaConversionException( String.format("Incorrect number of parameters for bridge signature %s; incompatible with %s", bridgeMT, samMethodType)); } } // If instance: first captured arg (receiver) must be subtype of class where impl method is defined final int capturedStart; final int samStart; if (implIsInstanceMethod) { final Class<?> receiverClass; // implementation is an instance method, adjust for receiver in captured variables / SAM arguments if (capturedArity == 0) { // receiver is function parameter capturedStart = 0; samStart = 1; receiverClass = instantiatedMethodType.parameterType(0); } else { // receiver is a captured variable capturedStart = 1; samStart = 0; receiverClass = invokedType.parameterType(0); } // check receiver type if (!implDefiningClass.isAssignableFrom(receiverClass)) { throw new LambdaConversionException( String.format("Invalid receiver type %s; not a subtype of implementation type %s", receiverClass, implDefiningClass)); } Class<?> implReceiverClass = implMethod.type().parameterType(0); if (implReceiverClass != implDefiningClass && !implReceiverClass.isAssignableFrom(receiverClass)) { throw new LambdaConversionException( String.format("Invalid receiver type %s; not a subtype of implementation receiver type %s", receiverClass, implReceiverClass)); } } else { // no receiver capturedStart = 0; samStart = 0; } // Check for exact match on non-receiver captured arguments final int implFromCaptured = capturedArity - capturedStart; for (int i=0; i<implFromCaptured; i++) { Class<?> implParamType = implMethodType.parameterType(i); Class<?> capturedParamType = invokedType.parameterType(i + capturedStart); if (!capturedParamType.equals(implParamType)) { throw new LambdaConversionException( String.format("Type mismatch in captured lambda parameter %d: expecting %s, found %s", i, capturedParamType, implParamType)); } } // Check for adaptation match on SAM arguments final int samOffset = samStart - implFromCaptured; for (int i=implFromCaptured; i<implArity; i++) { Class<?> implParamType = implMethodType.parameterType(i); Class<?> instantiatedParamType = instantiatedMethodType.parameterType(i + samOffset); if (!isAdaptableTo(instantiatedParamType, implParamType, true)) { throw new LambdaConversionException( String.format("Type mismatch for lambda argument %d: %s is not convertible to %s", i, instantiatedParamType, implParamType)); } } // Adaptation match: return type Class<?> expectedType = instantiatedMethodType.returnType(); Class<?> actualReturnType = (implKind == MethodHandleInfo.REF_newInvokeSpecial) ? implDefiningClass : implMethodType.returnType(); Class<?> samReturnType = samMethodType.returnType(); if (!isAdaptableToAsReturn(actualReturnType, expectedType)) { throw new LambdaConversionException( String.format("Type mismatch for lambda return: %s is not convertible to %s", actualReturnType, expectedType)); } if (!isAdaptableToAsReturnStrict(expectedType, samReturnType)) { throw new LambdaConversionException( String.format("Type mismatch for lambda expected return: %s is not convertible to %s", expectedType, samReturnType)); } for (MethodType bridgeMT : additionalBridges) { if (!isAdaptableToAsReturnStrict(expectedType, bridgeMT.returnType())) { throw new LambdaConversionException( String.format("Type mismatch for lambda expected return: %s is not convertible to %s", expectedType, bridgeMT.returnType())); } } } /** * Check type adaptability for parameter types. * @param fromType Type to convert from * @param toType Type to convert to * @param strict If true, do strict checks, else allow that fromType may be parameterized * @return True if 'fromType' can be passed to an argument of 'toType' */ private boolean isAdaptableTo(Class<?> fromType, Class<?> toType, boolean strict) { if (fromType.equals(toType)) { return true; } if (fromType.isPrimitive()) { Wrapper wfrom = forPrimitiveType(fromType); if (toType.isPrimitive()) { // both are primitive: widening Wrapper wto = forPrimitiveType(toType); return wto.isConvertibleFrom(wfrom); } else { // from primitive to reference: boxing return toType.isAssignableFrom(wfrom.wrapperType()); } } else { if (toType.isPrimitive()) { // from reference to primitive: unboxing Wrapper wfrom; if (isWrapperType(fromType) && (wfrom = forWrapperType(fromType)).primitiveType().isPrimitive()) { // fromType is a primitive wrapper; unbox+widen Wrapper wto = forPrimitiveType(toType); return wto.isConvertibleFrom(wfrom); } else { // must be convertible to primitive return !strict; } } else { // both are reference types: fromType should be a superclass of toType. return !strict || toType.isAssignableFrom(fromType); } } } /** * Check type adaptability for return types -- * special handling of void type) and parameterized fromType * @return True if 'fromType' can be converted to 'toType' */ private boolean isAdaptableToAsReturn(Class<?> fromType, Class<?> toType) { return toType.equals(void.class) || !fromType.equals(void.class) && isAdaptableTo(fromType, toType, false); } private boolean isAdaptableToAsReturnStrict(Class<?> fromType, Class<?> toType) { if (fromType.equals(void.class)) return toType.equals(void.class); return isAdaptableTo(fromType, toType, true); } /*********** Logging support -- for debugging only, uncomment as needed static final Executor logPool = Executors.newSingleThreadExecutor(); protected static void log(final String s) { MethodHandleProxyLambdaMetafactory.logPool.execute(new Runnable() { @Override public void run() { System.out.println(s); } }); } protected static void log(final String s, final Throwable e) { MethodHandleProxyLambdaMetafactory.logPool.execute(new Runnable() { @Override public void run() { System.out.println(s); e.printStackTrace(System.out); } }); } ***********************/ }
⏎ java/lang/invoke/AbstractValidatingLambdaMetafactory.java
Or download all of them as a single archive file:
File name: jre-rt-java-1.8.0_191-src.zip File size: 6664831 bytes Release date: 2018-10-28 Download
⇒ JRE 8 rt.jar - javax.* Package Source Code
2023-08-23, 247608👍, 4💬
Popular Posts:
commons-lang-1.0.1.jar is the JAR file for Apache Commons Lang 1.0.1, which provides a host of helpe...
The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms, it was develo...
How to download and install javamail-1_2.zip? The JavaMail API is a set of abstract APIs that model ...
JDK 11 jdk.javadoc.jmod is the JMOD file for JDK 11 Java Document tool, which can be invoked by the ...
Apache Commons Codec library provides implementations of common encoders and decoders such as Base64...