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 jdk.unsupported.jmod - Unsupported Module
JDK 11 jdk.unsupported.jmod is the JMOD file for JDK 11 Unsupported module.
JDK 11 Unsupported module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.unsupported.jmod.
JDK 11 Unsupported module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Unsupported module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.unsupported.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ sun/reflect/ReflectionFactory.java
/* * Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package sun.reflect; import java.io.OptionalDataException; import java.lang.invoke.MethodHandle; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.UndeclaredThrowableException; import java.security.AccessControlContext; import java.security.AccessController; import java.security.Permission; import java.security.ProtectionDomain; import java.security.PrivilegedAction; import jdk.internal.misc.SharedSecrets; import jdk.internal.misc.JavaSecurityAccess; /** * ReflectionFactory supports custom serialization. * Its methods support the creation of uninitialized objects, invoking serialization * private methods for readObject, writeObject, readResolve, and writeReplace. * <p> * ReflectionFactory access is restricted, if a security manager is active, * unless the permission {@code RuntimePermission("reflectionFactoryAccess")} * is granted. */ public class ReflectionFactory { private static final ReflectionFactory soleInstance = new ReflectionFactory(); private static final jdk.internal.reflect.ReflectionFactory delegate = AccessController.doPrivileged( new PrivilegedAction<jdk.internal.reflect.ReflectionFactory>() { public jdk.internal.reflect.ReflectionFactory run() { return jdk.internal.reflect.ReflectionFactory.getReflectionFactory(); } }); private ReflectionFactory() {} private static final Permission REFLECTION_FACTORY_ACCESS_PERM = new RuntimePermission("reflectionFactoryAccess"); /** * Provides the caller with the capability to instantiate reflective * objects. * * <p> First, if there is a security manager, its {@code checkPermission} * method is called with a {@link java.lang.RuntimePermission} with target * {@code "reflectionFactoryAccess"}. This may result in a security * exception. * * <p> The returned {@code ReflectionFactory} object should be carefully * guarded by the caller, since it can be used to read and write private * data and invoke private methods, as well as to load unverified bytecodes. * It must never be passed to untrusted code. * * @return the ReflectionFactory * @throws SecurityException if a security manager exists and its * {@code checkPermission} method doesn't allow access to * the RuntimePermission "reflectionFactoryAccess". */ public static ReflectionFactory getReflectionFactory() { SecurityManager security = System.getSecurityManager(); if (security != null) { security.checkPermission(REFLECTION_FACTORY_ACCESS_PERM); } return soleInstance; } /** * Returns an accessible constructor capable of creating instances * of the given class, initialized by the given constructor. * * @param cl the class to instantiate * @param constructorToCall the constructor to call * @return an accessible constructor */ public Constructor<?> newConstructorForSerialization(Class<?> cl, Constructor<?> constructorToCall) { return delegate.newConstructorForSerialization(cl, constructorToCall); } /** * Returns an accessible no-arg constructor for a class. * The no-arg constructor is found searching the class and its supertypes. * * @param cl the class to instantiate * @return a no-arg constructor for the class or {@code null} if * the class or supertypes do not have a suitable no-arg constructor */ public final Constructor<?> newConstructorForSerialization(Class<?> cl) { return delegate.newConstructorForSerialization(cl); } /** * Returns an accessible no-arg constructor for an externalizable class to be * initialized using a public no-argument constructor. * * @param cl the class to instantiate * @return A no-arg constructor for the class; returns {@code null} if * the class does not implement {@link java.io.Externalizable} */ public final Constructor<?> newConstructorForExternalization(Class<?> cl) { return delegate.newConstructorForExternalization(cl); } /** * Returns a direct MethodHandle for the {@code readObject} method on * a Serializable class. * The first argument of {@link MethodHandle#invoke} is the serializable * object and the second argument is the {@code ObjectInputStream} passed to * {@code readObject}. * * @param cl a Serializable class * @return a direct MethodHandle for the {@code readObject} method of the class or * {@code null} if the class does not have a {@code readObject} method */ public final MethodHandle readObjectForSerialization(Class<?> cl) { return delegate.readObjectForSerialization(cl); } /** * Invokes the supplied constructor, adding the provided protection domains * to the invocation stack before invoking {@code Constructor::newInstance}. * If no {@linkplain System#getSecurityManager() security manager} is present, * or no domains are provided, then this method simply calls * {@code cons.newInstance()}. Otherwise, it invokes the provided constructor * with privileges at the intersection of the current context and the provided * protection domains. * * @param cons A constructor obtained from {@code * newConstructorForSerialization} or {@code * newConstructorForExternalization}. * @param domains An array of protection domains that limit the privileges * with which the constructor is invoked. Can be {@code null} * or empty, in which case privileges are only limited by the * {@linkplain AccessController#getContext() current context}. * * @return A new object built from the provided constructor. * * @throws NullPointerException if {@code cons} is {@code null}. * @throws InstantiationException if thrown by {@code cons.newInstance()}. * @throws InvocationTargetException if thrown by {@code cons.newInstance()}. * @throws IllegalAccessException if thrown by {@code cons.newInstance()}. */ public final Object newInstanceForSerialization(Constructor<?> cons, ProtectionDomain[] domains) throws InstantiationException, InvocationTargetException, IllegalAccessException { SecurityManager sm = System.getSecurityManager(); if (sm == null || domains == null || domains.length == 0) { return cons.newInstance(); } else { JavaSecurityAccess jsa = SharedSecrets.getJavaSecurityAccess(); PrivilegedAction<?> pea = () -> { try { return cons.newInstance(); } catch (InstantiationException | InvocationTargetException | IllegalAccessException x) { throw new UndeclaredThrowableException(x); } }; // Can't use PrivilegedExceptionAction with jsa try { return jsa.doIntersectionPrivilege(pea, AccessController.getContext(), new AccessControlContext(domains)); } catch (UndeclaredThrowableException x) { Throwable cause = x.getCause(); if (cause instanceof InstantiationException) throw (InstantiationException) cause; if (cause instanceof InvocationTargetException) throw (InvocationTargetException) cause; if (cause instanceof IllegalAccessException) throw (IllegalAccessException) cause; // not supposed to happen throw x; } } } /** * Returns a direct MethodHandle for the {@code readObjectNoData} method on * a Serializable class. * The first argument of {@link MethodHandle#invoke} is the serializable * object and the second argument is the {@code ObjectInputStream} passed to * {@code readObjectNoData}. * * @param cl a Serializable class * @return a direct MethodHandle for the {@code readObjectNoData} method * of the class or {@code null} if the class does not have a * {@code readObjectNoData} method */ public final MethodHandle readObjectNoDataForSerialization(Class<?> cl) { return delegate.readObjectNoDataForSerialization(cl); } /** * Returns a direct MethodHandle for the {@code writeObject} method on * a Serializable class. * The first argument of {@link MethodHandle#invoke} is the serializable * object and the second argument is the {@code ObjectOutputStream} passed to * {@code writeObject}. * * @param cl a Serializable class * @return a direct MethodHandle for the {@code writeObject} method of the class or * {@code null} if the class does not have a {@code writeObject} method */ public final MethodHandle writeObjectForSerialization(Class<?> cl) { return delegate.writeObjectForSerialization(cl); } /** * Returns a direct MethodHandle for the {@code readResolve} method on * a serializable class. * The single argument of {@link MethodHandle#invoke} is the serializable * object. * * @param cl the Serializable class * @return a direct MethodHandle for the {@code readResolve} method of the class or * {@code null} if the class does not have a {@code readResolve} method */ public final MethodHandle readResolveForSerialization(Class<?> cl) { return delegate.readResolveForSerialization(cl); } /** * Returns a direct MethodHandle for the {@code writeReplace} method on * a serializable class. * The single argument of {@link MethodHandle#invoke} is the serializable * object. * * @param cl the Serializable class * @return a direct MethodHandle for the {@code writeReplace} method of the class or * {@code null} if the class does not have a {@code writeReplace} method */ public final MethodHandle writeReplaceForSerialization(Class<?> cl) { return delegate.writeReplaceForSerialization(cl); } /** * Returns true if the class has a static initializer. * The presence of a static initializer is used to compute the serialVersionUID. * @param cl a serializable class * @return {@code true} if the class has a static initializer, * otherwise {@code false} */ public final boolean hasStaticInitializerForSerialization(Class<?> cl) { return delegate.hasStaticInitializerForSerialization(cl); } /** * Returns a new OptionalDataException with {@code eof} set to {@code true} * or {@code false}. * @param bool the value of {@code eof} in the created OptionalDataException * @return a new OptionalDataException */ public final OptionalDataException newOptionalDataExceptionForSerialization(boolean bool) { Constructor<OptionalDataException> cons = delegate.newOptionalDataExceptionForSerialization(); try { return cons.newInstance(bool); } catch (InstantiationException|IllegalAccessException|InvocationTargetException ex) { throw new InternalError("unable to create OptionalDataException", ex); } } }
⏎ sun/reflect/ReflectionFactory.java
Or download all of them as a single archive file:
File name: jdk.unsupported-11.0.1-src.zip File size: 18487 bytes Release date: 2018-11-04 Download
⇒ JDK 11 jdk.unsupported.desktop.jmod - Unsupported Desktop Module
2020-04-14, 9844👍, 0💬
Popular Posts:
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...
How to download and install Apache XMLBeans-2.6.0.zip? If you want to try the XMLBeans Java library,...
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
Java Advanced Imaging (JAI) is a Java platform extension API that provides a set of object-oriented ...
How to display XML element type information with the jaxp\TypeInfoWriter.java provided in the Apache...