MethodHandles.CollectArguments(MethodHandle, Int32, MethodHandle) Metodo

Definizione

Spazio dei nomi:

Java.Lang.Invoke

Assembly:

Mono.Android.dll

Adatta un handle di metodo di destinazione pre-elaborazione di una sottoselaborazione dei relativi argomenti con un filtro (un altro handle di metodo).

[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

Parametri

target

MethodHandle

handle del metodo da richiamare dopo aver filtrato la sottosequenza degli argomenti

pos

Int32

posizione del primo argomento dell'adattatore da passare al filtro e/o all'argomento di destinazione che riceve il risultato del filtro

filter

MethodHandle

handle del metodo da chiamare sulla sottosequenza degli argomenti

Valori restituiti

MethodHandle

handle del metodo che incorpora la logica di filtro della sottosequenza dell'argomento specificata

Attributi

RegisterAttribute

Commenti

Adatta un handle di metodo di destinazione pre-elaborazione di una sottoselaborazione dei relativi argomenti con un filtro (un altro handle di metodo). Gli argomenti pre-elaborati vengono sostituiti dal risultato (se presente) della funzione di filtro. La destinazione viene quindi chiamata nell'elenco di argomenti modificato (in genere abbreviato).

Se il filtro restituisce un valore, la destinazione deve accettare tale valore come argomento nella posizione pos, preceduto e/o seguito da qualsiasi argomento non passato al filtro. Se il filtro restituisce void, la destinazione deve accettare tutti gli argomenti non passati al filtro. Nessun argomento viene riordinato e un risultato restituito dal filtro sostituisce (in ordine) l'intera sottosequenza di argomenti originariamente passati all'adapter.

I tipi di argomento (se presenti) del filtro sostituiscono zero o uno dei tipi di argomento della destinazione, in corrispondenza della posizione pos, nell'handle del metodo adattato risultante. Il tipo restituito del filtro (se presente) deve essere identico al tipo di argomento della destinazione nella posizione pose tale argomento di destinazione viene fornito dal valore restituito del filtro.

In tutti i casi, pos deve essere maggiore o uguale a zero e pos deve anche essere minore o uguale all'arità della destinazione.

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

Ecco lo pseudocodice per l'adattatore risultante: <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 adattatore di collectArguments(mh, 0, coll) raccolta equivale a uno che prima "riduce" gli argomenti interessati e quindi li elimina, in passaggi separati come segue: <blockquote>

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

</blockquote> Se l'handle del metodo di destinazione non utilizza argomenti oltre al risultato (se presente) del filtro coll, collectArguments(mh, 0, coll) è equivalente a filterReturnValue(coll, mh). Se l'handle coll del metodo di filtro utilizza un argomento e produce un risultato non void, collectArguments(mh, N, coll) equivale a filterArguments(mh, N, coll). Altre equivalenze sono possibili, ma richiedono la permutazione dell'argomento.

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

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.