MethodHandle.AsVarargsCollector(Class) Método

Definición

Espacio de nombres:: Java.Lang.Invoke

Ensamblado:: Mono.Android.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Convierte una <arity adaptador de variable em>que es capaz de aceptar cualquier número de argumentos posicionales finales y recopilarlos en un argumento de matriz.

[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

Parámetros

arrayType: Class

a menudo Object[], el tipo del argumento de matriz que recopilará los argumentos.

Devoluciones

MethodHandle

un nuevo identificador de método que puede recopilar cualquier número de argumentos finales en una matriz, antes de llamar al identificador del método original.

Atributos: RegisterAttribute

Comentarios

Convierte una <arity adaptador de variable em>que es capaz de aceptar cualquier número de argumentos posicionales finales y recopilarlos en un argumento de matriz.

El tipo y el comportamiento del adaptador serán los mismos que el tipo y el comportamiento del destino, salvo que ciertas invoke solicitudes y asType pueden dar lugar a argumentos posicionales finales que se recopilan en el parámetro final del destino. Además, el tipo de último parámetro MethodType#lastParameterType del adaptador será arrayType, incluso si el destino tiene un tipo de último parámetro diferente.

Esta transformación puede devolver this si el identificador del método ya es de aridad variable y su tipo de parámetro final es idéntico a arrayType.

Cuando se llama a con #invokeExact invokeExact, el adaptador invoca el destino sin cambios de argumento. (Note: Este comportamiento es diferente de un #asCollector recopilador de aridad fija, ya que acepta una matriz completa de longitud indeterminada, en lugar de un número fijo de argumentos).

Cuando se llama con sin formato, inexacta #invoke invoke, si el tipo de llamador es el mismo que el adaptador, el adaptador invoca el destino como con invokeExact. (Este es el comportamiento normal para invoke cuando los tipos coinciden).

De lo contrario, si el autor de la llamada y la aridad del adaptador son iguales y el tipo de parámetro final del autor de la llamada es un tipo de referencia idéntico o asignable al tipo de parámetro final del adaptador, los argumentos y los valores devueltos se convierten en pares, como si estuviera en #asType asType un identificador de método de aridad fijo.

De lo contrario, las aridades difieren o el tipo de parámetro final del adaptador no se puede asignar desde el tipo de llamador correspondiente. En este caso, el adaptador reemplaza todos los argumentos finales de la posición del argumento final original en adelante, por una nueva matriz de tipo arrayType, cuyos elementos componen (en orden) los argumentos reemplazados.

El tipo de llamador debe proporcionar como mínimo argumentos suficientes y del tipo correcto para satisfacer el requisito del destino para los argumentos posicionales antes del argumento de matriz final. Por lo tanto, el autor de la llamada debe proporcionar, como mínimo, N-1 argumentos, donde N es la aridad del destino. Además, debe existir conversiones de los argumentos entrantes a los argumentos del destino. Al igual que con otros usos de sin formato invoke, si no se cumplen estos requisitos básicos, se puede producir una WrongMethodTypeException excepción .

En todos los casos, el adaptador devuelve el valor que devuelve el destino.

En el último caso, es exactamente como si el controlador de método de destino se adaptara temporalmente con un recopilador de aridad fija #asCollector a la aridad requerida por el tipo de llamador. (Al igual que con asCollector, si la longitud de la matriz es cero, se puede usar una constante compartida en lugar de una nueva matriz. Si la llamada implícita a asCollector produciría o IllegalArgumentExceptionWrongMethodTypeException, la llamada al adaptador de aridad de variables debe iniciar WrongMethodTypeException.

El comportamiento de también está especializado para adaptadores de #asType asType aridad variable, para mantener la invariable que sin formato, inexact invoke siempre es equivalente a una asType llamada para ajustar el tipo de destino, seguido de invokeExact. Por lo tanto, un adaptador de aridad variable responde a una asType solicitud mediante la creación de un recopilador de aridad fija, si y solo si el adaptador y el tipo solicitado difieren en aridad o en el tipo de argumento final. El recopilador de aridad fija resultante tiene su tipo ajustado más (si es necesario) al tipo solicitado por conversión en pares, como si fuera otra aplicación de asType.

Cuando se obtiene un identificador de método mediante la ejecución de una ldc instrucción de una CONSTANT_MethodHandle constante y el método de destino se marca como un método de aridad variable (con el bit 0x0080modificador ), el identificador de método aceptará varias aridades, como si la constante de identificador de método se creara mediante una llamada a asVarargsCollector.

Para crear un adaptador de recopilación que recopile un número predeterminado de argumentos y cuyo tipo refleje este número predeterminado, use #asCollector asCollector en su lugar.

Ninguna transformación de identificador de método genera nuevos identificadores de método con aridad variable, a menos que se documenten como lo hacen. Por lo tanto, además asVarargsCollector de y withVarargs, todos los métodos de MethodHandle y MethodHandles devolverán un identificador de método con aridad fija, excepto en los casos en los que se especifican para devolver su operando original (por ejemplo, asType del tipo propio del identificador del método).

Al llamar asVarargsCollector a en un identificador de método que ya sea de aridad variable, se generará un identificador de método con el mismo tipo y comportamiento. Puede devolver (o no) el identificador del método de aridad de variable original.

Este es un ejemplo de un identificador de método de aridad de variable de creación de listas: <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>

Discussion: Estas reglas están diseñadas como una variación de tipo dinámico de las reglas de Java para los métodos de aridad de variables. En ambos casos, los llamadores a un método de aridad variable o un identificador de método pueden pasar cero o más argumentos posicionales, o bien pasar matrices previamente recopiladas de cualquier longitud. Los usuarios deben tener en cuenta el rol especial del argumento final y del efecto de una coincidencia de tipo en ese argumento final, que determina si un único argumento final se interpreta como una matriz completa o un único elemento de una matriz que se va a recopilar. Tenga en cuenta que el tipo dinámico del argumento final no tiene ningún efecto en esta decisión, solo una comparación entre el descriptor de tipo simbólico del sitio de llamada y el descriptor de tipo del identificador de método).

Java documentación para java.lang.invoke.MethodHandle.asVarargsCollector(java.lang.Class<?>).

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.

Se aplica a