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

[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

Parâmetros

Retornos

identificador de método que incorpora a lógica de filtragem de subsequência de argumento especificada

Atributos

RegisterAttribute

Comentários

Adapta um identificador de método de destino pré-processando uma sub-sequência de seus argumentos com um filtro (outro identificador de método). Os argumentos pré-processados são substituídos pelo resultado (se houver) da função de filtro. Em seguida, o destino é chamado na lista de argumentos modificados (geralmente abreviados).

Se o filtro retornar um valor, o destino deverá aceitar esse valor como seu argumento em posição pos, precedido e/ou seguido por quaisquer argumentos não passados para o filtro. Se o filtro retornar nulo, o destino deverá aceitar todos os argumentos não passados para o filtro. Nenhum argumento é reordenado e um resultado retornado do filtro substitui (em ordem) toda a subsequência de argumentos passados originalmente para o adaptador.

Os tipos de argumento (se houver) do filtro substituem zero ou um tipo de argumento do destino, em posição pos, no identificador de método adaptado resultante. O tipo de retorno do filtro (se houver) deve ser idêntico ao tipo de argumento do destino em posição pose esse argumento de destino é fornecido pelo valor retornado do filtro.

Em todos os casos, pos deve ser maior ou igual a zero e pos também deve ser menor ou igual à aridade do destino.

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

Aqui está o pseudocódigo para o adaptador resultante: <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>

Um adaptador collectArguments(mh, 0, coll) de coleção é equivalente a um que primeiro "dobra" os argumentos afetados e, em seguida, os descarta, em etapas separadas da seguinte maneira: <blockquote>

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

</blockquote> Se o identificador do método de destino não consumir argumentos além do resultado (se houver) do filtro coll, será collectArguments(mh, 0, coll) equivalente a filterReturnValue(coll, mh). Se o identificador coll do método de filtro consumir um argumento e produzir um resultado não nulo, será collectArguments(mh, N, coll) equivalente a filterArguments(mh, N, coll). Outras equivalências são possíveis, mas exigiriam permutação de argumento.

Documentação Java para java.lang.invoke.MethodHandles.collectArguments(java.lang.invoke.MethodHandle, int, java.lang.invoke.MethodHandle).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.