MethodHandles.CollectArguments(MethodHandle, Int32, MethodHandle) Methode

Definition

Namespace:

Java.Lang.Invoke

Assembly:

Mono.Android.dll

Passt ein Zielmethodenhandle an, indem eine Untersequenz seiner Argumente mit einem Filter (einem anderen Methodenhandle) vorverarbeitet wird.

[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

Parameter

target

MethodHandle

das Methodenhandle, das nach dem Filtern der Unterquence von Argumenten aufgerufen werden soll

pos

Int32

die Position des ersten Adapterarguments, das an den Filter übergeben werden soll, und/oder das Zielargument, das das Ergebnis des Filters erhält

filter

MethodHandle

Methodenhandle zum Aufrufen der Untermenge von Argumenten

Gibt zurück

MethodHandle

Methodenhandle, das die angegebene Subsequence-Filterlogik enthält

Attribute

RegisterAttribute

Hinweise

Passt ein Zielmethodenhandle an, indem eine Untersequenz seiner Argumente mit einem Filter (einem anderen Methodenhandle) vorverarbeitet wird. Die vorverarbeiteten Argumente werden durch das Ergebnis (falls vorhanden) der Filterfunktion ersetzt. Das Ziel wird dann für die geänderte (in der Regel gekürzte) Argumentliste aufgerufen.

Wenn der Filter einen Wert zurückgibt, muss das Ziel diesen Wert als argumentieren pos, vorangestellt und/oder gefolgt von Argumenten akzeptieren, die nicht an den Filter übergeben werden. Wenn der Filter "void" zurückgibt, muss das Ziel alle Argumente akzeptieren, die nicht an den Filter übergeben werden. Es werden keine Argumente neu angeordnet, und ein Ergebnis, das vom Filter zurückgegeben wird, ersetzt (in der Reihenfolge) die gesamte Untermenge der Argumente, die ursprünglich an den Adapter übergeben wurden.

Die Argumenttypen (falls vorhanden) des Filters ersetzen null oder ein Argumenttyp des Ziels an position posim resultierenden angepassten Methodenhandle. Der Rückgabetyp des Filters (falls vorhanden) muss mit dem Argumenttyp des Ziels an der Position posidentisch sein, und dieses Zielargument wird vom Rückgabewert des Filters bereitgestellt.

In allen Fällen pos muss größer oder gleich Null sein und pos auch kleiner oder gleich der Arität des Ziels sein.

<b>Beispiel:</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>

Hier ist pseudocode für den resultierenden Adapter: <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>

Ein Sammlungsadapter collectArguments(mh, 0, coll) entspricht einem, der zuerst die betroffenen Argumente "gefaltet" und dann in separaten Schritten wie folgt abbricht: <Blockquote>

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

</blockquote> If the target method handle consumes no arguments than the result (if any) of the filter coll, then collectArguments(mh, 0, coll) is equivalent to filterReturnValue(coll, mh). Wenn der Filtermethodenhandle coll ein Argument verwendet und ein nicht leeres Ergebnis erzeugt, entspricht filterArguments(mh, N, coll)es collectArguments(mh, N, coll) . Andere Äquivalenzen sind möglich, würden aber eine Argument-Permutation erfordern.

Java Dokumentation für java.lang.invoke.MethodHandles.collectArguments(java.lang.invoke.MethodHandle, int, java.lang.invoke.MethodHandle).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.