public static ObjectMapper getObjectMapper()

in geronimo-openapi-impl/src/main/java/org/apache/geronimo/microprofile/openapi/impl/loader/yaml/Yaml.java [75:204]
125 lines of code
14 McCabe index (conditional complexity)

    public static ObjectMapper getObjectMapper() {
        final SimpleAbstractTypeResolver resolver = new SimpleAbstractTypeResolver();
        ApiBindings.get().forEach((k, v) -> resolver.addMapping(Class.class.cast(k), v));

        final SimpleModule module = new SimpleModule();
        module.setAbstractTypes(resolver);
        module.addDeserializer(Parameter.In.class, new JsonDeserializer<Parameter.In>() {
            @Override
            public Parameter.In deserialize(final JsonParser p, final DeserializationContext ctxt) {
                return Stream.of(Parameter.In.values()).filter(it -> {
                    try {
                        return it.name().equalsIgnoreCase(p.getValueAsString());
                    } catch (IOException e) {
                        throw new IllegalArgumentException(e);
                    }
                }).findFirst().orElseThrow(() -> new IllegalArgumentException("No matching In value"));
            }
        });
        module.addDeserializer(Schema.SchemaType.class, new JsonDeserializer<Schema.SchemaType>() {
            @Override
            public Schema.SchemaType deserialize(final JsonParser p, final DeserializationContext ctxt) {
                return Stream.of(Schema.SchemaType.values()).filter(it -> {
                    try {
                        return it.name().equalsIgnoreCase(p.getValueAsString());
                    } catch (IOException e) {
                        throw new IllegalArgumentException(e);
                    }
                }).findFirst().orElseThrow(() -> new IllegalArgumentException("No matching SchemaType value"));
            }
        });
        module.addDeserializer(SecurityScheme.Type.class, new JsonDeserializer<SecurityScheme.Type>() {
            @Override
            public SecurityScheme.Type deserialize(final JsonParser p, final DeserializationContext ctxt) {
                return Stream.of(SecurityScheme.Type.values()).filter(it -> {
                    try {
                        return it.name().equalsIgnoreCase(p.getValueAsString());
                    } catch (IOException e) {
                        throw new IllegalArgumentException(e);
                    }
                }).findFirst().orElseThrow(() -> new IllegalArgumentException("No matching SecurityScheme.Type value"));
            }
        });
        module.addSerializer(BigDecimal.class, new NumberSerializer(BigDecimal.class) {
            @Override
            public void serialize(final Number value, final JsonGenerator g,
                                  final SerializerProvider provider) throws IOException {
                if (BigDecimal.class.isInstance(value) && value.doubleValue() == value.longValue()) {
                    super.serialize(value.longValue(), g, provider);
                } else {
                    super.serialize(value, g, provider);
                }
            }
        });
        module.addSerializer(JsonString.class, new StdScalarSerializer<JsonString>(JsonString.class) {
            @Override
            public void serialize(final JsonString value, final JsonGenerator gen, final SerializerProvider provider) throws IOException {
                gen.writeString(value.getString());
            }
        });
        module.addSerializer(JsonNumber.class, new StdScalarSerializer<JsonNumber>(JsonNumber.class) {
            @Override
            public void serialize(final JsonNumber value, final JsonGenerator gen, final SerializerProvider provider) throws IOException {
                final double v = value.doubleValue();
                if (v == value.intValue()) {
                    gen.writeNumber(value.intValue());
                } else if (v == value.longValue()) {
                    gen.writeNumber(value.longValue());
                } else {
                    gen.writeNumber(v);
                }
            }
        });
        module.addSerializer(JsonValue.class, new StdScalarSerializer<JsonValue>(JsonValue.class) {
            @Override
            public void serialize(final JsonValue value, final JsonGenerator gen, final SerializerProvider provider) throws IOException {
                switch (value.getValueType()) {
                    case TRUE:
                    case FALSE:
                        gen.writeBoolean(value.equals(JsonValue.TRUE));
                        break;
                    case ARRAY:
                    case OBJECT:
                        gen.writeTree(new ObjectMapper().readTree(value.toString())); // not elegant but is it that common?
                        break;
                    default:
                }
            }
        });
        Stream.of(SecurityScheme.Type.class, SecurityScheme.In.class,
                Schema.SchemaType.class, Header.Style.class, Encoding.Style.class,
                Parameter.Style.class, Parameter.In.class)
              .forEach(it -> toStringSerializer(module, it));

        final ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
        mapper.registerModule(module);
        mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
            @Override
            public Boolean hasAnyGetter(final Annotated a) {
                return "getExtensions".equals(a.getName());
            }

            @Override
            protected boolean _isIgnorable(final Annotated a) {
                return super._isIgnorable(a) || a.getAnnotation(JsonbTransient.class) != null;
            }

            @Override
            public PropertyName findNameForSerialization(final Annotated a) {
                return ofNullable(a.getAnnotation(JsonbProperty.class))
                        .map(JsonbProperty::value)
                        .map(PropertyName::new)
                        .orElseGet(() -> super.findNameForSerialization(a));
            }

            @Override
            public PropertyName findNameForDeserialization(final Annotated a) {
                return ofNullable(a.getAnnotation(JsonbProperty.class))
                        .map(JsonbProperty::value)
                        .map(PropertyName::new)
                        .orElseGet(() -> super.findNameForDeserialization(a));
            }
        });
        mapper.setPropertyNamingStrategy(new PropertyNamingStrategy.PropertyNamingStrategyBase() {
            @Override
            public String translate(final String propertyName) {
                return "ref".equals(propertyName) ? "$ref" : propertyName;
            }
        });
        return mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_NULL);
    }