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

Riferimento

Definizione

Spazio dei nomi:: Java.Lang.Invoke

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Produce un handle di metodo che adatta la sequenza chiamante dell'handle di metodo specificato a un nuovo tipo, riordinando gli argomenti.

[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

Parametri

target: MethodHandle

handle del metodo da richiamare dopo che gli argomenti vengono riordinati

newType: MethodType

tipo previsto del nuovo handle di metodo

reorder: Int32[]

matrice di indici che controlla il riordinamento

Restituisce

MethodHandle

handle di metodo che delega alla destinazione dopo che elimina gli argomenti inutilizzati e sposta e/o duplica gli altri argomenti

Attributi: RegisterAttribute

Commenti

Produce un handle di metodo che adatta la sequenza chiamante dell'handle di metodo specificato a un nuovo tipo, riordinando gli argomenti. L'handle del metodo risultante è garantito per segnalare un tipo uguale al nuovo tipo desiderato.

La matrice specificata controlla il riordino. Chiamare #I il numero di parametri in ingresso (il valore newType.parameterCount()e chiamare #O il numero di parametri in uscita (il valore target.type().parameterCount()). La lunghezza della matrice di riordinamento deve quindi essere #Oe ogni elemento deve essere un numero non negativo minore di #I. Per ogni N valore minore di #O, l'argomento N-th in uscita verrà ricavato dall'argomento I-th in ingresso, dove I è reorder[N].

Non vengono applicate conversioni di argomenti o valori restituiti. Il tipo di ogni argomento in ingresso, come determinato da newType, deve essere identico al tipo del parametro o dei parametri in uscita corrispondenti nell'handle del metodo di destinazione. Il tipo restituito di newType deve essere identico al tipo restituito della destinazione originale.

La matrice di riordinamento non deve specificare una permutazione effettiva. Un argomento in ingresso verrà duplicato se il relativo indice viene visualizzato più volte nella matrice e un argomento in ingresso verrà eliminato se il relativo indice non viene visualizzato nella matrice. Come nel caso di #dropArguments(MethodHandle,int,List) dropArguments, gli argomenti in ingresso che non sono menzionati nella matrice di riordinamento possono essere di qualsiasi tipo, come determinato solo da 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>

Documentazione java per java.lang.invoke.MethodHandles.permuteArguments(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType, int...).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Si applica a

Condividi tramite