MethodHandles.CollectArguments(MethodHandle, Int32, MethodHandle) Méthode

[Android.Runtime.Register("collectArguments", "(Ljava/lang/invoke/MethodHandle;ILjava/lang/invoke/MethodHandle;)Ljava/lang/invoke/MethodHandle;", "", ApiSince=26)]
public static Java.Lang.Invoke.MethodHandle? CollectArguments(Java.Lang.Invoke.MethodHandle? target, int pos, Java.Lang.Invoke.MethodHandle? filter);

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

Paramètres

Retours

handle de méthode qui incorpore la logique de filtrage de sous-séquence d’arguments spécifié

Attributs

RegisterAttribute

Remarques

Adapte un handle de méthode cible en prétraitant une sous-séquence de ses arguments avec un filtre (un autre handle de méthode). Les arguments prétraités sont remplacés par le résultat (le cas échéant) de la fonction de filtre. La cible est ensuite appelée sur la liste d’arguments modifiée (généralement raccourcie).

Si le filtre retourne une valeur, la cible doit accepter cette valeur en tant qu’argument en position pos, précédée et/ou suivie d’arguments non passés au filtre. Si le filtre retourne void, la cible doit accepter tous les arguments non passés au filtre. Aucun argument n’est réorganisé et un résultat retourné par le filtre remplace (dans l’ordre) la sous-séquence entière des arguments transmis à l’origine à l’adaptateur.

Les types d’arguments (le cas échéant) du filtre remplacent zéro ou un type d’argument de la cible, à la position pos, dans le handle de méthode adapté résultant. Le type de retour du filtre (le cas échéant) doit être identique au type d’argument de la cible à la position pos, et cet argument cible est fourni par la valeur de retour du filtre.

Dans tous les cas, pos doit être supérieur ou égal à zéro, et pos doit également être inférieur ou égal à l’arité de la cible.

<b>Example :</b><blockquote>

{@code
            import static java.lang.invoke.MethodHandles.*;
            import static java.lang.invoke.MethodType.*;
            ...
            MethodHandle deepToString = publicLookup()
              .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));

            MethodHandle ts1 = deepToString.asCollector(String[].class, 1);
            assertEquals("[strange]", (String) ts1.invokeExact("strange"));

            MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
            assertEquals("[up, down]", (String) ts2.invokeExact("up", "down"));

            MethodHandle ts3 = deepToString.asCollector(String[].class, 3);
            MethodHandle ts3_ts2 = collectArguments(ts3, 1, ts2);
            assertEquals("[top, [up, down], strange]",
                         (String) ts3_ts2.invokeExact("top", "up", "down", "strange"));

            MethodHandle ts3_ts2_ts1 = collectArguments(ts3_ts2, 3, ts1);
            assertEquals("[top, [up, down], [strange]]",
                         (String) ts3_ts2_ts1.invokeExact("top", "up", "down", "strange"));

            MethodHandle ts3_ts2_ts3 = collectArguments(ts3_ts2, 1, ts3);
            assertEquals("[top, [[up, down, strange], charm], bottom]",
                         (String) ts3_ts2_ts3.invokeExact("top", "up", "down", "strange", "charm", "bottom"));
            }

</blockquote>

Voici un pseudocode pour l’adaptateur résultant : <blockquote>

{@code
            T target(A...,V,C...);
            V filter(B...);
            T adapter(A... a,B... b,C... c) {
              V v = filter(b...);
              return target(a...,v,c...);
            }
            // and if the filter has no arguments:
            T target2(A...,V,C...);
            V filter2();
            T adapter2(A... a,C... c) {
              V v = filter2();
              return target2(a...,v,c...);
            }
            // and if the filter has a void return:
            T target3(A...,C...);
            void filter3(B...);
            void adapter3(A... a,B... b,C... c) {
              filter3(b...);
              return target3(a...,c...);
            }
            }

</blockquote>

Un adaptateur collectArguments(mh, 0, coll) de collection équivaut à celui qui « plie » d’abord les arguments affectés, puis les supprime, en étapes distinctes comme suit : <blockquote>

{@code
            mh = MethodHandles.dropArguments(mh, 1, coll.type().parameterList()); //step 2
            mh = MethodHandles.foldArguments(mh, coll); //step 1
            }

</blockquote> Si le handle de méthode cible ne consomme aucun argument en plus du résultat (le cas échéant) du filtre coll, équivaut collectArguments(mh, 0, coll) à filterReturnValue(coll, mh). Si le handle coll de méthode de filtre consomme un argument et produit un résultat non vide, il collectArguments(mh, N, coll) équivaut à filterArguments(mh, N, coll). D’autres équivalences sont possibles, mais nécessitent une permutation d’argument.

Java documentation pour java.lang.invoke.MethodHandles.collectArguments(java.lang.invoke.MethodHandle, int, java.lang.invoke.MethodHandle).

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