Modifier and Type	Class and Description
private static record	MethodHandleProxies.MethodInfo
private static class	MethodHandleProxies.WeakReferenceHolder<T>

Modifier and Type	Field and Description
private static final ClassDesc	CD_IllegalAccessException
private static final ClassDesc	CD_UndeclaredThrowableException
private static final AtomicInteger	counter
private static final List<ClassDesc>	DEFAULT_RETHROWS
private static final ClassFileDumper	DUMPER
private static final String	ENSURE_ORIGINAL_LOOKUP
private static final JavaLangReflectAccess	JLRA
private static final MethodType	MT_MethodHandle_Object
private static final MethodType	MT_Object_Lookup_MethodHandle_MethodHandle
private static final MethodType	MT_void_Lookup_MethodHandle_MethodHandle
private static final MethodTypeDesc	MTD_Class
private static final MethodTypeDesc	MTD_int
private static final MethodTypeDesc	MTD_MethodHandle_MethodType
private static final MethodTypeDesc	MTD_String
private static final MethodTypeDesc	MTD_void_Lookup
private static final MethodTypeDesc	MTD_void_Lookup_MethodHandle_MethodHandle
private static final MethodTypeDesc	MTD_void_String
private static final MethodTypeDesc	MTD_void_Throwable
private static final ClassValue<MethodHandleProxies.WeakReferenceHolder<Class<?>>>	PROXIES
private static final String	TARGET_NAME
private static final String	TYPE_NAME
private static final Set<Class<?>>	WRAPPER_TYPES

Access	Constructor and Description
private	MethodHandleProxies()

Method Summary

Modifier and Type	Method and Description
private static void	addElementType(Set<Class<?>> types, Class<?> cls)
private static void	addElementTypes(Set<Class<?>> types, Class<?>... classes)
public static < the desired type of the wrapper, a single-method interface T> T	Returns: a correctly-typed wrapper for the given target asInterfaceInstance(final Class<T> a class object representing `T` intfc, final MethodHandle the method handle to invoke from the wrapper target) Produces an instance of the given single-method interface which redirects its calls to the given method handle.
private static MethodHandle	bindCaller(MethodHandle target, Class<?> hostClass)
private static byte[]	Returns: the bytes of the implementation classes createTemplate(ClassLoader loader, ClassDesc proxyDesc, ClassDesc the given interface ifaceDesc, String the name of the single abstract method methodName, List<MethodHandleProxies.MethodInfo> the information for implementation methods methods) Creates an implementation class file for a given interface.
private static void	ensureAccess(Module target, Class<?> c)
private static Class<?>	getProxyClass(Class<?> intfc)
private static boolean	isObjectMethod(Method m)
public static boolean	Returns: true if the reference is not null and points to an object produced by `asInterfaceInstance` isWrapperInstance(Object any reference x) Determines if the given object was produced by a call to `asInterfaceInstance`.
private static Module	newDynamicModule(ClassLoader ld, Set<Class<?>> types) Create a dynamic module defined to the given class loader and has access to the given types.
private static Class<?>	newProxyClass(Class<?> intfc)
private static String	nextModuleName()
public static MethodHandle	Returns: a method handle implementing the unique method wrapperInstanceTarget(Object any reference x) Produces or recovers a target method handle which is behaviorally equivalent to the unique method of this wrapper instance.
public static Class<?>	Returns: the single-method interface type for which the wrapper was created wrapperInstanceType(Object any reference x) Recovers the unique single-method interface type for which this wrapper instance was created.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Field Detail

CD_IllegalAccessException	back to summary
private static final ClassDesc CD_IllegalAccessException

CD_UndeclaredThrowableException	back to summary
private static final ClassDesc CD_UndeclaredThrowableException

counter	back to summary
private static final AtomicInteger counter

DEFAULT_RETHROWS	back to summary
private static final List<ClassDesc> DEFAULT_RETHROWS

DUMPER	back to summary
private static final ClassFileDumper DUMPER

ENSURE_ORIGINAL_LOOKUP	back to summary
private static final String ENSURE_ORIGINAL_LOOKUP

JLRA	back to summary
private static final JavaLangReflectAccess JLRA

MT_MethodHandle_Object	back to summary
private static final MethodType MT_MethodHandle_Object

MT_Object_Lookup_MethodHandle_MethodHandle	back to summary
private static final MethodType MT_Object_Lookup_MethodHandle_MethodHandle

MT_void_Lookup_MethodHandle_MethodHandle	back to summary
private static final MethodType MT_void_Lookup_MethodHandle_MethodHandle

MTD_Class	back to summary
private static final MethodTypeDesc MTD_Class

MTD_int	back to summary
private static final MethodTypeDesc MTD_int

MTD_MethodHandle_MethodType	back to summary
private static final MethodTypeDesc MTD_MethodHandle_MethodType

MTD_String	back to summary
private static final MethodTypeDesc MTD_String

MTD_void_Lookup	back to summary
private static final MethodTypeDesc MTD_void_Lookup

MTD_void_Lookup_MethodHandle_MethodHandle	back to summary
private static final MethodTypeDesc MTD_void_Lookup_MethodHandle_MethodHandle

MTD_void_String	back to summary
private static final MethodTypeDesc MTD_void_String

MTD_void_Throwable	back to summary
private static final MethodTypeDesc MTD_void_Throwable

PROXIES	back to summary
private static final ClassValue<MethodHandleProxies.WeakReferenceHolder<Class<?>>> PROXIES

TARGET_NAME	back to summary
private static final String TARGET_NAME

TYPE_NAME	back to summary
private static final String TYPE_NAME

WRAPPER_TYPES	back to summary
private static final Set<Class<?>> WRAPPER_TYPES

Constructor Detail

MethodHandleProxies	back to summary
private MethodHandleProxies()

Method Detail

addElementType	back to summary
private static void addElementType(Set<Class<?>> types, Class<?> cls)

addElementTypes	back to summary
private static void addElementTypes(Set<Class<?>> types, Class<?>... classes)

asInterfaceInstance back to summary

asInterfaceInstance	back to summary
public static <T> T asInterfaceInstance(final Class<T> intfc, final MethodHandle target) Produces an instance of the given single-method interface which redirects its calls to the given method handle. A single-method interface is an interface which declares a uniquely named method. When determining the uniquely named method of a single-method interface, the public `Object` methods (`toString`, `equals`, `hashCode`) are disregarded as are any default (non-abstract) methods. For example, `java.util.Comparator` is a single-method interface, even though it re-declares the `Object.equals` method and also declares default methods, such as `Comparator.reverse`. The interface must be public, not hidden, and not sealed. No additional access checks are performed. The resulting instance of the required type will respond to invocation of the type's uniquely named method by calling the given target on the incoming arguments, and returning or throwing whatever the target returns or throws. The invocation will be as if by `target.invoke`. The target's type will be checked before the instance is created, as if by a call to `asType`, which may result in a `WrongMethodTypeException`. The uniquely named method is allowed to be multiply declared, with distinct type descriptors. (E.g., it can be overloaded, or can possess bridge methods.) All such declarations are connected directly to the target method handle. Argument and return types are adjusted by `asType` for each individual declaration. The wrapper instance will implement the requested interface and its super-types, but no other single-method interfaces. This means that the instance will not unexpectedly pass an `instanceof` test for any unrequested type. Implementation Note Therefore, each instance must implement a unique single-method interface. Implementations may not bundle together multiple single-method interfaces onto single implementation classes in the style of `java.desktop/java.awt.AWTEventMulticaster`. The method handle may throw an undeclared exception, which means any checked exception (or other checked throwable) not declared by the requested type's single abstract method. If this happens, the throwable will be wrapped in an instance of `UndeclaredThrowableException` and thrown in that wrapped form. Like `Integer.valueOf`, `asInterfaceInstance` is a factory method whose results are defined by their behavior. It is not guaranteed to return a new instance for every call. Because of the possibility of bridge methods and other corner cases, the interface may also have several abstract methods with the same name but having distinct descriptors (types of returns and parameters). In this case, all the methods are bound in common to the one given target. The type check and effective `asType` conversion is applied to each method type descriptor, and all abstract methods are bound to the target in common. Beyond this type check, no further checks are made to determine that the abstract methods are related in any way. Future versions of this API may accept additional types, such as abstract classes with single abstract methods. Future versions of this API may also equip wrapper instances with one or more additional public "marker" interfaces. Parameters <T> the desired type of the wrapper, a single-method interface intfc:Class<T> a class object representing `T` target:MethodHandle the method handle to invoke from the wrapper Returns:T a correctly-typed wrapper for the given target Annotations @SuppressWarnings:doclint:reference Exceptions NullPointerException: if either argument is null IllegalArgumentException: if the `intfc` is not a valid argument to this method WrongMethodTypeException: if the target cannot be converted to the type required by the requested interface

public static <T> T asInterfaceInstance(final Class<T> intfc, final MethodHandle target)

Produces an instance of the given single-method interface which redirects its calls to the given method handle.

A single-method interface is an interface which declares a uniquely named method. When determining the uniquely named method of a single-method interface, the public Object methods (toString, equals, hashCode) are disregarded as are any default (non-abstract) methods. For example, java.util.Comparator is a single-method interface, even though it re-declares the Object.equals method and also declares default methods, such as Comparator.reverse.

The interface must be public, not hidden, and not sealed. No additional access checks are performed.

The resulting instance of the required type will respond to invocation of the type's uniquely named method by calling the given target on the incoming arguments, and returning or throwing whatever the target returns or throws. The invocation will be as if by target.invoke. The target's type will be checked before the instance is created, as if by a call to asType, which may result in a WrongMethodTypeException.

The uniquely named method is allowed to be multiply declared, with distinct type descriptors. (E.g., it can be overloaded, or can possess bridge methods.) All such declarations are connected directly to the target method handle. Argument and return types are adjusted by asType for each individual declaration.

The wrapper instance will implement the requested interface and its super-types, but no other single-method interfaces. This means that the instance will not unexpectedly pass an instanceof test for any unrequested type.

Implementation Note

Therefore, each instance must implement a unique single-method interface. Implementations may not bundle together multiple single-method interfaces onto single implementation classes in the style of java.desktop/java.awt.AWTEventMulticaster.

The method handle may throw an undeclared exception, which means any checked exception (or other checked throwable) not declared by the requested type's single abstract method. If this happens, the throwable will be wrapped in an instance of UndeclaredThrowableException and thrown in that wrapped form.

Like Integer.valueOf, asInterfaceInstance is a factory method whose results are defined by their behavior. It is not guaranteed to return a new instance for every call.

Because of the possibility of bridge methods and other corner cases, the interface may also have several abstract methods with the same name but having distinct descriptors (types of returns and parameters). In this case, all the methods are bound in common to the one given target. The type check and effective asType conversion is applied to each method type descriptor, and all abstract methods are bound to the target in common. Beyond this type check, no further checks are made to determine that the abstract methods are related in any way.

Future versions of this API may accept additional types, such as abstract classes with single abstract methods. Future versions of this API may also equip wrapper instances with one or more additional public "marker" interfaces.

Parameters

<T>: the desired type of the wrapper, a single-method interface
intfc:Class<T>: a class object representing T
target:MethodHandle: the method handle to invoke from the wrapper

Returns:T

a correctly-typed wrapper for the given target

Annotations

@SuppressWarnings:doclint:reference

Exceptions

NullPointerException:: if either argument is null
IllegalArgumentException:: if the intfc is not a valid argument to this method
WrongMethodTypeException:: if the target cannot be converted to the type required by the requested interface

bindCaller	back to summary
private static MethodHandle bindCaller(MethodHandle target, Class<?> hostClass)

createTemplate	back to summary
private static byte[] createTemplate(ClassLoader loader, ClassDesc proxyDesc, ClassDesc ifaceDesc, String methodName, List<MethodHandleProxies.MethodInfo> methods) Creates an implementation class file for a given interface. One implementation class is defined for each interface. Parameters ifaceDesc:ClassDesc the given interface methodName:String the name of the single abstract method methods:List<MethodHandleProxies.MethodInfo> the information for implementation methods Returns:byte[] the bytes of the implementation classes

createTemplate

back to summary

private static byte[] createTemplate(ClassLoader loader, ClassDesc proxyDesc, ClassDesc ifaceDesc, String methodName, List<MethodHandleProxies.MethodInfo> methods)

Creates an implementation class file for a given interface. One implementation class is defined for each interface.

Parameters

ifaceDesc:ClassDesc: the given interface
methodName:String: the name of the single abstract method
methods:List<MethodHandleProxies.MethodInfo>: the information for implementation methods

Returns:byte[]

the bytes of the implementation classes

ensureAccess	back to summary
private static void ensureAccess(Module target, Class<?> c)

getProxyClass	back to summary
private static Class<?> getProxyClass(Class<?> intfc)

isObjectMethod	back to summary
private static boolean isObjectMethod(Method m)

isWrapperInstance back to summary

isWrapperInstance	back to summary
public static boolean isWrapperInstance(Object x) Determines if the given object was produced by a call to `asInterfaceInstance`. Parameters x:Object any reference Returns:boolean true if the reference is not null and points to an object produced by `asInterfaceInstance`

public static boolean isWrapperInstance(Object x)

Determines if the given object was produced by a call to asInterfaceInstance.

Parameters

x:Object: any reference

Returns:boolean

true if the reference is not null and points to an object produced by asInterfaceInstance

newDynamicModule	back to summary
private static Module newDynamicModule(ClassLoader ld, Set<Class<?>> types) Create a dynamic module defined to the given class loader and has access to the given types. The dynamic module contains only one single package named the same as the name of the dynamic module. It's not exported or open.

newDynamicModule

back to summary

private static Module newDynamicModule(ClassLoader ld, Set<Class<?>> types)

Create a dynamic module defined to the given class loader and has access to the given types.

The dynamic module contains only one single package named the same as the name of the dynamic module. It's not exported or open.

newProxyClass	back to summary
private static Class<?> newProxyClass(Class<?> intfc)

nextModuleName	back to summary
private static String nextModuleName()

wrapperInstanceTarget back to summary

wrapperInstanceTarget	back to summary
public static MethodHandle wrapperInstanceTarget(Object x) Produces or recovers a target method handle which is behaviorally equivalent to the unique method of this wrapper instance. The object `x` must have been produced by a call to `asInterfaceInstance`. This requirement may be tested via `isWrapperInstance`. Parameters x:Object any reference Returns:MethodHandle a method handle implementing the unique method Exceptions IllegalArgumentException: if the reference x is not to a wrapper instance

public static MethodHandle wrapperInstanceTarget(Object x)

Produces or recovers a target method handle which is behaviorally equivalent to the unique method of this wrapper instance. The object x must have been produced by a call to asInterfaceInstance. This requirement may be tested via isWrapperInstance.

Parameters

x:Object: any reference

Returns:MethodHandle

a method handle implementing the unique method

Exceptions

IllegalArgumentException:: if the reference x is not to a wrapper instance

wrapperInstanceType back to summary

wrapperInstanceType	back to summary
public static Class<?> wrapperInstanceType(Object x) Recovers the unique single-method interface type for which this wrapper instance was created. The object `x` must have been produced by a call to `asInterfaceInstance`. This requirement may be tested via `isWrapperInstance`. Parameters x:Object any reference Returns:Class<?> the single-method interface type for which the wrapper was created Exceptions IllegalArgumentException: if the reference x is not to a wrapper instance

public static Class<?> wrapperInstanceType(Object x)

Recovers the unique single-method interface type for which this wrapper instance was created. The object x must have been produced by a call to asInterfaceInstance. This requirement may be tested via isWrapperInstance.

Parameters

x:Object: any reference

Returns:Class<?>

the single-method interface type for which the wrapper was created

Exceptions

IllegalArgumentException:: if the reference x is not to a wrapper instance

java.lang.invoke back to summary

private final Record MethodHandleProxies.MethodInfo

Class Inheritance

extends Record

java.lang.Object
java.lang.Record
java.lang.invoke.MethodHandleProxies.MethodInfo

Record Components

desc:MethodTypeDesc
thrown:List<ClassDesc>
fieldName:String

Field Summary

Modifier and Type	Field and Description
private final MethodTypeDesc	desc Record Component accessed by desc().
private final String	fieldName Record Component accessed by fieldName().
private final List<ClassDesc>	thrown Record Component accessed by thrown().

Constructor Summary

Access	Constructor and Description
private	MethodInfo(MethodTypeDesc desc, List<ClassDesc> thrown, String fieldName)

Method Summary

Modifier and Type	Method and Description
public MethodTypeDesc	desc() Record Component getter of desc.
public final boolean	equals(Object o) Implements abstract java.lang.Record.equals. Indicates whether some other object is "equal to" this one.
public String	fieldName() Record Component getter of fieldName.
public final int	hashCode() Implements abstract java.lang.Record.hashCode. Returns a hash code value for the record.
public List<ClassDesc>	thrown() Record Component getter of thrown.
public final String	toString() Implements abstract java.lang.Record.toString. Returns a string representation of the record.

Field Detail

desc	back to summary
private final MethodTypeDesc desc Record Component accessed by desc().

fieldName	back to summary
private final String fieldName Record Component accessed by fieldName().

thrown	back to summary
private final List<ClassDesc> thrown Record Component accessed by thrown().

Constructor Detail

MethodInfo	back to summary
private MethodInfo(MethodTypeDesc desc, List<ClassDesc> thrown, String fieldName)

Method Detail

desc	back to summary
public MethodTypeDesc desc() Record Component getter of desc.

equals back to summary

equals	back to summary
public final boolean equals(Object o) Implements abstract java.lang.Record.equals. Doc from java.lang.Record.equals. Indicates whether some other object is "equal to" this one. In addition to the general contract of `Object.equals`, record classes must further obey the invariant that when a record instance is "copied" by passing the result of the record component accessor methods to the canonical constructor, as follows: R copy = new R(r.c1(), r.c2(), ..., r.cn()); then it must be the case that `r.equals(copy)`.

public final boolean equals(Object o)

Implements abstract java.lang.Record.equals.

Doc from java.lang.Record.equals.

Indicates whether some other object is "equal to" this one. In addition to the general contract of Object.equals, record classes must further obey the invariant that when a record instance is "copied" by passing the result of the record component accessor methods to the canonical constructor, as follows:

    R copy = new R(r.c1(), r.c2(), ..., r.cn());

then it must be the case that r.equals(copy).

fieldName	back to summary
public String fieldName() Record Component getter of fieldName.

hashCode back to summary

public final int hashCode()

Implements abstract java.lang.Record.hashCode.

Doc from java.lang.Record.hashCode.

Returns a hash code value for the record. Obeys the general contract of Object.hashCode. For records, hashing behavior is constrained by the refined contract of Record.equals, so that any two records created from the same components must have the same hash code.

thrown	back to summary
public List<ClassDesc> thrown() Record Component getter of thrown.

toString back to summary

public final String toString()

Implements abstract java.lang.Record.toString.

Doc from java.lang.Record.toString.

Returns a string representation of the record. In accordance with the general contract of Object#toString(), the toString method returns a string that "textually represents" this record. The result should be a concise but informative representation that is easy for a person to read.

In addition to this general contract, record classes must further participate in the invariant that any two records which are equal must produce equal strings. This invariant is necessarily relaxed in the rare case where corresponding equal component values might fail to produce equal strings for themselves.

Modifier and Type	Method and Description
pack-priv T	get()
pack-priv void	set(T value)

public final Class MethodHandleProxies

Nested and Inner Type Summary

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private final Record MethodHandleProxies.MethodInfo

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail

private final Class MethodHandleProxies.WeakReferenceHolder<T>

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail