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 17 jdk.unsupported.jmod - Unsupported Module
JDK 17 jdk.unsupported.jmod is the JMOD file for JDK 17 Unsupported module.
JDK 17 Unsupported module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\jdk.unsupported.jmod.
JDK 17 Unsupported module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Unsupported module source code files are stored in \fyicenter\jdk-17.0.5\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, 2021, 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.security.AccessController; import java.security.Permission; import java.security.PrivilegedAction; /** * 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(); @SuppressWarnings("removal") 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() { @SuppressWarnings("removal") 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); } /** * 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-17.0.5-src.zip File size: 18533 bytes Release date: 2022-09-13 Download
⇒ JDK 17 jdk.unsupported.desktop.jmod - Unsupported Desktop Module
2022-11-07, 1442👍, 0💬
Popular Posts:
JDOM provides a solution for using XML from Java that is as simple as Java itself. There is no compe...
JDK 11 jdk.scripting.nashorn.jm odis the JMOD file for JDK 11 Scripting Nashorn module. JDK 11 Scrip...
JRE 8 deploy.jar is the JAR file for JRE 8 Java Control Panel and other deploy tools. JRE (Java Runt...
JDK 11 jdk.jshell.jmod is the JMOD file for JDK 11 JShell tool, which can be invoked by the "jshell"...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...