org.dynalang.dynalink.support

Class LinkerServicesImpl

java.lang.Object

org.dynalang.dynalink.support.LinkerServicesImpl

All Implemented Interfaces:

LinkerServices

public class LinkerServicesImpl
extends Object
implements LinkerServices

Default implementation of the LinkerServices interface.

Author:

Attila Szegedi

Constructor Summary

Constructors

Constructor and Description
LinkerServicesImpl(TypeConverterFactory typeConverterFactory, GuardingDynamicLinker topLevelLinker) Creates a new linker services object.

Method Summary

Modifier and Type	Method and Description
java.lang.invoke.MethodHandle	asType(java.lang.invoke.MethodHandle handle, java.lang.invoke.MethodType fromType) Similar to MethodHandle.asType(MethodType) except it also hooks in method handles produced by GuardingTypeConverterFactory implementations, providing for language-specific type coercing of parameters.
boolean	canConvert(Class<?> from, Class<?> to) 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.
ConversionComparator.Comparison	compareConversion(Class<?> sourceType, Class<?> targetType1, Class<?> targetType2) Determines which of the two type conversions from a source type to the two target types is preferred.
GuardedInvocation	getGuardedInvocation(LinkRequest linkRequest) Creates a guarded invocation using the DynamicLinker that exposes this linker services interface.
java.lang.invoke.MethodHandle	getTypeConverter(Class<?> sourceType, Class<?> targetType) Given a source and target type, returns a method handle that converts between them.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LinkerServicesImpl

public LinkerServicesImpl(TypeConverterFactory typeConverterFactory,
                  GuardingDynamicLinker topLevelLinker)

Creates a new linker services object.

Parameters:

typeConverterFactory - the type converter factory exposed by the services.

topLevelLinker - the top level linker used by the services.

Method Detail

canConvert

public boolean canConvert(Class<?> from,
                 Class<?> to)

Description copied from interface: LinkerServices

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 (notably, if the "from" or "to" types are sufficiently generic), but returning false guarantees that it would fail.

Specified by:

canConvert in interface LinkerServices

Parameters:

from - the source type for the conversion

to - the target type for the conversion

Returns:

true if there can be a conversion, false if there can not.

asType

public java.lang.invoke.MethodHandle asType(java.lang.invoke.MethodHandle handle,
                                   java.lang.invoke.MethodType fromType)

Description copied from interface: LinkerServices

Similar to MethodHandle.asType(MethodType) except it also hooks in method handles produced by 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. It doesn't use language-specific conversions on the return type.

Specified by:

asType in interface LinkerServices

Parameters:

handle - target method handle

fromType - the types of source arguments

Returns:

a method handle that is a suitable combination of MethodHandle.asType(MethodType) and MethodHandles.filterArguments(MethodHandle, int, MethodHandle...) with GuardingTypeConverterFactory produced type converters as filters.

getTypeConverter

public java.lang.invoke.MethodHandle getTypeConverter(Class<?> sourceType,
                                             Class<?> targetType)

Description copied from interface: LinkerServices

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; you should mostly rely on LinkerServices.asType(MethodHandle, MethodType) instead. You really only need this method if you have a piece of your program that is written in Java, and you need to reuse existing type conversion machinery in a non-invokedynamic context.

Specified by:

getTypeConverter in interface LinkerServices

Parameters:

sourceType - the type to convert from

targetType - the type to convert to

Returns:

a method handle performing the conversion.

compareConversion

public ConversionComparator.Comparison compareConversion(Class<?> sourceType,
                                                Class<?> targetType1,
                                                Class<?> targetType2)

Description copied from interface: LinkerServices

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.

Specified by:

compareConversion in interface LinkerServices

Parameters:

sourceType - the source type.

targetType1 - one potential target type

targetType2 - another potential target type.

Returns:

one of Comparison constants that establish which - if any - of the target types is preferable for the conversion.

getGuardedInvocation

public GuardedInvocation getGuardedInvocation(LinkRequest linkRequest)
                                       throws Exception

Description copied from interface: LinkerServices

Creates a guarded invocation using the DynamicLinker that exposes this linker services interface. Linkers can typically use them to delegate linking of wrapped objects.

Specified by:

getGuardedInvocation in interface LinkerServices

Parameters:

linkRequest - a request for linking the invocation

Returns:

a guarded invocation linked by the top-level linker (or any of its delegates). Can be null if no available linker is able to link the invocation.

Throws:

Exception - in case the top-level linker throws an exception