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

Référence

Définition

Espace de noms:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Produit un handle de méthode qui adapte la séquence appelante du handle de méthode donné à un nouveau type, en réorganisant les arguments.

[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

Paramètres

target: MethodHandle

handle de méthode à appeler une fois les arguments réorganisé

newType: MethodType

type attendu du nouveau handle de méthode

reorder: Int32[]

tableau d’index qui contrôle la réorganisation

Retours

MethodHandle

un handle de méthode qui délègue à la cible après avoir abandonné les arguments inutilisés et/ou déplace et/ou dupliquer les autres arguments

Attributs: RegisterAttribute

Remarques

Produit un handle de méthode qui adapte la séquence appelante du handle de méthode donné à un nouveau type, en réorganisant les arguments. Le handle de méthode résultant est garanti pour signaler un type qui est égal au nouveau type souhaité.

Le tableau donné contrôle la réorganisation. Appelez #I le nombre de paramètres entrants (la valeur newType.parameterCount(), puis appelez #O le nombre de paramètres sortants (la valeur target.type().parameterCount()). Ensuite, la longueur du tableau de réorganisation doit être #O, et chaque élément doit être un nombre non négatif inférieur à #I. Pour chaque N argument inférieur #Oà , l’argument N-th sortant est extrait de l’argument I-th entrant, où I est reorder[N].

Aucune conversion de valeur d’argument ou de retour n’est appliquée. Le type de chaque argument entrant, tel que déterminé par newType, doit être identique au type du paramètre ou des paramètres sortants correspondants dans le handle de méthode cible. Le type de retour de newType doit être identique au type de retour de la cible d’origine.

Le tableau de réorganisation n’a pas besoin de spécifier de permutation réelle. Un argument entrant est dupliqué si son index apparaît plusieurs fois dans le tableau et qu’un argument entrant est supprimé si son index n’apparaît pas dans le tableau. Comme dans le cas des #dropArguments(MethodHandle,int,List) dropArgumentsarguments entrants qui ne sont pas mentionnés dans le tableau de réorganisation peuvent être n’importe quel type, comme déterminé uniquement par 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>

Documentation Java pour java.lang.invoke.MethodHandles.permuteArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, int...).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

S’applique à

Partager via