MethodHandles.FoldArguments Méthode
Définition
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.
Surcharges
| FoldArguments(MethodHandle, Int32, MethodHandle) |
Adapte un handle de méthode cible en prétraiter certains de ses arguments, en commençant à une position donnée, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’origine d’arguments juste avant les arguments pliés. |
| FoldArguments(MethodHandle, MethodHandle) |
Adapte un handle de méthode cible en prétraitant certains de ses arguments, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’arguments d’origine. |
FoldArguments(MethodHandle, Int32, MethodHandle)
Adapte un handle de méthode cible en prétraiter certains de ses arguments, en commençant à une position donnée, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’origine d’arguments juste avant les arguments pliés.
[Android.Runtime.Register("foldArguments", "(Ljava/lang/invoke/MethodHandle;ILjava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)]
public static Java.Lang.Invoke.MethodHandle? FoldArguments (Java.Lang.Invoke.MethodHandle? target, int pos, Java.Lang.Invoke.MethodHandle? combiner);[<Android.Runtime.Register("foldArguments", "(Ljava/lang/invoke/MethodHandle;ILjava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=33)>]
static member FoldArguments : Java.Lang.Invoke.MethodHandle * int * Java.Lang.Invoke.MethodHandle -> Java.Lang.Invoke.MethodHandleParamètres
- target
- MethodHandle
handle de méthode à appeler une fois les arguments combinés
- pos
- Int32
position à laquelle commencer le pliage et à laquelle insérer le résultat de pliage ; si c’est 0le cas, l’effet est le même que pour #foldArguments(MethodHandle, MethodHandle).
- combiner
- MethodHandle
handle de méthode pour appeler initialement sur les arguments entrants
Retours
handle de méthode qui incorpore la logique de pliage d’arguments spécifié
- Attributs
Remarques
Adapte un handle de méthode cible en prétraiter certains de ses arguments, en commençant à une position donnée, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’origine d’arguments juste avant les arguments pliés.
Cette méthode est étroitement liée à #foldArguments(MethodHandle, MethodHandle), mais permet de contrôler la position dans la liste de paramètres à laquelle le pliage a lieu. L’argument qui contrôle cela, posest un index de base zéro. La méthode #foldArguments(MethodHandle, MethodHandle) mentionnée ci-dessus suppose la position 0.
Ajouté dans 9.
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 à
FoldArguments(MethodHandle, MethodHandle)
Adapte un handle de méthode cible en prétraitant certains de ses arguments, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’arguments d’origine.
[Android.Runtime.Register("foldArguments", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=26)]
public static Java.Lang.Invoke.MethodHandle? FoldArguments (Java.Lang.Invoke.MethodHandle? target, Java.Lang.Invoke.MethodHandle? combiner);[<Android.Runtime.Register("foldArguments", "(Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=26)>]
static member FoldArguments : Java.Lang.Invoke.MethodHandle * Java.Lang.Invoke.MethodHandle -> Java.Lang.Invoke.MethodHandleParamètres
- target
- MethodHandle
handle de méthode à appeler une fois les arguments combinés
- combiner
- MethodHandle
handle de méthode pour appeler initialement sur les arguments entrants
Retours
handle de méthode qui incorpore la logique de pliage d’arguments spécifié
- Attributs
Remarques
Adapte un handle de méthode cible en prétraitant certains de ses arguments, puis en appelant la cible avec le résultat du prétraitement, inséré dans la séquence d’arguments d’origine.
Le prétraitement est effectué par combiner, un deuxième handle de méthode. Parmi les arguments passés à l’adaptateur, les premiers N arguments sont copiés dans le combineur, qui est ensuite appelé. (Ici, N est défini comme le nombre de paramètres du combineur.) Après cela, le contrôle passe à la cible, avec tout résultat du combineur inséré avant les arguments entrants d’origine N .
Si le combineur retourne une valeur, le premier type de paramètre de la cible doit être identique au type de retour du combineur, et les types de paramètres suivants N de la cible doivent correspondre exactement aux paramètres du combineur.
Si le combineur a un retour void, aucun résultat n’est inséré, et les premiers N types de paramètres de la cible doivent correspondre exactement aux paramètres du combineur.
L’adaptateur résultant est le même type que la cible, sauf que le premier type de paramètre est supprimé, s’il correspond au résultat du combineur.
(Notez que #dropArguments(MethodHandle,int,List) dropArguments vous pouvez utiliser pour supprimer tous les arguments que le combineur ou la cible ne souhaite pas recevoir. Si certains arguments entrants ne sont destinés qu’au combineur, envisagez d’utiliser MethodHandle#asCollector asCollector à la place, car ces arguments n’auront pas besoin d’être en direct sur la pile lors de l’entrée à la cible.)
<b>Example :</b><blockquote>
{@code
import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class,
"println", methodType(void.class, String.class))
.bindTo(System.out);
MethodHandle cat = lookup().findVirtual(String.class,
"concat", methodType(String.class, String.class));
assertEquals("boojum", (String) cat.invokeExact("boo", "jum"));
MethodHandle catTrace = foldArguments(cat, trace);
// also prints "boo":
assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
}
</blockquote>
Voici un pseudocode pour l’adaptateur résultant. Dans le code, T représente le type de résultat de l’adaptateur et de l’adaptateur target résultant. V/v représente le type et la valeur du paramètre et de l’argument qui target précèdent la position de pliage ; V il s’agit également du type de résultat du combiner. A/a indique les types et valeurs des N paramètres et des arguments à la position de pliage. B/b représentent les types et valeurs des target paramètres et arguments qui suivent les paramètres et arguments pliés. <blockquote>
{@code
// there are N arguments in A...
T target(V, A[N]..., B...);
V combiner(A...);
T adapter(A... a, B... b) {
V v = combiner(a...);
return target(v, a..., b...);
}
// and if the combiner has a void return:
T target2(A[N]..., B...);
void combiner2(A...);
T adapter2(A... a, B... b) {
combiner2(a...);
return target2(a..., b...);
}
}
</blockquote>
<em>Remarque :</em> L’adaptateur résultant n’est jamais un handle de méthode MethodHandle#asVarargsCollector variable-arity, même si le handle de méthode cible d’origine était.
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.