MethodHandles.PermuteArguments(MethodHandle, MethodType, Int32[]) Método

Definição

Namespace:

Java.Lang.Invoke

Assembly:

Mono.Android.dll

Produz um identificador de método que adapta a sequência de chamadas do identificador de método fornecido a um novo tipo, reordenando os argumentos.

[Android.Runtime.Register("permuteArguments", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;[I)Ljava/lang/invoke/MethodHandle;", "", ApiSince=26)]
public static Java.Lang.Invoke.MethodHandle? PermuteArguments(Java.Lang.Invoke.MethodHandle? target, Java.Lang.Invoke.MethodType? newType, params int[]? reorder);

[<Android.Runtime.Register("permuteArguments", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;[I)Ljava/lang/invoke/MethodHandle;", "", ApiSince=26)>]
static member PermuteArguments : Java.Lang.Invoke.MethodHandle * Java.Lang.Invoke.MethodType * int[] -> Java.Lang.Invoke.MethodHandle

Parâmetros

target

MethodHandle

o identificador do método a ser invocado depois que os argumentos são reordenados

newType

MethodType

o tipo esperado do novo identificador de método

reorder

Int32[]

uma matriz de índice que controla a reordenação

Retornos

MethodHandle

um identificador de método que delega ao destino depois que ele descarta argumentos não utilizados e move e/ou duplica os outros argumentos

Atributos

RegisterAttribute

Comentários

Produz um identificador de método que adapta a sequência de chamadas do identificador de método fornecido a um novo tipo, reordenando os argumentos. O identificador de método resultante é garantido para relatar um tipo igual ao novo tipo desejado.

A matriz fornecida controla a reordenação. Chame #I o número de parâmetros de entrada (o valor newType.parameterCount()e chame #O o número de parâmetros de saída (o valor target.type().parameterCount()). Em seguida, o comprimento da matriz de reordenação deve ser #O, e cada elemento deve ser um número não negativo menor que #I. Para cada N menor que #O, o Nargumento -th de saída será retirado do Iargumento de entrada -th, onde I está reorder[N].

Nenhuma conversão de valor de retorno ou argumento é aplicada. O tipo de cada argumento de entrada, conforme determinado por newType, deve ser idêntico ao tipo do parâmetro de saída correspondente ou parâmetros no identificador do método de destino. O tipo de newType retorno deve ser idêntico ao tipo de retorno do destino original.

A matriz de reordenação não precisa especificar uma permutação real. Um argumento de entrada será duplicado se seu índice aparecer mais de uma vez na matriz e um argumento de entrada será descartado se o índice não aparecer na matriz. Como no caso de argumentos de #dropArguments(MethodHandle,int,List) dropArgumentsentrada que não são mencionados na matriz de reordenação podem ser qualquer tipo, conforme determinado apenas por newType. <blockquote>

{@code
            import static java.lang.invoke.MethodHandles.*;
            import static java.lang.invoke.MethodType.*;
            ...
            MethodType intfn1 = methodType(int.class, int.class);
            MethodType intfn2 = methodType(int.class, int.class, int.class);
            MethodHandle sub = ... (int x, int y) -> (x-y) ...;
            assert(sub.type().equals(intfn2));
            MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1);
            MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0);
            assert((int)rsub.invokeExact(1, 100) == 99);
            MethodHandle add = ... (int x, int y) -> (x+y) ...;
            assert(add.type().equals(intfn2));
            MethodHandle twice = permuteArguments(add, intfn1, 0, 0);
            assert(twice.type().equals(intfn1));
            assert((int)twice.invokeExact(21) == 42);
            }

</blockquote>

Documentação Java para java.lang.invoke.MethodHandles.permuteArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, int...).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.