JsonbAccessMode.this.types.asClass(parameterizedType.getRawType())) ? toSet() : toList();
                                                    fn = (json, mp) -> json.asJsonArray().stream()
                                                                           .map(i -> mapItem(i, paramType, mp, jsonbDeserializer))
                                                                           .collect(collector);
                                                }
                                            }
                                        }
                                        if (fn == null) {
                                            fn = (json, mp) -> mapItem(json, targetType, mp, jsonbDeserializer);
                                        }
                                        impl.putIfAbsent(targetType, fn);
                                    }
                                    return fn.apply(value, parser);
                                }

                                private Object mapItem(final JsonValue jsonValue, final Type targetType,
                                                       final MappingParser parser, final JsonbDeserializer jsonbDeserializer) {
                                    return jsonbDeserializer.deserialize(
                                        JsonValueParserAdapter.createFor(jsonValue, parserFactory),
                                        new JohnzonDeserializationContext(parser, builderFactoryInstance, jsonProvider),
                                        targetType);
                                }

@Override
                                public Object fromJson(final JsonValue value, final Type targetType, final MappingParser parser) {
                                    final JsonbDeserializer jsonbDeserializer = instance.getValue();
                                    if (global || targetType == mappedType) { // fast test and matches most cases
                                        return mapItem(value, targetType, parser, jsonbDeserializer);
                                    }

                                    BiFunction<JsonValue, MappingParser, Object> fn = impl.get(targetType);
                                    if (fn == null) {
                                        if (value.getValueType() == JsonValue.ValueType.ARRAY) {
                                            if (ParameterizedType.class.isInstance(targetType)) {
                                                final ParameterizedType parameterizedType = ParameterizedType.class.cast(targetType);
                                                final Class<?> paramType = JsonbAccessMode.this.types.findParamType(parameterizedType, Collection.class);

} catch (final IllegalAccessException e) {
                    throw new IllegalStateException(e);
                } catch (final InvocationTargetException e) {
                    throw new IllegalStateException(e.getCause());
                }
            }

            @Override
            public Type[] getParameterTypes() {
                return types;
            }

            @Override
            public String[] getParameterNames() {
                return params;
            }

            @Override
            public Adapter<?, ?>[] getParameterConverter() {
                return converters;
            }

            @Override
            public Adapter<?, ?>[] getParameterItemConverter() {
                return itemConverters;
            }

            @Override
            public ObjectConverter.Codec<?>[] getObjectConverter() {
                return objectConverters;
            }
        };
    }

    private Object tryToCreateInstance(final Class<?> declaringClass) {