MethodHandles.PermuteArguments(MethodHandle, MethodType, Int32[]) Methode

Referenz

Definition

Namespace:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Erzeugt ein Methodenhandle, das die aufrufende Sequenz des angegebenen Methodenhandles an einen neuen Typ anpasst, indem die Argumente neu angeordnet werden.

[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

Parameter

target: MethodHandle

das Methodenhandle, das aufgerufen werden soll, nachdem Argumente neu angeordnet wurden

newType: MethodType

der erwartete Typ des neuen Methodenhandles

reorder: Int32[]

ein Indexarray, das die Neuanordnung steuert

Gibt zurück

MethodHandle

eine Methode, die Stellvertretungen an das Ziel abgibt, nachdem sie nicht verwendete Argumente abgelegt und/oder die anderen Argumente dupliziert

Attribute: RegisterAttribute

Hinweise

Erzeugt ein Methodenhandle, das die aufrufende Sequenz des angegebenen Methodenhandles an einen neuen Typ anpasst, indem die Argumente neu angeordnet werden. Der resultierende Methodenhandle wird garantiert einen Typ melden, der dem gewünschten neuen Typ entspricht.

Das angegebene Array steuert die Neuanordnung. Rufen Sie #I die Anzahl der eingehenden Parameter (den WertnewType.parameterCount()) auf, und rufen Sie die Anzahl der ausgehenden Parameter (den Werttarget.type().parameterCount()) auf#O. Dann muss die Länge des Neuanordnungsarrays sein #O, und jedes Element muss eine nicht negative Zahl kleiner sein als #I. Für jeden N kleiner als #Owird das Nausgehende Argument -th aus dem Ieingehenden Argument -n entnommen, wobei I das Argument "-n" lautet reorder[N].

Es werden keine Argument- oder Rückgabewertkonvertierungen angewendet. Der Typ der einzelnen eingehenden Argumente, wie es newTypebestimmt wird, muss mit dem Typ des entsprechenden ausgehenden Parameters oder parameters im Zielmethodenhandle identisch sein. Der Rückgabetyp muss newType mit dem Rückgabetyp des ursprünglichen Ziels identisch sein.

Das Neuanordnungsarray muss keine tatsächliche Permutation angeben. Ein eingehendes Argument wird dupliziert, wenn sein Index mehr als einmal im Array angezeigt wird, und ein eingehendes Argument wird gelöscht, wenn sein Index nicht im Array angezeigt wird. Wie bei #dropArguments(MethodHandle,int,List) dropArgumentseingehenden Argumenten, die im Neuanordnungsarray nicht erwähnt werden, kann es sich um einen beliebigen Typ handeln, der nur von 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>

Java-Dokumentation für java.lang.invoke.MethodHandles.permuteArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, int...).

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.

Gilt für:

Freigeben über