Implements jdk.dynalink.linker.LinkerServices.asType.

Doc from jdk.dynalink.linker.LinkerServices.asType.

Similar to MethodHandle#asType(MethodType) except it also hooks in method handles produced by all available GuardingTypeConverterFactory implementations, providing for language-specific type coercing of parameters. It will apply MethodHandle#asType(MethodType) for all primitive-to-primitive, wrapper-to-primitive, primitive-to-wrapper conversions as well as for all upcasts. For all other conversions, it'll insert MethodHandles#filterArguments(MethodHandle, int, MethodHandle...) with composite filters provided by GuardingTypeConverterFactory implementations.

Annotations

@Override

Implements jdk.dynalink.linker.LinkerServices.canConvert.

Doc from jdk.dynalink.linker.LinkerServices.canConvert.

Returns true if there might exist a conversion between the requested types (either an automatic JVM conversion, or one provided by any available GuardingTypeConverterFactory), or false if there definitely does not exist a conversion between the requested types. Note that returning true does not guarantee that the conversion will succeed at runtime for all values (especially if the "from" or "to" types are sufficiently generic), but returning false guarantees that it would fail.

Annotations

@Override

Implements jdk.dynalink.linker.LinkerServices.compareConversion.

Doc from jdk.dynalink.linker.LinkerServices.compareConversion.

Determines which of the two type conversions from a source type to the two target types is preferred. This is used for dynamic overloaded method resolution. If the source type is convertible to exactly one target type with a method invocation conversion, it is chosen, otherwise available ConversionComparators are consulted.

Annotations

@Override

Implements jdk.dynalink.linker.LinkerServices.filterInternalObjects.

Doc from jdk.dynalink.linker.LinkerServices.filterInternalObjects.

Modifies the method handle so that any parameters that can receive potentially internal language runtime objects will have a filter added on them to prevent them from escaping, potentially by wrapping them. It can also potentially add an unwrapping filter to the return value. Basically transforms the method handle using the transformer configured by DynamicLinkerFactory#setInternalObjectsFilter(MethodHandleTransformer).

Annotations

@Override

Implements jdk.dynalink.linker.LinkerServices.getGuardedInvocation.

Doc from jdk.dynalink.linker.LinkerServices.getGuardedInvocation.

Creates a guarded invocation delegating back to the DynamicLinker that exposes this linker services object. The dynamic linker will then itself delegate the linking to all of its managed GuardingDynamicLinkers including potentially this one if no linker responds earlier, so beware of infinite recursion. You'll typically craft the link request so that it will be different than the one you are currently trying to link.

Annotations

@Override

Exceptions

Exception:

in case the top-level linker throws an exception

Implements jdk.dynalink.linker.LinkerServices.getTypeConverter.

Doc from jdk.dynalink.linker.LinkerServices.getTypeConverter.

Given a source and target type, returns a method handle that converts between them. Never returns null; in worst case it will return an identity conversion (that might fail for some values at runtime). You rarely need to use this method directly and should mostly rely on asType(MethodHandle, MethodType) instead. This method is needed when you need to reuse existing type conversion machinery outside the context of processing a link request.

Annotations

@Override

Implements jdk.dynalink.linker.LinkerServices.getWithLookup.

Doc from jdk.dynalink.linker.LinkerServices.getWithLookup.

Executes an operation within the context of a particular MethodHandles.Lookup lookup object. Normally, methods on LinkerServices are invoked as part of the linking mechanism in which case Dynalink internally maintains a per-thread current lookup (the one belonging to the descriptor of the call site being linked). This lookup can be retrieved by any GuardingTypeConverterFactory involved in linking if it needs to generate lookup-sensitive converters. However, linker services' methods can be invoked outside the linking process too when implementing invocation-time dispatch schemes, invoking conversions at runtime, etc. If it becomes necessary to use any type converter in this situation, and it needs a lookup, it will normally only get MethodHandles#publicLookup() as the thread is not engaged in a linking operation. If there is a way to meaningfully associate the operation to the context of some caller class, consider performing it within an invocation of this method and passing a full-strength lookup for that class, as it will associate that lookup with the current thread for the duration of the operation.

Annotations

@Override