Examples with Format io.micronaut.core.convert.format.Format used on opensource projects

Example 1 with Format

use of io.micronaut.core.convert.format.Format in project micronaut-core by micronaut-projects.

the class QueryValueArgumentBinder method bind.

/**
 * Binds the argument with {@link QueryValue} annotation to the request
 * (Also binds without annotation if request body is not permitted).
 *
 * It will first try to convert to ConvertibleMultiValues type and if conversion is successful, add the
 * corresponding parameters to the request. (By default the conversion will be successful if the {@link Format}
 * annotation is present and has one of the supported values - see
 * {@link io.micronaut.core.convert.converters.MultiValuesConverterFactory} for specific converters). Otherwise
 * the uri template will be used to deduce what will be done with the request. For example, simple parameters are
 * converted to {@link String}
 */
@Override
public BindingResult<T> bind(ArgumentConversionContext<T> context, HttpRequest<?> source) {
    ConvertibleMultiValues<String> parameters = source.getParameters();
    Argument<T> argument = context.getArgument();
    AnnotationMetadata annotationMetadata = argument.getAnnotationMetadata();
    boolean hasAnnotation = annotationMetadata.hasAnnotation(QueryValue.class);
    HttpMethod httpMethod = source.getMethod();
    boolean permitsRequestBody = HttpMethod.permitsRequestBody(httpMethod);
    BindingResult<T> result;
    if (hasAnnotation || !permitsRequestBody) {
        // First try converting from the ConvertibleMultiValues type and if conversion is successful, return it.
        // Otherwise use the given uri template to deduce what to do with the variable
        Optional<T> multiValueConversion;
        if (annotationMetadata.hasAnnotation(Format.class)) {
            multiValueConversion = conversionService.convert(parameters, context);
        } else {
            multiValueConversion = Optional.empty();
        }
        if (multiValueConversion.isPresent()) {
            result = () -> multiValueConversion;
        } else {
            String parameterName = annotationMetadata.stringValue(QueryValue.class).orElse(argument.getName());
            // If we need to bind all request params to command object
            // checks if the variable is defined with modifier char *, eg. ?pojo*
            boolean bindAll = source.getAttribute(HttpAttributes.ROUTE_MATCH, UriMatchInfo.class).map(umi -> {
                UriMatchVariable uriMatchVariable = umi.getVariableMap().get(parameterName);
                return uriMatchVariable != null && uriMatchVariable.isExploded();
            }).orElse(false);
            if (bindAll) {
                Object value;
                // Only maps and POJOs will "bindAll", lists work like normal
                if (Iterable.class.isAssignableFrom(argument.getType())) {
                    value = doResolve(context, parameters, parameterName);
                    if (value == null) {
                        value = Collections.emptyList();
                    }
                } else {
                    value = parameters.asMap();
                }
                result = doConvert(value, context);
            } else {
                result = doBind(context, parameters, parameterName);
            }
        }
    } else {
        result = BindingResult.EMPTY;
    }
    return result;
}

Example 2 with Format

use of io.micronaut.core.convert.format.Format in project micronaut-core by micronaut-projects.

the class TimeConverterRegistrar method register.

@Override
public void register(ConversionService<?> conversionService) {
    final BiFunction<CharSequence, ConversionContext, Optional<Duration>> durationConverter = (object, context) -> {
        String value = object.toString().trim();
        if (value.startsWith("P")) {
            try {
                return Optional.of(Duration.parse(value));
            } catch (DateTimeParseException e) {
                context.reject(value, e);
                return Optional.empty();
            }
        } else {
            Matcher matcher = DURATION_MATCHER.matcher(value);
            if (matcher.find()) {
                String amount = matcher.group(1);
                final String g2 = matcher.group(2);
                char type = g2.charAt(0);
                try {
                    switch(type) {
                        case 's':
                            return Optional.of(Duration.ofSeconds(Integer.parseInt(amount)));
                        case 'm':
                            String ms = matcher.group(MILLIS);
                            if (StringUtils.hasText(ms)) {
                                return Optional.of(Duration.ofMillis(Integer.parseInt(amount)));
                            } else {
                                return Optional.of(Duration.ofMinutes(Integer.parseInt(amount)));
                            }
                        case 'h':
                            return Optional.of(Duration.ofHours(Integer.parseInt(amount)));
                        case 'd':
                            return Optional.of(Duration.ofDays(Integer.parseInt(amount)));
                        default:
                            final String seq = g2 + matcher.group(3);
                            switch(seq) {
                                case "ns":
                                    return Optional.of(Duration.ofNanos(Integer.parseInt(amount)));
                                default:
                                    context.reject(value, new DateTimeParseException("Unparseable date format (" + value + "). Should either be a ISO-8601 duration or a round number followed by the unit type", value, 0));
                                    return Optional.empty();
                            }
                    }
                } catch (NumberFormatException e) {
                    context.reject(value, e);
                }
            }
        }
        return Optional.empty();
    };
    // CharSequence -> Duration
    conversionService.addConverter(CharSequence.class, Duration.class, (object, targetType, context) -> durationConverter.apply(object, context));
    // CharSequence -> TemporalAmount
    conversionService.addConverter(CharSequence.class, TemporalAmount.class, (object, targetType, context) -> durationConverter.apply(object, context).map(TemporalAmount.class::cast));
    // CharSequence -> LocalDateTime
    conversionService.addConverter(CharSequence.class, LocalDateTime.class, (object, targetType, context) -> {
        try {
            DateTimeFormatter formatter = resolveFormatter(context);
            LocalDateTime result = LocalDateTime.parse(object, formatter);
            return Optional.of(result);
        } catch (DateTimeParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // TemporalAccessor - CharSequence
    final TypeConverter<TemporalAccessor, CharSequence> temporalConverter = (object, targetType, context) -> {
        try {
            DateTimeFormatter formatter = resolveFormatter(context);
            return Optional.of(formatter.format(object));
        } catch (DateTimeParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    };
    conversionService.addConverter(TemporalAccessor.class, CharSequence.class, temporalConverter);
    // CharSequence -> LocalDate
    conversionService.addConverter(CharSequence.class, LocalDate.class, (object, targetType, context) -> {
        try {
            DateTimeFormatter formatter = resolveFormatter(context);
            LocalDate result = LocalDate.parse(object, formatter);
            return Optional.of(result);
        } catch (DateTimeParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // CharSequence -> ZonedDateTime
    conversionService.addConverter(CharSequence.class, ZonedDateTime.class, (object, targetType, context) -> {
        try {
            DateTimeFormatter formatter = resolveFormatter(context);
            ZonedDateTime result = ZonedDateTime.parse(object, formatter);
            return Optional.of(result);
        } catch (DateTimeParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // CharSequence -> OffsetDateTime
    conversionService.addConverter(CharSequence.class, OffsetDateTime.class, (object, targetType, context) -> {
        try {
            DateTimeFormatter formatter = resolveFormatter(context);
            OffsetDateTime result = OffsetDateTime.parse(object, formatter);
            return Optional.of(result);
        } catch (DateTimeParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
}

Example 3 with Format

use of io.micronaut.core.convert.format.Format in project micronaut-core by micronaut-projects.

the class DefaultConversionService method resolveFormat.

private SimpleDateFormat resolveFormat(ConversionContext context) {
    AnnotationMetadata annotationMetadata = context.getAnnotationMetadata();
    Optional<String> format = annotationMetadata.stringValue(Format.class);
    return format.map(pattern -> new SimpleDateFormat(pattern, context.getLocale())).orElseGet(() -> new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", context.getLocale()));
}

Example 4 with Format

use of io.micronaut.core.convert.format.Format in project micronaut-core by micronaut-projects.

the class DefaultConversionService method registerDefaultConverters.

/**
 * Default Converters.
 */
@SuppressWarnings({ "OptionalIsPresent", "unchecked" })
protected void registerDefaultConverters() {
    // primitive array to wrapper array
    @SuppressWarnings("rawtypes") Function primitiveArrayToWrapperArray = ArrayUtils::toWrapperArray;
    addConverter(double[].class, Double[].class, primitiveArrayToWrapperArray);
    addConverter(byte[].class, Byte[].class, primitiveArrayToWrapperArray);
    addConverter(short[].class, Short[].class, primitiveArrayToWrapperArray);
    addConverter(boolean[].class, Boolean[].class, primitiveArrayToWrapperArray);
    addConverter(int[].class, Integer[].class, primitiveArrayToWrapperArray);
    addConverter(float[].class, Float[].class, primitiveArrayToWrapperArray);
    addConverter(double[].class, Double[].class, primitiveArrayToWrapperArray);
    addConverter(char[].class, Character[].class, primitiveArrayToWrapperArray);
    // wrapper to primitive array converters
    Function<Object[], Object> wrapperArrayToPrimitiveArray = ArrayUtils::toPrimitiveArray;
    // noinspection rawtypes
    addConverter(Double[].class, double[].class, (Function) wrapperArrayToPrimitiveArray);
    // noinspection rawtypes
    addConverter(Integer[].class, int[].class, (Function) wrapperArrayToPrimitiveArray);
    // Object -> List
    addConverter(Object.class, List.class, (object, targetType, context) -> {
        Optional<Argument<?>> firstTypeVariable = context.getFirstTypeVariable();
        Argument<?> argument = firstTypeVariable.orElse(Argument.OBJECT_ARGUMENT);
        Optional converted = DefaultConversionService.this.convert(object, context.with(argument));
        if (converted.isPresent()) {
            return Optional.of(Collections.singletonList(converted.get()));
        }
        return Optional.empty();
    });
    // String -> Class
    addConverter(CharSequence.class, Class.class, (object, targetType, context) -> {
        ClassLoader classLoader = targetType.getClassLoader();
        if (classLoader == null) {
            classLoader = DefaultConversionService.class.getClassLoader();
        }
        return ClassUtils.forName(object.toString(), classLoader);
    });
    // AnnotationClassValue -> Class
    addConverter(AnnotationClassValue.class, Class.class, (object, targetType, context) -> object.getType());
    addConverter(AnnotationClassValue.class, Object.class, (object, targetType, context) -> {
        if (targetType.equals(Class.class)) {
            return object.getType();
        } else {
            if (CharSequence.class.isAssignableFrom(targetType)) {
                return Optional.of(object.getName());
            } else {
                Optional i = object.getInstance();
                if (i.isPresent() && targetType.isInstance(i.get())) {
                    return i;
                }
                return Optional.empty();
            }
        }
    });
    addConverter(AnnotationClassValue[].class, Class.class, (object, targetType, context) -> {
        if (object.length > 0) {
            final AnnotationClassValue o = object[0];
            if (o != null) {
                return o.getType();
            }
        }
        return Optional.empty();
    });
    addConverter(AnnotationClassValue[].class, Class[].class, (object, targetType, context) -> {
        List<Class> classes = new ArrayList<>(object.length);
        for (AnnotationClassValue<?> annotationClassValue : object) {
            if (annotationClassValue != null) {
                final Optional<? extends Class<?>> type = annotationClassValue.getType();
                if (type.isPresent()) {
                    classes.add(type.get());
                }
            }
        }
        return Optional.of(classes.toArray(new Class[0]));
    });
    // URI -> URL
    addConverter(URI.class, URL.class, uri -> {
        try {
            return uri.toURL();
        } catch (MalformedURLException e) {
            return null;
        }
    });
    // InputStream -> String
    addConverter(InputStream.class, String.class, (object, targetType, context) -> {
        BufferedReader reader = new BufferedReader(new InputStreamReader(object));
        try {
            return Optional.of(IOUtils.readText(reader));
        } catch (IOException e) {
            context.reject(e);
            return Optional.empty();
        }
    });
    // String -> byte[]
    addConverter(CharSequence.class, byte[].class, (object, targetType, context) -> Optional.of(object.toString().getBytes(context.getCharset())));
    addConverter(Integer.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Integer.BYTES).putInt(object).array()));
    addConverter(Character.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Integer.BYTES).putChar(object).array()));
    addConverter(Long.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Long.BYTES).putLong(object).array()));
    addConverter(Short.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Short.BYTES).putShort(object).array()));
    addConverter(Double.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Double.BYTES).putDouble(object).array()));
    addConverter(Float.class, byte[].class, (object, targetType, context) -> Optional.of(ByteBuffer.allocate(Float.BYTES).putFloat(object).array()));
    // InputStream -> Number
    addConverter(InputStream.class, Number.class, (object, targetType, context) -> {
        Optional<String> convert = DefaultConversionService.this.convert(object, String.class, context);
        if (convert.isPresent()) {
            return convert.flatMap(val -> DefaultConversionService.this.convert(val, targetType, context));
        }
        return Optional.empty();
    });
    // Reader -> String
    addConverter(Reader.class, String.class, (object, targetType, context) -> {
        BufferedReader reader = object instanceof BufferedReader ? (BufferedReader) object : new BufferedReader(object);
        try {
            return Optional.of(IOUtils.readText(reader));
        } catch (IOException e) {
            context.reject(e);
            return Optional.empty();
        }
    });
    // String -> File
    addConverter(CharSequence.class, File.class, (object, targetType, context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        return Optional.of(new File(object.toString()));
    });
    // String[] -> Enum
    addConverter(String[].class, Enum.class, (object, targetType, context) -> {
        if (object == null || object.length == 0) {
            return Optional.empty();
        }
        StringJoiner joiner = new StringJoiner("");
        for (String string : object) {
            joiner.add(string);
        }
        final String val = joiner.toString();
        return convert(val, targetType, context);
    });
    addConverter(String[].class, CharSequence.class, (object, targetType, context) -> {
        if (object == null || object.length == 0) {
            return Optional.empty();
        }
        StringJoiner joiner = new StringJoiner("");
        for (String string : object) {
            joiner.add(string);
        }
        return convert(joiner.toString(), targetType, context);
    });
    // CharSequence -> Long for bytes
    addConverter(CharSequence.class, Number.class, new ReadableBytesTypeConverter());
    // CharSequence -> Date
    addConverter(CharSequence.class, Date.class, (object, targetType, context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            SimpleDateFormat format = resolveFormat(context);
            return Optional.of(format.parse(object.toString()));
        } catch (ParseException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // Date -> CharSequence
    addConverter(Date.class, CharSequence.class, (object, targetType, context) -> {
        SimpleDateFormat format = resolveFormat(context);
        return Optional.of(format.format(object));
    });
    // String -> Path
    addConverter(CharSequence.class, Path.class, (object, targetType, context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            return Optional.ofNullable(Paths.get(object.toString()));
        } catch (Exception e) {
            context.reject("Invalid path [" + object + " ]: " + e.getMessage(), e);
            return Optional.empty();
        }
    });
    // String -> Integer
    addConverter(CharSequence.class, Integer.class, (CharSequence object, Class<Integer> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Integer converted = Integer.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> BigInteger
    addConverter(CharSequence.class, BigInteger.class, (CharSequence object, Class<BigInteger> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            BigInteger converted = new BigInteger(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Float
    addConverter(CharSequence.class, Float.class, (CharSequence object, Class<Float> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Float converted = Float.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Double
    addConverter(CharSequence.class, Double.class, (CharSequence object, Class<Double> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Double converted = Double.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Long
    addConverter(CharSequence.class, Long.class, (CharSequence object, Class<Long> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Long converted = Long.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Short
    addConverter(CharSequence.class, Short.class, (CharSequence object, Class<Short> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Short converted = Short.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Byte
    addConverter(CharSequence.class, Byte.class, (CharSequence object, Class<Byte> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            Byte converted = Byte.valueOf(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> BigDecimal
    addConverter(CharSequence.class, BigDecimal.class, (CharSequence object, Class<BigDecimal> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            BigDecimal converted = new BigDecimal(object.toString());
            return Optional.of(converted);
        } catch (NumberFormatException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Boolean
    addConverter(CharSequence.class, Boolean.class, (CharSequence object, Class<Boolean> targetType, ConversionContext context) -> {
        String booleanString = object.toString().toLowerCase(Locale.ENGLISH);
        switch(booleanString) {
            case "yes":
            case "y":
            case "on":
            case "true":
                return Optional.of(Boolean.TRUE);
            default:
                return Optional.of(Boolean.FALSE);
        }
    });
    // String -> URL
    addConverter(CharSequence.class, URL.class, (CharSequence object, Class<URL> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            String spec = object.toString();
            if (!spec.contains("://")) {
                spec = "http://" + spec;
            }
            return Optional.of(new URL(spec));
        } catch (MalformedURLException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> URI
    addConverter(CharSequence.class, URI.class, (CharSequence object, Class<URI> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            return Optional.of(new URI(object.toString()));
        } catch (URISyntaxException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Locale
    addConverter(CharSequence.class, Locale.class, object -> StringUtils.parseLocale(object.toString()));
    // String -> UUID
    addConverter(CharSequence.class, UUID.class, (CharSequence object, Class<UUID> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            return Optional.of(UUID.fromString(object.toString()));
        } catch (IllegalArgumentException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Currency
    addConverter(CharSequence.class, Currency.class, (CharSequence object, Class<Currency> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            return Optional.of(Currency.getInstance(object.toString()));
        } catch (IllegalArgumentException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> TimeZone
    addConverter(CharSequence.class, TimeZone.class, (CharSequence object, Class<TimeZone> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        return Optional.of(TimeZone.getTimeZone(object.toString()));
    });
    // String -> Charset
    addConverter(CharSequence.class, Charset.class, (CharSequence object, Class<Charset> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        try {
            return Optional.of(Charset.forName(object.toString()));
        } catch (IllegalCharsetNameException | UnsupportedCharsetException e) {
            context.reject(object, e);
            return Optional.empty();
        }
    });
    // String -> Character
    addConverter(CharSequence.class, Character.class, (CharSequence object, Class<Character> targetType, ConversionContext context) -> {
        String str = object.toString();
        if (str.length() == 1) {
            return Optional.of(str.charAt(0));
        } else {
            return Optional.empty();
        }
    });
    // String -> Array
    addConverter(CharSequence.class, Object[].class, (CharSequence object, Class<Object[]> targetType, ConversionContext context) -> {
        if (object instanceof AnnotationClassValue && targetType.equals(AnnotationClassValue[].class)) {
            AnnotationClassValue[] array = new AnnotationClassValue[1];
            array[0] = (AnnotationClassValue) object;
            return Optional.of(array);
        }
        String str = object.toString();
        String[] strings = str.split(",");
        Class<?> componentType = ReflectionUtils.getWrapperType(targetType.getComponentType());
        Object newArray = Array.newInstance(componentType, strings.length);
        for (int i = 0; i < strings.length; i++) {
            String string = strings[i];
            Optional<?> converted = convert(string, componentType);
            if (converted.isPresent()) {
                Array.set(newArray, i, converted.get());
            }
        }
        return Optional.of((Object[]) newArray);
    });
    // String -> Int Array
    addConverter(CharSequence.class, int[].class, (CharSequence object, Class<int[]> targetType, ConversionContext context) -> {
        String str = object.toString();
        String[] strings = str.split(",");
        Object newArray = Array.newInstance(int.class, strings.length);
        for (int i = 0; i < strings.length; i++) {
            String string = strings[i];
            Optional<?> converted = convert(string, int.class);
            if (converted.isPresent()) {
                Array.set(newArray, i, converted.get());
            }
        }
        return Optional.of((int[]) newArray);
    });
    // String -> Char Array
    addConverter(String.class, char[].class, (String object, Class<char[]> targetType, ConversionContext context) -> Optional.of(object.toCharArray()));
    // Object[] -> String[]
    addConverter(Object[].class, String[].class, (Object[] object, Class<String[]> targetType, ConversionContext context) -> {
        String[] strings = new String[object.length];
        for (int i = 0; i < object.length; i++) {
            Object o = object[i];
            if (o != null) {
                strings[i] = o.toString();
            }
        }
        return Optional.of(strings);
    });
    // String -> Enum
    addConverter(CharSequence.class, Enum.class, (CharSequence object, Class<Enum> targetType, ConversionContext context) -> {
        if (StringUtils.isEmpty(object)) {
            return Optional.empty();
        }
        String stringValue = object.toString();
        try {
            Enum val = Enum.valueOf(targetType, stringValue);
            return Optional.of(val);
        } catch (IllegalArgumentException e) {
            try {
                Enum val = Enum.valueOf(targetType, NameUtils.environmentName(stringValue));
                return Optional.of(val);
            } catch (Exception e1) {
                Optional<Enum> valOpt = Arrays.stream(targetType.getEnumConstants()).filter(val -> val.toString().equals(stringValue)).findFirst();
                if (valOpt.isPresent()) {
                    return valOpt;
                }
                context.reject(object, e);
                return Optional.empty();
            }
        }
    });
    // Object -> String
    addConverter(Object.class, String.class, (Object object, Class<String> targetType, ConversionContext context) -> Optional.of(object.toString()));
    // Number -> Number
    addConverter(Number.class, Number.class, (Number object, Class<Number> targetType, ConversionContext context) -> {
        Class targetNumberType = ReflectionUtils.getWrapperType(targetType);
        if (targetNumberType.isInstance(object)) {
            return Optional.of(object);
        }
        if (targetNumberType == Integer.class) {
            return Optional.of(object.intValue());
        }
        if (targetNumberType == Long.class) {
            return Optional.of(object.longValue());
        }
        if (targetNumberType == Short.class) {
            return Optional.of(object.shortValue());
        }
        if (targetNumberType == Byte.class) {
            return Optional.of(object.byteValue());
        }
        if (targetNumberType == Float.class) {
            return Optional.of(object.floatValue());
        }
        if (targetNumberType == Double.class) {
            return Optional.of(object.doubleValue());
        }
        if (targetNumberType == BigInteger.class) {
            if (object instanceof BigDecimal) {
                return Optional.of(((BigDecimal) object).toBigInteger());
            }
            return Optional.of(BigInteger.valueOf(object.longValue()));
        }
        if (targetNumberType == BigDecimal.class) {
            return Optional.of(new BigDecimal(object.toString()));
        }
        return Optional.empty();
    });
    // String -> List/Iterable
    addConverter(CharSequence.class, Iterable.class, (CharSequence object, Class<Iterable> targetType, ConversionContext context) -> {
        Optional<Argument<?>> typeVariable = context.getFirstTypeVariable();
        Argument<?> componentType = typeVariable.orElse(Argument.OBJECT_ARGUMENT);
        ConversionContext newContext = context.with(componentType);
        Class<?> targetComponentType = ReflectionUtils.getWrapperType(componentType.getType());
        String[] strings = object.toString().split(",");
        List list = new ArrayList();
        for (String string : strings) {
            Optional converted = convert(string, targetComponentType, newContext);
            if (converted.isPresent()) {
                list.add(converted.get());
            }
        }
        return CollectionUtils.convertCollection((Class) targetType, list);
    });
    TypeConverter<Object, Optional> objectToOptionalConverter = (object, targetType, context) -> {
        Optional<Argument<?>> typeVariable = context.getFirstTypeVariable();
        Argument<?> componentType = typeVariable.orElse(Argument.OBJECT_ARGUMENT);
        Class<?> targetComponentType = ReflectionUtils.getWrapperType(componentType.getType());
        ConversionContext newContext = context.with(componentType).with(context.getAnnotationMetadata());
        Optional converted = convert(object, targetComponentType, newContext);
        if (converted.isPresent()) {
            return Optional.of(converted);
        }
        return Optional.of(Optional.empty());
    };
    // Optional handling
    addConverter(Object.class, Optional.class, objectToOptionalConverter);
    addConverter(Object.class, OptionalInt.class, (object, targetType, context) -> {
        Optional<Integer> converted = convert(object, Integer.class, context);
        return converted.map(integer -> Optional.of(OptionalInt.of(integer))).orElseGet(() -> Optional.of(OptionalInt.empty()));
    });
    addConverter(Object.class, OptionalLong.class, (object, targetType, context) -> {
        Optional<Long> converted = convert(object, Long.class, context);
        return converted.map(longValue -> Optional.of(OptionalLong.of(longValue))).orElseGet(() -> Optional.of(OptionalLong.empty()));
    });
    // Iterable -> String
    addConverter(Iterable.class, String.class, (object, targetType, context) -> Optional.of(CollectionUtils.toString(object)));
    // Iterable -> Object
    addConverter(Iterable.class, Object.class, (object, targetType, context) -> {
        if (Optional.class.isAssignableFrom(targetType)) {
            return objectToOptionalConverter.convert(object, (Class) targetType, context);
        }
        Iterator<?> i = object.iterator();
        int count = 0;
        Object value = null;
        while (i.hasNext()) {
            if (count > 0) {
                context.reject(object, new ConversionErrorException(Argument.of(targetType), new IllegalArgumentException("Cannot convert an iterable with more than 1 value to a non collection object")));
                return Optional.empty();
            }
            count++;
            value = i.next();
        }
        return convert(value, targetType, context);
    });
    // Iterable -> Iterable (inner type conversion)
    addConverter(Iterable.class, Iterable.class, (object, targetType, context) -> {
        if (ConvertibleValues.class.isAssignableFrom(targetType)) {
            if (object instanceof ConvertibleValues) {
                return Optional.of(object);
            }
            return Optional.empty();
        }
        Optional<Argument<?>> typeVariable = context.getFirstTypeVariable();
        Argument<?> componentType = typeVariable.orElse(Argument.OBJECT_ARGUMENT);
        Class<?> targetComponentType = ReflectionUtils.getWrapperType(componentType.getType());
        if (targetType.isInstance(object) && targetComponentType == Object.class) {
            return Optional.of(object);
        }
        List list = new ArrayList();
        ConversionContext newContext = context.with(componentType);
        for (Object o : object) {
            Optional<?> converted = convert(o, targetComponentType, newContext);
            if (converted.isPresent()) {
                list.add(converted.get());
            }
        }
        return CollectionUtils.convertCollection((Class) targetType, list);
    });
    // Object[] -> String
    addConverter(Object[].class, String.class, (object, targetType, context) -> Optional.of(ArrayUtils.toString(object)));
    // Object[] -> Object[] (inner type conversion)
    addConverter(Object[].class, Object[].class, (object, targetType, context) -> {
        Class<?> targetComponentType = targetType.getComponentType();
        List results = new ArrayList();
        for (Object o : object) {
            Optional<?> converted = convert(o, targetComponentType, context);
            if (converted.isPresent()) {
                results.add(converted.get());
            }
        }
        return Optional.of(results.toArray((Object[]) Array.newInstance(targetComponentType, results.size())));
    });
    // Iterable -> Object[]
    addConverter(Iterable.class, Object[].class, (object, targetType, context) -> {
        Class<?> targetComponentType = targetType.getComponentType();
        List results = new ArrayList();
        for (Object o : object) {
            Optional<?> converted = convert(o, targetComponentType, context);
            if (converted.isPresent()) {
                results.add(converted.get());
            }
        }
        return Optional.of(results.toArray((Object[]) Array.newInstance(targetComponentType, results.size())));
    });
    addConverter(Object[].class, Iterable.class, (object, targetType, context) -> convert(Arrays.asList(object), targetType, context));
    addConverter(Object.class, Object[].class, (object, targetType, context) -> {
        Class<?> targetComponentType = targetType.getComponentType();
        Optional<?> converted = convert(object, targetComponentType);
        if (converted.isPresent()) {
            Object[] result = (Object[]) Array.newInstance(targetComponentType, 1);
            result[0] = converted.get();
            return Optional.of(result);
        }
        return Optional.empty();
    });
    // Map -> Map (inner type conversion)
    addConverter(Map.class, Map.class, (object, targetType, context) -> {
        Argument<?> keyArgument = context.getTypeVariable("K").orElse(Argument.of(String.class, "K"));
        boolean isProperties = targetType.equals(Properties.class);
        Argument<?> valArgument = context.getTypeVariable("V").orElseGet(() -> {
            if (isProperties) {
                return Argument.of(String.class, "V");
            }
            return Argument.of(Object.class, "V");
        });
        Class keyType = keyArgument.getType();
        Class valueType = valArgument.getType();
        ConversionContext keyContext = context.with(keyArgument);
        ConversionContext valContext = context.with(valArgument);
        Map newMap = isProperties ? new Properties() : new LinkedHashMap();
        for (Object o : object.entrySet()) {
            Map.Entry entry = (Map.Entry) o;
            Object key = entry.getKey();
            Object value = entry.getValue();
            if (!keyType.isInstance(key)) {
                Optional convertedKey = convert(key, keyType, keyContext);
                if (convertedKey.isPresent()) {
                    key = convertedKey.get();
                } else {
                    continue;
                }
            }
            if (!valueType.isInstance(value) || value instanceof Map || value instanceof Collection) {
                Optional converted = convert(value, valueType, valContext);
                if (converted.isPresent()) {
                    value = converted.get();
                } else {
                    continue;
                }
            }
            newMap.put(key, value);
        }
        return Optional.of(newMap);
    });
    addConverter(Map.class, ConvertibleValues.class, (object, targetType, context) -> Optional.of(new ConvertibleValuesMap<Object>(object)));
    // Micronaut ByteBuffer -> byte for streamed results from HTTP clients
    addConverter(io.micronaut.core.io.buffer.ByteBuffer.class, byte[].class, (object, targetType, context) -> {
        byte[] result = object.toByteArray();
        ((ReferenceCounted) object).release();
        return Optional.of(result);
    });
    // ConvertibleMultiValues -> [?]
    addConverter(io.micronaut.core.convert.value.ConvertibleMultiValues.class, Iterable.class, new MultiValuesConverterFactory.MultiValuesToIterableConverter(this));
    addConverter(io.micronaut.core.convert.value.ConvertibleMultiValues.class, Map.class, new MultiValuesConverterFactory.MultiValuesToMapConverter(this));
    addConverter(io.micronaut.core.convert.value.ConvertibleMultiValues.class, Object.class, new MultiValuesConverterFactory.MultiValuesToObjectConverter(this));
    // [?] -> ConvertibleMultiValues
    addConverter(Iterable.class, io.micronaut.core.convert.value.ConvertibleMultiValues.class, new MultiValuesConverterFactory.IterableToMultiValuesConverter(this));
    addConverter(Map.class, io.micronaut.core.convert.value.ConvertibleMultiValues.class, new MultiValuesConverterFactory.MapToMultiValuesConverter(this));
    addConverter(Object.class, io.micronaut.core.convert.value.ConvertibleMultiValues.class, new MultiValuesConverterFactory.ObjectToMultiValuesConverter(this));
}