MethodHandle.AsVarargsCollector(Class) Méthode

[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

Paramètres

Retours

un nouveau handle de méthode qui peut collecter n’importe quel nombre d’arguments de fin dans un tableau, avant d’appeler le handle de méthode d’origine

Attributs

RegisterAttribute

Remarques

Rend une <variable em>arity</em> adapter qui est en mesure d’accepter un nombre quelconque d’arguments positionnels de fin et de les collecter dans un argument de tableau.

Le type et le comportement de l’adaptateur sont identiques au type et au comportement de la cible, sauf que certaines invoke et asType demandes peuvent entraîner la collecte d’arguments positionnels de fin dans le paramètre de fin de la cible. En outre, le type de paramètre MethodType#lastParameterType de l’adaptateur sera arrayType, même si la cible a un autre type de paramètre.

Cette transformation peut retourner this si le handle de méthode est déjà d’arité variable et que son type de paramètre de fin est identique à arrayType.

Lorsqu’elle est appelée avec #invokeExact invokeExact, l’adaptateur appelle la cible sans modification d’argument. (<em>Remarque :</em> Ce comportement est différent d’un collecteur d’arité fixes #asCollector, car il accepte un tableau entier de longueur indéterminée, plutôt qu’un nombre fixe d’arguments.)

Lorsqu’elle est appelée avec un type brut, incorrect #invoke invoke, si le type d’appelant est le même que l’adaptateur, l’adaptateur appelle la cible comme avec invokeExact. (Il s’agit du comportement normal pour le moment où invoke les types correspondent.)

Sinon, si l’appelant et l’arité de l’adaptateur sont identiques et que le type de paramètre de fin de l’appelant est un type de référence identique ou assignable au type de paramètre de fin de l’adaptateur, les arguments et les valeurs de retour sont convertis par paire, comme si sur #asType asType un handle de méthode arity fixe.

Sinon, les arités diffèrent ou le type de paramètre de fin de l’adaptateur n’est pas assignable à partir du type d’appelant correspondant. Dans ce cas, l’adaptateur remplace tous les arguments de fin de la position d’argument de fin d’origine, par un nouveau tableau de type arrayType, dont les éléments comprennent (dans l’ordre) les arguments remplacés.

Le type d’appelant doit fournir autant d’arguments, et du type correct, pour satisfaire l’exigence de la cible pour les arguments positionnels avant l’argument de tableau de fin. Ainsi, l’appelant doit fournir, au minimum, N-1 des arguments, où N est l’arité de la cible. En outre, il doit exister des conversions entre les arguments entrants et les arguments de la cible. Comme avec d’autres utilisations simples invoke, si ces exigences de base ne sont pas remplies, une WrongMethodTypeException peut être levée.

Dans tous les cas, ce que la cible retourne finalement est retourné inchangé par l’adaptateur.

Dans le dernier cas, il est exactement comme si le handle de méthode cible était temporairement adapté avec un collecteur d’arité fixe #asCollector à la arité requise par le type d’appelant. (Comme avec asCollector, si la longueur du tableau est égale à zéro, une constante partagée peut être utilisée au lieu d’un nouveau tableau. Si l’appel implicite à lever asCollector une IllegalArgumentException ou WrongMethodTypeException, l’appel à l’adaptateur d’arité variable doit lever WrongMethodTypeException.)

Le comportement de #asType asType l’adaptateur est également spécialisé pour les adaptateurs d’arité variable, pour maintenir l’invariant que la plaine, inexacte invoke est toujours équivalente à un asType appel pour ajuster le type cible, suivi par invokeExact. Par conséquent, un adaptateur arity variable répond à une asType demande en créant un collecteur d’arité fixe, si et seulement si l’adaptateur et le type demandé diffèrent en arité ou en type d’argument de fin. Le collecteur d’arités fixes résultant a son type ajusté (si nécessaire) au type demandé par conversion par paire, comme par une autre application de asType.

Lorsqu’un handle de méthode est obtenu en exécutant une ldc instruction d’une CONSTANT_MethodHandle constante et que la méthode cible est marquée comme une méthode d’arité variable (avec le bit 0x0080de modificateur), le handle de méthode accepte plusieurs arités, comme si la constante de handle de méthode a été créée par le biais d’un appel à asVarargsCollector.

Pour créer un adaptateur de collecte qui collecte un nombre prédéterminé d’arguments et dont le type reflète ce nombre prédéterminé, utilisez #asCollector asCollector à la place.

Aucune transformation de handle de méthode ne produit de nouveaux handles de méthode avec arité variable, sauf si elles sont documentées comme cela. Par conséquent, outre asVarargsCollector et withVarargs, toutes les méthodes dans MethodHandle et MethodHandles retournent un handle de méthode avec arité fixe, sauf dans les cas où ils sont spécifiés pour retourner leur opérande d’origine (par exemple, asType du propre type du handle de méthode).

L’appel asVarargsCollector à un handle de méthode qui est déjà d’arité variable produit un handle de méthode avec le même type et le même comportement. Il peut (ou non) retourner le handle de méthode d’arité de variable d’origine.

Voici un exemple de handle de méthode arity variable à création de liste : <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> Ces règles sont conçues comme une variante dynamique des règles de Java pour les méthodes d’arité des variables. Dans les deux cas, les appelants à une méthode ou un handle de méthode variable peuvent passer zéro ou plus d’arguments positionnels, ou passer des tableaux pré-collectés de n’importe quelle longueur. Les utilisateurs doivent connaître le rôle spécial de l’argument final et l’effet d’une correspondance de type sur cet argument final, qui détermine si un seul argument de fin est interprété comme un tableau entier ou un élément unique d’un tableau à collecter. Notez que le type dynamique de l’argument de fin n’a aucun effet sur cette décision, seule une comparaison entre le descripteur de type symbolique du site d’appel et le descripteur de type du handle de méthode.)

Java documentation pour java.lang.invoke.MethodHandle.asVarargsCollector(java.lang.Class<?>).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.