jdk.internal.dynalink.linker.MethodTypeConversionStrategy Java Examples

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
 * @param autoConversionStrategy conversion strategy for automatic type conversions. After
 * {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
 * conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. Can be null, in which case no
 * custom strategy is employed.
 */
public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
        final MethodTypeConversionStrategy autoConversionStrategy) {
    final List<GuardingTypeConverterFactory> l = new LinkedList<>();
    final List<ConversionComparator> c = new LinkedList<>();
    for(final GuardingTypeConverterFactory factory: factories) {
        l.add(factory);
        if(factory instanceof ConversionComparator) {
            c.add((ConversionComparator)factory);
        }
    }
    this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
    this.comparators = c.toArray(new ConversionComparator[c.size()]);
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}
 

/**
 * Sets an object representing the conversion strategy for automatic type conversions. After
 * {@link TypeConverterFactory#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has
 * applied all custom conversions to a method handle, it still needs to effect
 * {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
 * can usually be automatically applied as per
 * {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
 * However, sometimes language runtimes will want to customize even those conversions for their own call
 * sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
 * ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
 * automatic conversion strategy, that can deal with null values. Note that when the strategy's
 * {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
 * is invoked, the custom language conversions will already have been applied to the method handle, so by
 * design the difference between the handle's current method type and the desired final type will always
 * only be ones that can be subjected to method invocation conversions. The strategy also doesn't need to
 * invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
 * @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
 * created by this factory.
 */
public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
    this.autoConversionStrategy = autoConversionStrategy;
}