Partager via

MethodHandle.AsSpreader Méthode

  • Référence

Définition

Espace de noms:
Java.Lang.Invoke
Assembly:
Mono.Android.dll

Surcharges

AsSpreader(Class, Int32)

Crée un <>handle de méthode em de propagation</em>, qui accepte un argument de tableau de fin et répartit ses éléments en tant qu’arguments positionnels.
AsSpreader(Int32, Class, Int32)

Crée un <>handle de méthode em array-spreading</em>, qui accepte un argument de tableau à une position donnée et répartit ses éléments en tant qu’arguments positionnels à la place du tableau.

AsSpreader(Class, Int32)

Crée un <>handle de méthode em de propagation</em>, qui accepte un argument de tableau de fin et répartit ses éléments en tant qu’arguments positionnels.

[Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader (Java.Lang.Class? arrayType, int arrayLength);
[<Android.Runtime.Register("asSpreader", "(Ljava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_Ljava_lang_Class_IHandler", ApiSince=26)>]
abstract member AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

Paramètres

arrayType
Class

généralement Object[], le type de l’argument de tableau à partir duquel extraire les arguments de propagation

arrayLength
Int32

nombre d’arguments à répartir à partir d’un argument de tableau entrant

Retours

MethodHandle

un nouveau handle de méthode qui répartit son argument de tableau final, avant d’appeler le handle de méthode d’origine

Attributs
RegisterAttribute

Remarques

Crée un <>handle de méthode em de propagation</em>, qui accepte un argument de tableau de fin et répartit ses éléments en tant qu’arguments positionnels. Le nouveau handle de méthode s’adapte, en tant que cible, à la poignée de méthode actuelle. Le type de l’adaptateur est identique au type de la cible, sauf que les paramètres finaux arrayLength du type cible sont remplacés par un seul paramètre de tableau de type arrayType.

Si le type d’élément de tableau diffère de l’un des types d’arguments correspondants sur la cible d’origine, la cible d’origine est adaptée pour prendre directement les éléments de tableau, comme par un appel à #asType asType.

Lorsqu’elle est appelée, l’adaptateur remplace un argument de tableau de fin par les éléments du tableau, chacun en tant qu’argument propre à la cible. (L’ordre des arguments est conservé.) Ils sont convertis par paire en cas de cast et/ou de désaboxing en types des paramètres de fin de la cible. Enfin, la cible est appelée. Ce que la cible retourne finalement est retourné inchangé par l’adaptateur.

Avant d’appeler la cible, l’adaptateur vérifie que le tableau contient exactement suffisamment d’éléments pour fournir un nombre d’arguments correct au handle de méthode cible. (Le tableau peut également être null quand aucun élément n’est requis.)

Lorsque l’adaptateur est appelé, la longueur de l’argument fourni array est interrogée comme si par ou arraylength bytecodearray.length. Si l’adaptateur accepte un argument de tableau de fin de longueur nulle, l’argument fourni array peut être un tableau de longueur nulle ou null; sinon, l’adaptateur lève un NullPointerException si le tableau est null et lève un IllegalArgumentException si le tableau n’a pas le nombre correct d’éléments.

Voici quelques exemples simples de handles de méthode de propagation de tableau : <blockquote>

{@code
            MethodHandle equals = publicLookup()
              .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
            assert( (boolean) equals.invokeExact("me", (Object)"me"));
            assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
            // spread both arguments from a 2-array:
            MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
            assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
            assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
            // try to spread from anything but a 2-array:
            for (int n = 0; n <= 10; n++) {
              Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
              try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
              catch (IllegalArgumentException ex) { } // OK
            }
            // spread both arguments from a String array:
            MethodHandle eq2s = equals.asSpreader(String[].class, 2);
            assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
            assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
            // spread second arguments from a 1-array:
            MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
            assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
            assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
            // spread no arguments from a 0-array or null:
            MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
            assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
            assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
            // asSpreader and asCollector are approximate inverses:
            for (int n = 0; n <= 2; n++) {
                for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
                    MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
                    assert( (boolean) equals2.invokeWithArguments("me", "me"));
                    assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
                }
            }
            MethodHandle caToString = publicLookup()
              .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
            assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
            MethodHandle caString3 = caToString.asCollector(char[].class, 3);
            assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
            MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
            assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));
            }

</blockquote>

Documentation Java pour java.lang.invoke.MethodHandle.asSpreader(java.lang.Class<?>, int).

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

S’applique à

AsSpreader(Int32, Class, Int32)

Crée un <>handle de méthode em array-spreading</em>, qui accepte un argument de tableau à une position donnée et répartit ses éléments en tant qu’arguments positionnels à la place du tableau.

[Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)]
public virtual Java.Lang.Invoke.MethodHandle? AsSpreader (int spreadArgPos, Java.Lang.Class? arrayType, int arrayLength);
[<Android.Runtime.Register("asSpreader", "(ILjava/lang/Class;I)Ljava/lang/invoke/MethodHandle;", "GetAsSpreader_ILjava_lang_Class_IHandler", ApiSince=33)>]
abstract member AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle
override this.AsSpreader : int * Java.Lang.Class * int -> Java.Lang.Invoke.MethodHandle

Paramètres

spreadArgPos
Int32

position (index de base zéro) dans la liste d’arguments à partir de laquelle la propagation doit commencer.

arrayType
Class

généralement Object[], le type de l’argument de tableau à partir duquel extraire les arguments de propagation

arrayLength
Int32

nombre d’arguments à répartir à partir d’un argument de tableau entrant

Retours

MethodHandle

un nouveau handle de méthode qui répartit un argument de tableau à une position donnée, avant d’appeler le handle de méthode d’origine

Attributs
RegisterAttribute

Remarques

Crée un <>handle de méthode em array-spreading</em>, qui accepte un argument de tableau à une position donnée et répartit ses éléments en tant qu’arguments positionnels à la place du tableau. Le nouveau handle de méthode s’adapte, en tant que cible, à la poignée de méthode actuelle. Le type de l’adaptateur sera identique au type de la cible, sauf que les arrayLength paramètres du type de la cible, en commençant à la position spreadArgPosde base zéro, sont remplacés par un paramètre de tableau unique de type arrayType.

Cette méthode se comporte très bien comme #asSpreader(Class, int), mais accepte un argument supplémentaire spreadArgPos pour indiquer à quelle position dans la liste des paramètres la répartition doit avoir lieu.

Ajouté dans 9.

Documentation Java pour java.lang.invoke.MethodHandle.asSpreader(int, java.lang.Class<?>, int).

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

S’applique à