Класс MethodHandles

Этот метод чувствителен к вызывающему объекту, что означает, что он может возвращать разные значения различным вызывающим объектам.

Согласно соглашению, класс lookup для данного объекта lookup будет Object.

Вызывающему объекту, указанному как объект Lookup в модуле M1 разрешено выполнять глубокое рефлексирование по модулю M2 и пакету целевого класса только в том случае, если выполняются все следующие условия:

• Если менеджер безопасности существует, вызывается его метод checkPermission для проверки ReflectPermission("suppressAccessChecks") и он должен завершиться без исключений.
• Объект lookup вызывающего объекта должен иметь полные привилегии доступа. В частности:
  • Объект lookup вызывающего объекта должен иметь режим lookup MODULE. (Это необходимо, так как иначе не было бы способа гарантировать, что исходный создатель lookup был членом любого конкретного модуля, и поэтому любые последующие проверки читаемости и квалифицированных экспортов стали бы неэффективными.)
  • Объект lookup вызывающего объекта должен иметь доступ PRIVATE. (Это необходимо, так как приложение, намеревающееся использовать внутримодульный доступ с помощью MODULE в одиночку, непреднамеренно также позволит глубокое рефлексирование к своему собственному модулю.)
• Целевой класс должен быть обычным классом, а не примитивным или массивом. (Таким образом, M2 хорошо определён.)
• Если вызывающий модуль M1 отличается от целевого модуля M2, то должны выполняться оба следующих условия:
  • M1 reads M2.
  • M2 opens пакет, содержащий целевой класс, должен быть по крайней мере M1.

Если какое-либо из вышеперечисленных проверок нарушается, этот метод завершается с исключением.

В противном случае, если M1 и M2 являются одним модулем, этот метод возвращает Lookup на targetClass с полным привилегированным доступом и предыдущим классом lookup.

В противном случае, M1 и M2 являются разными модулями. Этот метод возвращает Lookup на targetClass с записью класса lookup вызывающего объекта в качестве нового предыдущего класса lookup с доступом PRIVATE, но без доступа MODULE.

Полученный Lookup объект не имеет ORIGINAL доступа.

Скрытый класс с данными класса может быть создан с помощью вызова Lookup::defineHiddenClassWithClassData. Этот метод заставит выполниться статический инициализатор класса lookup данного caller объекта lookup, если он ещё не был инициализирован.

Скрытые классы, созданные с помощью Lookup::defineHiddenClass, и обычные классы не имеют данных класса. null возвращается, если этот метод вызывается для таких классов.

У режимов lookup для этого lookup должен быть исходный доступ для получения данных класса.

Скрытый класс с данными класса можно создать, вызвав Lookup::defineHiddenClassWithClassData. Этот метод заставит выполнить статический инициализатор класса поиска заданного caller объекта поиска, если он не был инициализирован.

Скрытый класс, созданный с помощью Lookup::defineHiddenClass, и нескрытые классы не имеют данных класса. null возвращается, если этот метод вызывается для объекта поиска в этих классах.

Режимы поиска для этого поиска должны иметь оригинальный доступ для получения данных класса.

Если есть менеджер безопасности, вызывается его метод checkPermission с разрешением ReflectPermission("suppressAccessChecks")

Если возвращаемый обработчик метода вызывается с отрицательным размером массива, будет брошено NegativeArraySizeException

Если возвращаемый обработчик метода вызывается с null ссылкой на массив, будет брошено NullPointerException

При вызове возвращаемого обработчика метода ссылка на массив и индекс массива проверяются. Будет брошено NullPointerException, если ссылка на массив null, и ArrayIndexOutOfBoundsException будет брошено, если индекс отрицательный или если он больше или равен длине массива.

При вызове возвращаемого обработчика метода ссылка на массив и индекс массива проверяются. Будет брошено NullPointerException, если ссылка на массив null, и ArrayIndexOutOfBoundsException будет брошено, если индекс отрицательный или если он больше или равен длине массива.

Определённые режимы доступа возвращаемого VarHandle не поддерживаются в следующих условиях:

• если компонентный тип — любой, кроме byte, short, char, int, long, float, или double, то атомарные режимы обновления числовых значений не поддерживаются.
• если компонентный тип — любой, кроме boolean, byte, short, char, int или long, то атомарные режимы обновления битовых значений не поддерживаются.

Если компонентный тип — float или double, то режимы числового и атомарного обновления сравнивают значения, используя их битовое представление (см. Float.floatToRawIntBits(float) и Double.doubleToRawLongBits(double) соответственно).

При вызове возвращаемого VarHandle, ссылка на массив и индекс проверяются. Будет брошено исключение NullPointerException, если ссылка на массив null, и исключение ArrayIndexOutOfBoundsException, если индекс отрицательный или больше или равен длине массива.

Поддерживаемые компонентные типы (типы переменных) — short, char, int, long, float и double.

Доступ к байтам по заданному индексу приведёт к исключению ArrayIndexOutOfBoundsException, если индекс меньше 0 или больше, чем длина массива byte[] минус размер (в байтах) T.

Доступ к байтам по индексу может быть выровнен или не выровнен для T, относительно базового адрес памяти A, связанного с массивом и индексом. Если доступ не выровнен, доступ к любым режимам, кроме get и set, приведёт к исключению IllegalStateException. В таких случаях атомарный доступ гарантирован только относительно наибольшей степени двойки, которая делит НОД A и размер (в байтах) T. Если доступ выровнен, то следующие режимы доступа поддерживаются и гарантируют атомарный доступ:

• режимы чтения и записи для всех T, за исключением режимов доступа get и set для long и double на 32-битных платформах.
• режимы атомарного обновления для int, long, float или double (будущие крупные обновления платформы JDK могут добавить поддержку дополнительных типов для некоторых режимов доступа, которые в настоящее время не поддерживаются).
• режимы числового атомарного обновления для int и long (будущие крупные обновления платформы JDK могут добавить поддержку дополнительных числовых типов для некоторых режимов доступа, которые в настоящее время не поддерживаются).
• режимы битового атомарного обновления для int и long (будущие крупные обновления платформы JDK могут добавить поддержку дополнительных числовых типов для некоторых режимов доступа, которые в настоящее время не поддерживаются).

Невыровненный доступ, а следовательно, гарантии атомарности, могут быть определены для массивов byte[] без работы с конкретным массивом. Учитывая index, T и соответствующий упакованный тип T_BOX, невыравнивание можно определить следующим образом:

 int sizeOfT = T_BOX.BYTES;  // size in bytes of T
 int misalignedAtZeroIndex = ByteBuffer.wrap(new byte[0]).
     alignmentOffset(0, sizeOfT);
 int misalignedAtIndex = (misalignedAtZeroIndex + index) % sizeOfT;
 boolean isMisaligned = misalignedAtIndex != 0;
 

Если тип переменной — float или double, то режимы атомарного обновления сравнивают значения, используя их битовое представление (см. Float.floatToRawIntBits(float) и Double.doubleToRawLongBits(double) соответственно).

Поддерживаемые типы компонентов (типы переменных) — short, char, int, long, float и double.

Доступ приведёт к ReadOnlyBufferException для операций, отличных от чтения, если ByteBuffer является только для чтения.

Доступ к байтам по заданному индексу приведёт к IndexOutOfBoundsException, если индекс меньше 0 или больше, чем предел ByteBuffer минус размер (в байтах) T.

Доступ к байтам по индексу может быть выровненным или невыровненным относительно базового адреса памяти, A скажем, связанного с ByteBuffer и индексом. Если доступ невыровнен, то доступ для операций, отличных от get и set режимов доступа, приведёт к IllegalStateException. В таких случаях атомный доступ гарантируется только по отношению к наибольшей степени двойки, которая делит НОД A и размера (в байтах) T. Если доступ выровнен, то поддерживаются следующие режимы доступа, которые гарантированно поддерживают атомный доступ:

• режимы доступа для чтения и записи для всех T, за исключением режимов доступа get и set для long и double на 32-битных платформах.
• атомные режимы обновления для int, long, float или double. (В будущих крупных выпусках платформы JDK могут быть добавлены дополнительные типы для некоторых в настоящее время неподдерживаемых режимов доступа.)
• атомные режимы числового обновления для int и long. (В будущих крупных выпусках платформы JDK могут быть добавлены дополнительные числовые типы для некоторых в настоящее время неподдерживаемых режимов доступа.)
• атомные режимы побитового обновления для int и long. (В будущих крупных выпусках платформы JDK могут быть добавлены дополнительные числовые типы для некоторых в настоящее время неподдерживаемых режимов доступа.)

Невыровненные операции доступа, и, следовательно, гарантии атомности, могут быть определены для ByteBuffer, bb (прямого или иного), index, T и его соответствующего упакованного типа, T_BOX, следующим образом:

 int sizeOfT = T_BOX.BYTES;  // size in bytes of T
 ByteBuffer bb = ...
 int misalignedAtIndex = bb.alignmentOffset(index, sizeOfT);
 boolean isMisaligned = misalignedAtIndex != 0;
 

Если тип переменной — float или double, то атомные режимы обновления сравнивают значения, используя их двоичное представление (см. Float.floatToRawIntBits(float) и Double.doubleToRawLongBits(double) соответственно).

• один целевой MethodHandle
• ноль или более ведущих значений (подсчитывается leadingArgCount)
• массив Object[] содержащий хвостовые аргументы

Обработчик вызовов вызовет свою цель как вызов invoke с указанными type. То есть, если цель точно соответствует заданному type, она будет вести себя как invokeExact; в противном случае она будет вести себя так, как если бы использовался asType для преобразования цели к требуемому type.

Тип возвращаемого обработчика вызовов не будет заданным type, а будет содержать все параметры, кроме первого leadingArgCount, заменённые единственным массивом типа Object[], который будет последним параметром.

Перед вызовом своей цели обработчик вызовов распределит конечный массив, применит необходимые преобразования ссылок и распакует и расширит примитивные аргументы. Если при вызове обработчика вызовов аргумент массива не имеет правильного количества элементов, обработчик вызовов выбросит IllegalArgumentException вместо вызова цели.

Этот метод эквивалентен следующему коду (хотя может быть более эффективным):

MethodHandle invoker = MethodHandles.invoker(type);
int spreadArgCount = type.parameterCount() - leadingArgCount;
invoker = invoker.asSpreader(Object[].class, spreadArgCount);
return invoker;
 

Этот метод эквивалентен следующему коду (хотя может быть более эффективным): publicLookup().findVirtual(MethodHandle.class, "invokeExact", type)

Обсуждение: Обработчики вызовов могут быть полезны при работе с изменяемыми обработчиками методов неизвестных типов. Например, чтобы эмулировать вызов invokeExact к переменной методу-обработчику M, извлечь его тип T, найти обработчик вызовов X для T, и вызвать обработчик вызовов, как X.invoke(T, A...). (Нельзя вызвать X.invokeExact, так как тип T неизвестен.) Если требуется распределение, сбор или другие преобразования аргументов, их можно применить один раз к обработчику вызовов X и повторно использовать для многих значений обработчика методов M, при условии, что они совместимы с типом X.

(Примечание: обработчик вызовов не доступен через API Core Reflection. Попытка вызвать java.lang.reflect.Method.invoke на объявленный invokeExact или invoke метод вызовет UnsupportedOperationException.)

Этот метод не генерирует исключения, связанные с рефлексией или безопасностью.

Перед вызовом своего целевого метода, если целевой метод отличается от ожидаемого типа, обработчик-метод применит необходимые преобразования ссылок и упакует, распакует или расширит примитивные значения, как если бы это делалось с помощью asType. Аналогично, возвращаемое значение будет преобразовано при необходимости. Если целевой метод является методом с переменным числом аргументов, то будет выполнено необходимое преобразование арности, опять же, как если бы это делалось с помощью asType.

Этот метод эквивалентен следующему коду (хотя он может быть более эффективным): publicLookup().findVirtual(MethodHandle.class, "invoke", type)

Обсуждение: общий тип метода — это тип, который упоминает только Object аргументы и возвращаемые значения. Обработчик-метод для такого типа способен вызывать любой обработчик-метод с такой же арностью, как и общий тип.

(Примечание: метод обработчика недоступен через API Core Reflection. Попытка вызвать java.lang.reflect.Method.invoke на объявленном invokeExact или invoke методе приведет к возбуждению UnsupportedOperationException.)

Этот метод не вызывает рефлексивных или безопасности исключений.

Перед вызовом своего целевого метода, если тип режима доступа отличается от желаемого типа, обработчик-метод применит необходимые преобразования ссылок и упакует, распакует или расширит примитивные значения, как если бы это делалось с помощью asType. Аналогично, возвращаемое значение будет преобразовано при необходимости.

Этот метод эквивалентен следующему коду (хотя он может быть более эффективным): publicLookup().findVirtual(VarHandle.class, accessMode.name(), type)

Если исходный и новый типы равны, возвращает target.

Разрешены те же преобразования, что и для MethodHandle.asType, и некоторые дополнительные преобразования также применяются, если эти преобразования не удаются. Даны типы T0, T1, одно из следующих преобразований применяется, если возможно, до или вместо любых преобразований, выполненных asType:

• Если T0 и T1 — ссылки, а T1 — тип интерфейса, то значение типа T0 передается как T1 без преобразования. (Это обращение к интерфейсам соответствует использованию верификатора байткода.)
• Если T0 — boolean, а T1 — другой примитивный тип, то boolean преобразуется в значение типа byte, 1 для true, 0 для false. (Это обращение соответствует использованию верификатора байткода.)
• Если T1 — boolean, а T0 — другой примитивный тип, то T0 преобразуется в byte через преобразование Java (JLS 5.5), и проверяется младший бит результата, как если бы это делалось с помощью (x & 1) != 0.
• Если T0 и T1 — примитивные типы, отличные от boolean, то применяется преобразование Java (JLS 5.5). (В частности, T0 преобразуется в T1 путем расширения и/или сужения.)
• Если T0 — ссылка, а T1 — примитивный тип, то в момент выполнения будет применено преобразование распаковки, возможно, за которым следует преобразование Java (JLS 5.5) для примитивного значения, возможно, за которым следует преобразование из byte в boolean путем проверки младшего бита.
• Если T0 — ссылка, а T1 — примитивный тип, и если ссылка равна null в момент выполнения, то вводится нулевое значение.

Заданный массив управляет переупорядочиванием. Вызовите #I количество входных параметров (значение newType.parameterCount()), и вызовите #O количество выходных параметров (значение target.type().parameterCount()). Тогда длина массива переупорядочения должна быть #O, и каждый элемент должен быть неотрицательным числом, меньшим #I. Для каждого N меньше #O, N-й выходной аргумент будет взят из I-го входного аргумента, где I является reorder[N].

Не применяются никакие преобразования аргументов или возвращаемых значений. Тип каждого входного аргумента, как определено newType, должен быть идентичен типу соответствующего выходного параметра или параметров в целевом обработчике-методе. Тип возвращаемого значения newType должен быть идентичен типу возвращаемого значения оригинала.

Массив переупорядочения не обязательно должен задавать фактическое переупорядочение. Входной аргумент будет дублироваться, если его индекс встречается более одного раза в массиве, и входной аргумент будет отброшен, если его индекс не встречается в массиве. Как и в случае с dropArguments, входные аргументы, которые не упомянуты в массиве переупорядочения, могут быть любого типа, определяемого только newType.

import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodType intfn1 = methodType(int.class, int.class);
MethodType intfn2 = methodType(int.class, int.class, int.class);
MethodHandle sub = ... (int x, int y) -> (x-y) ...;
assert(sub.type().equals(intfn2));
MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1);
MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0);
assert((int)rsub.invokeExact(1, 100) == 99);
MethodHandle add = ... (int x, int y) -> (x+y) ...;
assert(add.type().equals(intfn2));
MethodHandle twice = permuteArguments(add, intfn1, 0, 0);
assert(twice.type().equals(intfn1));
assert((int)twice.invokeExact(21) == 42);
 

Примечание: Полученный адаптер никогда не является обработчиком-методом с переменным числом аргументов, даже если исходный целевой обработчик-метод был таковым.

Перед возвратом обработчика метода переданное значение преобразуется в требуемый тип. Если требуемый тип является примитивным, то используются расширяющие примитивные преобразования, в противном случае — преобразования ссылок.

Возвращаемый обработчик метода эквивалентен identity(type).bindTo(value).

Возвращаемый обработчик метода эквивалентен empty(methodType(type)). Он также эквивалентен explicitCastArguments(constant(Object.class, null), methodType(type)), так как explicitCastArguments преобразует null в значения по умолчанию.

Возвращаемый обработчик метода эквивалентен dropArguments(zero(type.returnType()), 0, type.parameterList()).

Тип нового обработчика метода будет исключать типы связанных параметров из исходного типа целевого объекта, поскольку новому обработчику метода больше не потребуется, чтобы вызывающие стороны предоставляли эти аргументы.

Каждое переданное значение аргумента должно соответствовать типу соответствующего связанного параметра. Если тип связанного параметра является примитивным, значение аргумента должно быть обёрткой, и оно будет распаковано для получения примитивного значения.

Аргумент pos выбирает, какие параметры нужно связать. Он может принимать значения от нуля до N-L (включительно), где N — арность целевого обработчика метода, а L — длина массива значений.

Примечание: Результирующий адаптер никогда не является обработчиком метода с переменным количеством аргументов, даже если исходный целевой обработчик метода был таковым.

Аргумент pos может принимать значения от нуля до N, где N — арность целевого объекта. Если pos равно нулю, фиктивные аргументы будут стоять перед реальными аргументами целевого объекта; если pos равно N, они будут стоять после.

Пример:

import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle cat = lookup().findVirtual(String.class,
  "concat", methodType(String.class, String.class));
assertEquals("xy", (String) cat.invokeExact("x", "y"));
MethodType bigType = cat.type().insertParameterTypes(0, int.class, String.class);
MethodHandle d0 = dropArguments(cat, 0, bigType.parameterList().subList(0,2));
assertEquals(bigType, d0.type());
assertEquals("yz", (String) d0.invokeExact(123, "x", "y", "z"));
 

Этот метод также эквивалентен следующему коду:

 dropArguments(target, pos, valueTypes.toArray(new Class[0]))
 

Аргумент pos может принимать значения от нуля до N, где N — арность целевого объекта. Если pos равно нулю, фиктивные аргументы будут стоять перед реальными аргументами целевого объекта; если pos равно N, они будут стоять после.

Результирующий обработчик будет иметь тот же тип возвращаемого значения, что и целевой обработчик.

В более формальных терминах, предположим эти два списка типов:

• Целевой обработчик имеет список типов параметров S..., M..., с таким количеством типов в S как указано в skip. Типы M - это те, которые должны совпасть с частью заданного списка типов, newTypes.
• Список newTypes содержит типы P..., M..., A..., с таким количеством типов в P как указано в pos. Типы M - это именно те типы, которые типы M в списке типов параметров целевого обработчика должны совпасть. Типы в A - это дополнительные типы, найденные после совпадающего подсписка.

Предварительная обработка выполняется одним или несколькими методами-обработчиками, указанными в элементах массива filters. Первый элемент массива фильтров соответствует аргументу pos целевого объекта, и так далее последовательно. Функции фильтра вызываются слева направо.

Нулевые аргументы в массиве обрабатываются как идентичность, и соответствующие аргументы остаются неизменными. (Если в массиве нет ненулевых элементов, возвращается исходный целевой объект.) Каждый фильтр применяется к соответствующему аргументу адаптера.

Если фильтр F применяется к N-му аргументу целевого объекта, то F должен быть методом-обработчиком, принимающим ровно один аргумент. Тип единственного аргумента F заменяет соответствующий тип аргумента целевого объекта в результирующем адаптированном методе-обработчике. Тип возвращаемого значения F должен быть идентичен соответствующему типу параметра целевого объекта.

Ошибка возникает, если есть элементы массива filters (null или не null), которые не соответствуют позициям аргументов в целевом объекте.

Пример:

import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle cat = lookup().findVirtual(String.class,
  "concat", methodType(String.class, String.class));
MethodHandle upcase = lookup().findVirtual(String.class,
  "toUpperCase", methodType(String.class));
assertEquals("xy", (String) cat.invokeExact("x", "y"));
MethodHandle f0 = filterArguments(cat, 0, upcase);
assertEquals("Xy", (String) f0.invokeExact("x", "y")); // Xy
MethodHandle f1 = filterArguments(cat, 1, upcase);
assertEquals("xY", (String) f1.invokeExact("x", "y")); // xY
MethodHandle f2 = filterArguments(cat, 0, upcase, upcase);
assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
 

Вот псевдокод для результирующего адаптера. В коде T обозначает тип возвращаемого значения как target, так и результирующего адаптера. P/p и B/b представляют типы и значения параметров и аргументов, которые предшествуют и следуют за позицией фильтра pos, соответственно. A[i]/a[i] обозначают типы и значения отфильтрованных параметров и аргументов; они также представляют типы возвращаемых значений методов-обработчиков filter[i]. Последние принимают аргументы v[i] типа V[i], которые также появляются в сигнатуре результирующего адаптера.

 T target(P... p, A[i]... a[i], B... b);
 A[i] filter[i](V[i]);
 T adapter(P... p, V[i]... v[i], B... b) {
   return target(p..., filter[i](v[i])..., b...);
 }
 

Примечание: Полученный адаптер никогда не является методом-обработчиком с переменным числом аргументов, даже если исходный целевой метод-обработчик был им.

Если фильтр возвращает значение, целевой метод должен принять это значение в качестве аргумента на позиции pos, перед и/или после любых аргументов, не переданных фильтру. Если фильтр возвращает void, целевой метод должен принять все аргументы, не переданные фильтру. Аргументы не переупорядочиваются, и результат, возвращённый фильтром, заменяет (в порядке) всю подпоследовательность аргументов, изначально переданных адаптеру.

Типы аргументов (если таковые имеются) фильтра заменяют ноль или один тип аргументов целевого метода на позиции pos в результирующем адаптированном обработчике метода. Тип возвращаемого значения фильтра (если таковой имеется) должен быть идентичен типу аргумента целевого метода на позиции pos, и этот аргумент целевого метода поставляется значением, возвращённым фильтром.

Во всех случаях pos должно быть больше или равно нулю, а pos также должно быть меньше или равно арности целевого метода.

Пример:

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"));
 

Вот псевдокод для результирующего адаптера. В коде T представляет тип возвращаемого значения target и результирующего адаптера. V/v обозначают тип возвращаемого значения и значение filter, которые также присутствуют в сигнатуре и аргументах target, соответственно, если V не void. A/a и C/c обозначают типы параметров и значения, предшествующие и следующие за позицией сбора pos в сигнатуре target. Они также появляются в сигнатуре результирующего адаптера и аргументах, где они окружают B/b, которые представляют типы параметров и аргументы filter (если таковые имеются).

 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...);
 T adapter3(A... a,B... b,C... c) {
   filter3(b...);
   return target3(a...,c...);
 }
 

Адаптер сбора collectArguments(mh, 0, coll) эквивалентен тому, который сначала "складывает" затронутые аргументы, а затем удаляет их, в отдельных шагах следующим образом:

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

Примечание: Результирующий адаптер никогда не является многоаргументным обработчиком метода, даже если исходный целевой обработчик метода был таковым.

Если целевой метод возвращает значение, фильтр должен принять это значение в качестве единственного аргумента. Если целевой метод возвращает void, фильтр должен принять никаких аргументов.

Тип возвращаемого значения фильтра заменяет тип возвращаемого значения целевого метода в результирующем адаптированном обработчике метода. Тип аргумента фильтра (если таковой имеется) должен быть идентичен типу возвращаемого значения целевого метода.

Пример:

import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle cat = lookup().findVirtual(String.class,
  "concat", methodType(String.class, String.class));
MethodHandle length = lookup().findVirtual(String.class,
  "length", methodType(int.class));
System.out.println((String) cat.invokeExact("x", "y")); // xy
MethodHandle f0 = filterReturnValue(cat, length);
System.out.println((int) f0.invokeExact("x", "y")); // 2
 

Вот псевдокод для результирующего адаптера. В коде T/t представляют тип возвращаемого значения и значение target; V, тип возвращаемого значения filter; а A/a, типы и значения параметров и аргументов target, а также результирующего адаптера.

 T target(A...);
 V filter(T);
 V adapter(A... a) {
   T t = target(a...);
   return filter(t);
 }
 // and if the target has a void return:
 void target2(A...);
 V filter2();
 V adapter2(A... a) {
   target2(a...);
   return filter2();
 }
 // and if the filter has a void return:
 T target3(A...);
 void filter3(V);
 void adapter3(A... a) {
   T t = target3(a...);
   filter3(t);
 }
 

Примечание: Результирующий адаптер никогда не является многоаргументным обработчиком метода, даже если исходный целевой обработчик метода был таковым.

Предварительная обработка выполняется combiner, вторым обработчиком метода. Из аргументов, переданных адаптеру, первые N аргументов копируются в комбинирующее устройство, которое затем вызывается. (Здесь N определяется как количество параметров комбинирующего устройства.) После этого управление передаётся целевому методу, а любой результат от комбинирующего устройства вставляется перед исходными N входными аргументами.

Если комбинирующее устройство возвращает значение, первый тип параметра целевого метода должен быть идентичен типу возвращаемого значения комбинирующего устройства, а следующие N типы параметров целевого метода должны точно соответствовать параметрам комбинирующего устройства.

Если комбинирующее устройство возвращает void, результат не будет вставлен, и первые N типы параметров целевого метода должны точно соответствовать параметрам комбинирующего устройства.

Результирующий адаптер имеет тот же тип, что и целевой, за исключением того, что первый тип параметра пропускается, если он соответствует результату комбинирующего устройства.

(Обратите внимание, что dropArguments можно использовать для удаления любых аргументов, которые не требуются ни комбинирующему устройству, ни целевому методу. Если некоторые входные аргументы предназначены только для комбинирующего устройства, рассмотрите использование asCollector вместо этого, так как эти аргументы не нужно будет хранить в стеке при входе в целевой метод.)

Пример:

import static java.lang.invoke.MethodHandles.*;
import static java.lang.invoke.MethodType.*;
...
MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class,
  "println", methodType(void.class, String.class))
    .bindTo(System.out);
MethodHandle cat = lookup().findVirtual(String.class,
  "concat", methodType(String.class, String.class));
assertEquals("boojum", (String) cat.invokeExact("boo", "jum"));
MethodHandle catTrace = foldArguments(cat, trace);
// also prints "boo":
assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
 

Вот псевдокод для результирующего адаптера. В коде T представляет тип возвращаемого значения target и результирующего адаптера. V/v представляют тип и значение параметра и аргумента target перед позицией складывания; V также является типом возвращаемого значения combiner. A/a обозначают типы и значения параметров и аргументов N на позиции складывания. B/b представляют типы и значения параметров и аргументов target, которые следуют за сложенными параметрами и аргументами.

 // there are N arguments in A...
 T target(V, A[N]..., B...);
 V combiner(A...);
 T adapter(A... a, B... b) {
   V v = combiner(a...);
   return target(v, a..., b...);
 }
 // and if the combiner has a void return:
 T target2(A[N]..., B...);
 void combiner2(A...);
 T adapter2(A... a, B... b) {
   combiner2(a...);
   return target2(a..., b...);
 }
 

Примечание: Результирующий адаптер никогда не является многоаргументным обработчиком метода, даже если исходный целевой обработчик метода был таковым.

Этот метод тесно связан с foldArguments(MethodHandle, MethodHandle), но позволяет управлять позицией в списке параметров, в которой происходит условное складывание. Аргумент, контролирующий это, pos, представляет собой индекс, начинающийся с нуля. Указанный метод foldArguments(MethodHandle, MethodHandle) предполагает позицию 0.

Вот псевдокод для результирующего адаптера. В коде T представляет собой унифицированный тип результата трёх задействованных обработчиков; A/a, типы и значения параметров и аргументов target потребляемых test; и B/b, те типы и значения параметров и аргументов target не потребляемых test.

 boolean test(A...);
 T target(A...,B...);
 T fallback(A...,B...);
 T adapter(A... a,B... b) {
   if (test(a...))
     return target(a..., b...);
   else
     return fallback(a..., b...);
 }
 

Целевой обработчик и обработчик должны иметь одинаковые соответствующие типы аргументов и возвращаемых значений, за исключением того, что обработчик может опустить хвостовые аргументы (аналогично предикату в guardWithTest). Кроме того, обработчик должен иметь дополнительный ведущий параметр типа exType или его супертип.

Вот псевдокод для результирующего адаптера. В коде T представляет тип возвращаемого значения target и handler, а также результирующего адаптера; A/a, типы и значения аргументов результата, потребляемых handler; и B/b, типы и значения аргументов результата, игнорируемых handler.

 T target(A..., B...);
 T handler(ExType, A...);
 T adapter(A... a, B... b) {
   try {
     return target(a..., b...);
   } catch (ExType ex) {
     return handler(ex, a...);
   }
 }
 

Целевой обработчик и обработчик должны возвращать один и тот же тип, даже если обработчик всегда выбрасывает исключение. (Это может произойти, например, потому, что обработчик моделирует finally условие). Чтобы создать такой обработчик, выбрасывающий исключение, составьте логику создания обработчика с throwException, чтобы создать обработчик метода с правильным типом возвращаемого значения.

Обработчик pred описывает условие цикла; а body, его тело. Цикл, полученный с помощью этого метода, в каждой итерации сначала вычисляет предикат, а затем выполняет его тело (если предикат вычисляется как true). Цикл завершится, как только предикат вычислится как false (в этом случае тело не будет выполнено).

Обработчик init описывает начальное значение дополнительной необязательной локальной переменной цикла. В каждой итерации эта локальная переменная цикла, если она присутствует, передаётся в body и обновляется значением, возвращаемым из её вызова. Результатом выполнения цикла будет конечное значение дополнительной локальной переменной цикла (если она присутствует).

Для этих аргументов-обработчиков действуют следующие правила:

• Обработчик body не должен быть null; его тип должен иметь вид (V A...)V, где V не void, или же (A...)void. (В случае void, мы присваиваем типу void имя V, и будем писать (V A...)V с пониманием, что тип void V тихо удаляется из списка параметров, оставляя (A...)V.)
• Список параметров (V A...) тела называется внутренним списком параметров. Он будет ограничивать списки параметров других частей цикла.
• Если тип переменной итерации V удаляется из внутреннего списка параметров, получившийся более короткий список (A...) называется внешним списком параметров.
• Тип возвращаемого значения тела V, если он не void, определяет тип дополнительной переменной состояния цикла. Тело должно принимать и возвращать значение этого типа V.
• Если init не null, он должен иметь тип возвращаемого значения V. Его список параметров (некоторого вида (A*)) должен быть эквивалентен внешнему списку параметров (A...).
• Если init является null, переменная цикла будет инициализирована её стандартным значением.
• Обработчик pred не должен быть null. Он должен иметь boolean в качестве типа возвращаемого значения. Его список параметров (либо пустой, либо вида (V A*)) должен быть эквивалентен внутреннему списку параметров.

Тип результата и сигнатура параметра полученного обработчика цикла определяются следующим образом:

• Тип результата обработчика цикла — это тип результата V тела.
• Типы параметров обработчика цикла — это типы (A...), из внешнего списка параметров.

Вот псевдокод для полученного обработчика цикла. В коде V/v представляют тип/значение единственной переменной цикла, а также тип результата цикла; и A/a, тип/значение аргумента, переданного в цикл.

 V init(A...);
 boolean pred(V, A...);
 V body(V, A...);
 V whileLoop(A... a...) {
   V v = init(a...);
   while (pred(v, a...)) {
     v = body(v, a...);
   }
   return v;
 }
 

Обработчик pred описывает условие цикла; а body, его тело. Цикл, полученный с помощью этого метода, в каждой итерации сначала выполняет его тело, а затем вычисляет предикат. Цикл завершится, как только предикат вычислится как false после выполнения тела.

Обработчик init описывает начальное значение дополнительной необязательной локальной переменной цикла. В каждой итерации эта локальная переменная цикла, если она присутствует, передаётся в body и обновляется значением, возвращаемым из её вызова. Результатом выполнения цикла будет конечное значение дополнительной локальной переменной цикла (если она присутствует).

Для этих аргументов-обработчиков действуют следующие правила:

• Обработчик body не должен быть null; его тип должен иметь вид (V A...)V, где V не void, или же (A...)void. (В случае void, мы присваиваем типу void имя V, и будем писать (V A...)V с пониманием, что тип void V тихо удаляется из списка параметров, оставляя (A...)V.)
• Список параметров (V A...) тела называется внутренним списком параметров. Он будет ограничивать списки параметров других частей цикла.
• Если тип переменной итерации V удаляется из внутреннего списка параметров, получившийся более короткий список (A...) называется внешним списком параметров.
• Тип возвращаемого значения тела V, если он не void, определяет тип дополнительной переменной состояния цикла. Тело должно принимать и возвращать значение этого типа V.
• Если init не null, он должен иметь тип возвращаемого значения V. Его список параметров (некоторого вида (A*)) должен быть эквивалентен внешнему списку параметров (A...).
• Если init является null, переменная цикла будет инициализирована её стандартным значением.
• Обработчик pred не должен быть null. Он должен иметь boolean в качестве типа возвращаемого значения. Его список параметров (либо пустой, либо вида (V A*)) должен быть эквивалентен внутреннему списку параметров.

Тип результата и сигнатура параметра полученного обработчика цикла определяются следующим образом:

• Тип результата обработчика цикла — это тип результата V тела.
• Типы параметров обработчика цикла — это типы (A...), из внешнего списка параметров.

Вот псевдокод для полученного обработчика цикла. В коде V/v представляют тип/значение единственной переменной цикла, а также тип результата цикла; и A/a, тип/значение аргумента, переданного в цикл.

 V init(A...);
 boolean pred(V, A...);
 V body(V, A...);
 V doWhileLoop(A... a...) {
   V v = init(a...);
   do {
     v = body(v, a...);
   } while (pred(v, a...));
   return v;
 }
 

Количество итераций определяется результатом оценки iterations обработчика. Счётчик итераций i — это дополнительная переменная цикла итераций типа int. Она будет инициализирована значением 0 и увеличиваться на 1 на каждой итерации.

Если body обработчик возвращает не-void тип V, то присутствует ведущая переменная цикла итераций этого типа. Эта переменная инициализируется с помощью необязательного init обработчика или по умолчанию для типа V, если этот обработчик null.

На каждой итерации переменные итерации передаются в вызов body обработчика. Не-void значение, возвращённое из тела (типа V) обновляет ведущую переменную итерации. Результатом выполнения цикла будет конечное значение V этой переменной (или void если переменной V нет).

Для обработчиков аргументов соблюдаются следующие правила:

• iterations обработчик не должен быть null, и должен возвращать тип int, который здесь упоминается как I в списках типов параметров.
• body обработчик не должен быть null; его тип должен иметь вид (V I A...)V, где V не-void, или иначе (I A...)void. (В случае void, мы присваиваем типу void имя V, и мы будем писать (V I A...)V, понимая, что тип void V тихо опускается из списка параметров, оставляя (I A...)V.)
• Список параметров (V I A...) тела вносит вклад в список типов, называемый внутренним списком параметров. Он будет ограничивать списки параметров других частей цикла.
• В качестве специального случая, если тело вносит вклад только в типы V и I, без дополнительных типов A, тогда внутренний список параметров дополняется типами аргументов A... iterations обработчика.
• Если типы переменных итераций (V I) удаляются из внутреннего списка параметров, полученный более короткий список (A...) называется внешним списком параметров.
• Тип возвращаемого значения тела V, если он не-void, определяет тип дополнительной переменной состояния цикла. Тело должно принимать в качестве параметра ведущее значение и возвращать значение этого типа V.
• Если init не-null, он должен иметь тип возвращаемого значения V. Его список параметров (некоторой формы (A*)) должен быть эффективно идентичен внешнему списку параметров (A...).
• Если init null, переменная цикла будет инициализирована своим значением по умолчанию по умолчанию.
• Список параметров iterations (некоторой формы (A*)) должен быть эффективно идентичен внешнему списку параметров (A...).

Тип возвращаемого значения и сигнатура параметров результирующего обработчика цикла определяются следующим образом:

• Тип возвращаемого значения обработчика цикла — это тип возвращаемого значения V тела.
• Типы параметров обработчика цикла — это типы (A...), из внешнего списка параметров.

Вот псевдокод для результирующего обработчика цикла. В коде V/v представляют тип/значение второй переменной цикла, а также тип возвращаемого значения цикла; а A.../a... представляют аргументы, переданные в цикл.

 int iterations(A...);
 V init(A...);
 V body(V, int, A...);
 V countedLoop(A... a...) {
   int end = iterations(a...);
   V v = init(a...);
   for (int i = 0; i < end; ++i) {
     v = body(v, i, a...);
   }
   return v;
 }
 

Счётчик цикла i — это переменная итерации цикла типа int. Обработчики start и end определяют начальное (включительно) и конечное (исключительно) значения счётчика цикла. Счётчик цикла будет инициализирован значением, возвращённым при оценке обработчика start, и будет выполняться до значения, возвращённого обработчиком end (исключительно), с шагом 1.

Если обработчик body возвращает тип, отличный от void типа V, присутствует также ведущая переменная итерации цикла этого типа. Эта переменная инициализируется с помощью необязательного обработчика init или по умолчанию типа V, если этот обработчик null.

В каждой итерации переменные итерации передаются в вызов обработчика body. Значение, отличное от void , возвращаемое телом (типа V) обновляет ведущую переменную итерации. Результатом выполнения обработчика цикла будет окончательное значение V этой переменной (или void, если переменная V отсутствует).

Для обработчиков аргументов соблюдаются следующие правила:

• Обработчики start и end не должны быть null, и оба должны возвращать общий тип int, обозначаемый здесь как I в списках типов параметров.
• Обработчик body не должен быть null; его тип должен иметь вид (V I A...)V, где V — не void, или же (I A...)void. (В случае void мы присваиваем тип void имени V, и мы будем писать (V I A...)V с пониманием того, что тип void V тихо удаляется из списка параметров, оставляя (I A...)V.)
• Список параметров (V I A...) тела вносит вклад в список типов, называемый внутренним списком параметров. Он будет ограничивать списки параметров других частей цикла.
• В качестве специального случая, если тело вносит вклад только в типы V и I, без дополнительных типов A, тогда внутренний список параметров расширяется типами аргументов A... обработчика end.
• Если типы переменных итерации (V I) удаляются из внутреннего списка параметров, полученный более короткий список (A...) называется внешним списком параметров.
• Тип возвращаемого значения тела V, если он не void, определяет тип дополнительной переменной состояния цикла. Тело должно принимать ведущий параметр и возвращать значение этого типа V.
• Если init не null, оно должно иметь тип возвращаемого значения V. Его список параметров (некоторого вида (A*)) должен быть эффективно идентичен внешнему списку параметров (A...).
• Если init равно null, переменная цикла будет инициализирована её значением по умолчанию.
• Список параметров start (некоторого вида (A*) ) должен быть эффективна идентичен внешнему списку параметров (A...).
• Аналогично, список параметров end должен быть эффективна идентичен внешнему списку параметров.

Тип результата и сигнатура параметров полученного обработчика цикла определяются следующим образом:

• Тип результата обработчика цикла — это тип результата V тела.
• Типы параметров обработчика цикла — это типы (A...), из внешнего списка параметров.

Вот псевдокод для полученного обработчика цикла. В коде V/v представляют тип / значение второй переменной цикла, а также тип результата цикла; а A.../a... представляют аргументы, передаваемые в цикл.

 int start(A...);
 int end(A...);
 V init(A...);
 V body(V, int, A...);
 V countedLoop(A... a...) {
   int e = end(a...);
   int s = start(a...);
   V v = init(a...);
   for (int i = s; i < e; ++i) {
     v = body(v, i, a...);
   }
   return v;
 }
 

Сам итератор будет определяться по результату вычисления iterator обработчика. Каждое полученное значение будет храниться в переменной цикла итерации типа T.

Если body обработчик возвращает тип, отличный от void типа V, присутствует также переменная цикла итерации ведущего типа. Эта переменная инициализируется с помощью необязательного init обработчика или значением по умолчанию типа V в случае, если этот обработчик null.

В каждой итерации переменные итерации передаются в вызов body обработчика. Значение, отличное от void типа V, возвращаемое из тела (блока), обновляет ведущую переменную итерации. Результатом выполнения обработчика цикла будет окончательное значение V переменной (или void если нет V переменной).

Для обработчиков аргументов выполняются следующие правила:

• Обработчик body не должен быть null; его тип должен быть в форме (V T A...)V, где V не является void, или же (T A...)void. (В случае void, мы присваиваем типу void имя V, и будем писать (V T A...)V с пониманием, что тип void типа V тихо удаляется из списка параметров, оставляя (T A...)V.)
• Список параметров (V T A...) тела добавляется в список типов, называемый внутренним списком параметров. Он будет ограничивать списки параметров других частей цикла.
• В качестве частного случая, если тело содержит только типы V и T, без дополнительных типов A, то внутренний список параметров дополняется типами аргументов A... обработчика iterator; если он null, добавляется единственный тип Iterable и формирует список A....
• Если типы переменной итерации (V T) исключаются из внутреннего списка параметров, полученный более короткий список (A...) называется внешним списком параметров.
• Тип возвращаемого значения тела V, если не void, определяет тип дополнительной переменной состояния цикла. Тело должно принимать ведущий параметр и возвращать значение этого типа V.
• Если init не null, оно должно иметь тип возвращаемого значения V. Его список параметров (некой формы (A*)) должен быть эквивалентен внешнему списку параметров (A...).
• Если init равно null, переменная цикла инициализируется своим значением по умолчанию по умолчанию.
• Если iterator обработчик не null, он должен иметь тип возвращаемого значения java.util.Iterator или подтип. Предполагается, что итератор, который он создаёт во время выполнения цикла, будет возвращать значения, которые могут быть преобразованы к типу T.
• Список параметров iterator не null (некой формы (A*)) должен быть эквивалентен внешнему списку параметров (A...).
• Если iterator равно null, по умолчанию устанавливается обработчик метода, который ведёт себя как Iterable.iterator(). В этом случае внутренний список параметров (V T A...) должен содержать по крайней мере один тип A, и параметр обработчика итератора корректируется для приёма ведущего типа A, как будто с помощью метода преобразования asType. Ведущий тип A должен быть Iterable или его подтипом. Эта операция преобразования, выполняемая во время создания цикла, не должна вызывать WrongMethodTypeException.

Тип T может быть либо примитивным, либо ссылочным. Так как тип Iterator<T> стирается в представлении обработчика метода до базового типа Iterator, комбинированный оператор iteratedLoop корректирует ведущий тип аргумента для body на Object, как будто с помощью метода преобразования asType. Поэтому, если во время выполнения цикла обнаружится итератор неправильного типа, могут возникнуть исключения во время выполнения в результате динамических преобразований, выполняемых методом MethodHandle.asType(MethodType).

Тип результата и сигнатура параметров результирующего обработчика цикла определяются следующим образом:

• Тип результата обработчика цикла — это тип результата V тела.
• Типы параметров обработчика цикла — это типы (A...), из внешнего списка параметров.

Вот псевдокод результирующего обработчика цикла. В коде V/v представляют тип/значение переменной цикла, а также тип результата цикла; T/t, типы элементов структуры, по которой цикл перебирает; а A.../a... представляют аргументы, передаваемые в цикл.

 Iterator<T> iterator(A...);  // defaults to Iterable::iterator
 V init(A...);
 V body(V,T,A...);
 V iteratedLoop(A... a...) {
   Iterator<T> it = iterator(a...);
   V v = init(a...);
   while (it.hasNext()) {
     T t = it.next();
     v = body(v, t, a...);
   }
   return v;
 }
 

Обработчик cleanup будет получать один или два дополнительных ведущих аргумента. Первый — исключение, выброшенное при выполнении обработчика target, или null, если исключение не было выброшено. Второй — результат выполнения обработчика target, или, если он выбросил исключение, значение по умолчанию нулевого или false типа требуемого типа. Второй аргумент отсутствует, если у обработчика target тип возвращаемого значения void. (Обратите внимание, что, за исключением преобразований типов аргументов, комбинаторы представляют void значения в списках параметров, опуская соответствующие парадоксальные аргументы, а не вставляя null или нулевые значения.)

Обработчики target и cleanup должны иметь одинаковые соответствующие типы аргументов и возвращаемых значений, за исключением того, что обработчик cleanup может опускать хвостовые аргументы. Также обработчик cleanup должен иметь один или два дополнительных ведущих параметра:

• тип Throwable, который будет содержать исключение, выброшенное обработчиком target (если таковое имеется); и
• параметр того же типа, что и тип возвращаемого значения как обработчика target, так и обработчика cleanup, который будет содержать результат выполнения обработчика target. Этот параметр отсутствует, если обработчик target возвращает void.

Псевдокод для результирующего адаптера выглядит следующим образом. В коде V представляет тип возвращаемого значения конструкции try/finally; A/a, типы и значения аргументов для результирующего обработчика, используемого обработкой очистки; и B/b, те же параметры, игнорируемые обработкой очистки.

 V target(A..., B...);
 V cleanup(Throwable, V, A...);
 V adapter(A... a, B... b) {
   V result = (zero value for V);
   Throwable throwable = null;
   try {
     result = target(a..., b...);
   } catch (Throwable t) {
     throwable = t;
     throw t;
   } finally {
     result = cleanup(throwable, result, a...);
   }
   return result;
 }
 

Обратите внимание, что сохранённые аргументы (a... в псевдокоде) не могут быть изменены выполнением целевого обработчика, и поэтому передаются неизменёнными от вызывающего обработчика к обработчику очистки, если он вызывается.

Целевой и обработчик очистки должны возвращать один и тот же тип, даже если обработчик очистки всегда выбрасывает исключение. Чтобы создать такой выбрасывающий обработчик очистки, используйте композицию логики очистки с throwException, чтобы создать обработчик метода нужного типа возвращаемого значения.

Обратите внимание, что tryFinally никогда не преобразует исключения в нормальные возвращаемые значения. В редких случаях, когда исключения необходимо преобразовать таким образом, сначала оберните целевой обработчик с помощью catchException(MethodHandle, Class, MethodHandle), чтобы перехватить исходящее исключение, а затем оберните с tryFinally.

Рекомендуется, чтобы тип первого параметра cleanup был объявлен как Throwable, а не как более узкий подтип. Это гарантирует, что cleanup всегда будет вызываться с любым исключением, которое выбросит target. Объявление более узкого типа может привести к выбросу ClassCastException обработчиком try-finally, если тип исключения, выброшенного target, не может быть приведён к типу первого параметра cleanup. Обратите внимание, что различные типы исключений VirtualMachineError, LinkageError, и RuntimeException могут, в принципе, быть выброшены практически любым Java-кодом, и блок finally, который перехватывает (скажем), только IOException, может замаскировать любые другие за ClassCastException.

Для значения селектора n, где n попадает в диапазон [0, N), и где N — количество обработчиков методов, обработчик метода типа переключатель таблиц вызовет n-й обработчик метода из списка обработчиков методов.

Для значения селектора, которое не попадает в диапазон [0, N), обработчик метода типа переключатель таблиц вызовет заданный обработчик метода по умолчанию.

Все обработчики методов, переданные в этот метод, должны иметь одинаковый тип, с дополнительным требованием, что ведущий параметр должен быть типа int. Ведущий параметр представляет собой селектор.

Любые хвостовые параметры, присутствующие в типе, также будут присутствовать в возвращаемом обработчике метода типа переключатель таблиц. Любые аргументы, назначенные этим параметрам, будут переданы вместе со значением селектора выбранному обработчику метода при его вызове.