MethodHandle.AsVarargsCollector(Class) Metodo

[Android.Runtime.Register("asVarargsCollector", "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandle;", "GetAsVarargsCollector_Ljava_lang_Class_Handler", ApiSince=26)]
public virtual Java.Lang.Invoke.MethodHandle? AsVarargsCollector(Java.Lang.Class? arrayType);

[<Android.Runtime.Register("asVarargsCollector", "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandle;", "GetAsVarargsCollector_Ljava_lang_Class_Handler", ApiSince=26)>]
abstract member AsVarargsCollector : Java.Lang.Class -> Java.Lang.Invoke.MethodHandle
override this.AsVarargsCollector : Java.Lang.Class -> Java.Lang.Invoke.MethodHandle

Parametri

Valori restituiti

un nuovo handle di metodo che può raccogliere un numero qualsiasi di argomenti finali in una matrice, prima di chiamare l'handle del metodo originale

Attributi

RegisterAttribute

Commenti

Crea un <adattatore em>variable arity</em> in grado di accettare un numero qualsiasi di argomenti posizionali finali e raccoglierli in un argomento di matrice.

Il tipo e il comportamento dell'adattatore saranno uguali al tipo e al comportamento della destinazione, ad eccezione del fatto che determinate invoke richieste e asType possono portare a argomenti posizionali finali raccolti nel parametro finale della destinazione. Inoltre, l'ultimo tipo di parametro MethodType#lastParameterType dell'adattatore sarà arrayType, anche se la destinazione ha un ultimo tipo di parametro diverso.

Questa trasformazione può restituire this se l'handle del metodo è già di tipo variabile e il tipo di parametro finale è identico a arrayType.

Quando viene chiamato con #invokeExact invokeExact, l'adapter richiama la destinazione senza modifiche all'argomento. (<em>Nota:</em> Questo comportamento è diverso da un agente di raccolta #asCollector arity fisso, poiché accetta un'intera matrice di lunghezza indeterminato, anziché un numero fisso di argomenti.

Quando viene chiamato con plain, inexact #invoke invoke, se il tipo di chiamante è uguale all'adattatore, l'adapter richiama la destinazione come con invokeExact. Questo è il comportamento normale per invoke quando i tipi corrispondono.

In caso contrario, se il chiamante e l'adattatore sono uguali e il tipo di parametro finale del chiamante è un tipo riferimento identico o assegnabile al tipo di parametro finale dell'adattatore, gli argomenti e i valori restituiti vengono convertiti in modo pairwise, come se #asType asType in un handle di metodo arity fisso.

In caso contrario, le arities differiscono o il tipo di parametro finale dell'adattatore non è assegnabile dal tipo di chiamante corrispondente. In questo caso, l'adattatore sostituisce tutti gli argomenti finali dalla posizione dell'argomento finale in poi, da una nuova matrice di tipo arrayType, i cui elementi comprendono (in ordine) gli argomenti sostituiti.

Il tipo di chiamante deve fornire gli argomenti meno sufficienti e del tipo corretto per soddisfare il requisito della destinazione per gli argomenti posizionali prima dell'argomento matrice finale. Pertanto, il chiamante deve fornire, almeno, N-1 argomenti, dove N è l'arità della destinazione. Inoltre, devono esistere conversioni dagli argomenti in ingresso agli argomenti della destinazione. Come per altri usi di normale invoke, se questi requisiti di base non sono soddisfatti, può essere generata un'eccezione WrongMethodTypeException .

In tutti i casi, il risultato restituito alla fine dalla destinazione viene restituito invariato dall'adattatore.

Nel caso finale, è esattamente come se l'handle del metodo di destinazione fosse temporaneamente adattato con un agente di raccolta #asCollector arity fisso per l'arità richiesta dal tipo di chiamante. (Come con asCollector, se la lunghezza della matrice è zero, è possibile usare una costante condivisa anziché una nuova matrice. Se la chiamata implicita a asCollector genera un'eccezione IllegalArgumentException o WrongMethodTypeException, la chiamata all'adattatore di arity variabile deve generare WrongMethodTypeException.

Il comportamento di #asType asType è anche specializzato per gli adattatori di arità variabile, per mantenere l'invariante che normale, inexact invoke è sempre equivalente a una asType chiamata per regolare il tipo di destinazione, seguito da invokeExact. Pertanto, un adattatore di arity variabile risponde a una asType richiesta creando un agente di raccolta arity fisso, se e solo se l'adattatore e il tipo richiesto differiscono in arity o tipo di argomento finale. L'agente di raccolta di arità fissa risultante ha il tipo modificato ulteriormente (se necessario) al tipo richiesto per conversione pairwise, come se da un'altra applicazione di asType.

Quando un handle di metodo viene ottenuto eseguendo un'istruzione ldc di una CONSTANT_MethodHandle costante e il metodo di destinazione viene contrassegnato come metodo di arità variabile (con il bit 0x0080modificatore ), l'handle del metodo accetterà più arità, come se la costante dell'handle del metodo fosse stata creata tramite una chiamata a asVarargsCollector.

Per creare un adattatore di raccolta che raccoglie un numero predeterminato di argomenti e il cui tipo riflette questo numero predeterminato, utilizzare #asCollector asCollector invece .

Le trasformazioni di handle di metodo non producono nuovi handle di metodo con arità variabile, a meno che non siano documentati come in questo modo. Pertanto, oltre asVarargsCollector a e withVarargs, tutti i metodi in MethodHandle e MethodHandles restituiscono un handle di metodo con arità fissa, tranne nei casi in cui vengono specificati per restituire il loro operando originale (ad esempio, asType del proprio tipo di handle del metodo).

La chiamata asVarargsCollector a un handle di metodo che è già di arity variabile produrrà un handle di metodo con lo stesso tipo e comportamento. Può (o non) restituire l'handle del metodo di arity della variabile originale.

Di seguito è riportato un esempio di handle di metodo di arity variabile che crea un elenco: <blockquote>

{@code
            MethodHandle deepToString = publicLookup()
              .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
            MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
            assertEquals("[won]",   (String) ts1.invokeExact(    new Object[]{"won"}));
            assertEquals("[won]",   (String) ts1.invoke(         new Object[]{"won"}));
            assertEquals("[won]",   (String) ts1.invoke(                      "won" ));
            assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
            // findStatic of Arrays.asList(...) produces a variable arity method handle:
            MethodHandle asList = publicLookup()
              .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
            assertEquals(methodType(List.class, Object[].class), asList.type());
            assert(asList.isVarargsCollector());
            assertEquals("[]", asList.invoke().toString());
            assertEquals("[1]", asList.invoke(1).toString());
            assertEquals("[two, too]", asList.invoke("two", "too").toString());
            String[] argv = { "three", "thee", "tee" };
            assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
            assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
            List ls = (List) asList.invoke((Object)argv);
            assertEquals(1, ls.size());
            assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));
            }

</blockquote>

<em>Discussion:</em> Queste regole sono progettate come variante tipizzata dinamicamente delle regole di Java per i metodi di arity delle variabili. In entrambi i casi, i chiamanti a un metodo di arity variabile o un handle di metodo possono passare zero o più argomenti posizionali oppure passare matrici pre-raccolte di qualsiasi lunghezza. Gli utenti devono essere consapevoli del ruolo speciale dell'argomento finale e dell'effetto di una corrispondenza di tipo sull'argomento finale, che determina se un singolo argomento finale viene interpretato come una matrice intera o un singolo elemento di una matrice da raccogliere. Si noti che il tipo dinamico dell'argomento finale non ha alcun effetto su questa decisione, ma solo un confronto tra il descrittore di tipo simbolico del sito di chiamata e il descrittore di tipo dell'handle del metodo.

Documentazione java per java.lang.invoke.MethodHandle.asVarargsCollector(java.lang.Class<?>).

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.