Java Examples for com.fasterxml.jackson.databind.JsonDeserializer

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
    if (deserializer instanceof BeanDeserializer) {
        BeanDeserializer beanDeserializer = (BeanDeserializer) deserializer;
        return new EntityBeanDeserializer(beanDeserializer, deserializer.getObjectIdReader());
    }
    return super.modifyDeserializer(config, beanDesc, deserializer);
}

@Override
@SuppressWarnings("unchecked")
public MessageParams deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonDeserializer<Object> mapDeser = ctxt.findRootValueDeserializer(MapType.construct(LinkedHashMap.class, SimpleType.construct(String.class), SimpleType.construct(Object.class)));
    Map<String, Object> m = (Map<String, Object>) mapDeser.deserialize(jp, ctxt);
    return new MessageParams(ImmutableMap.copyOf(m));
}

@Override
public Pair<?, ?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonDeserializer<Object> deserK = ctxt.findContextualValueDeserializer(type.containedType(0), null);
    JsonDeserializer<Object> deserV = ctxt.findContextualValueDeserializer(type.containedType(1), null);
    Object k = null, v = null;
    if (!(jp.hasCurrentToken() && jp.getCurrentToken() == JsonToken.START_OBJECT)) {
        expect(jp.nextToken(), JsonToken.START_OBJECT, jp, ctxt);
    }
    while (true) {
        JsonToken nextToken = jp.nextToken();
        if (nextToken == JsonToken.END_OBJECT) {
            break;
        }
        expect(nextToken, JsonToken.FIELD_NAME, jp, ctxt);
        jp.nextToken();
        if (KEY_NAMES.contains(jp.getCurrentName())) {
            if (k != null) {
                throw new JsonMappingException("Multiple key properties for Pair", jp.getCurrentLocation());
            }
            k = deserK.deserialize(jp, ctxt);
        } else if (VALUE_NAMES.contains(jp.getCurrentName())) {
            if (v != null) {
                throw new JsonMappingException("Multiple value properties for Pair", jp.getCurrentLocation());
            }
            v = deserV.deserialize(jp, ctxt);
        } else {
            if (!ctxt.handleUnknownProperty(jp, this, Map.Entry.class, jp.getCurrentName())) {
                throw new JsonMappingException("Unknown Pair property " + jp.getCurrentName(), jp.getCurrentLocation());
            }
        }
    }
    return Pair.of(k, v);
}

@Override
public Class<? extends JsonDeserializer<?>> findDeserializer(Annotated a) {
    Class clazz = a.getRawType();
    if (Collection.class.isAssignableFrom(clazz)) {
        // Collection should be handled in findContentDeserializer(Annotated a)
        return null;
    }
    Class<? extends JsonDeserializer<?>> deserializer = findDeserializerToUse(a);
    if (deserializer != null) {
        return deserializer;
    }
    return super.findDeserializer(a);
}

/**
     * Factory method for constructing a map where all entries use given
     * prefix
     */
public BeanPropertyMap renameAll(NameTransformer transformer) {
    if (transformer == null || (transformer == NameTransformer.NOP)) {
        return this;
    }
    Iterator<SettableBeanProperty> it = iterator();
    ArrayList<SettableBeanProperty> newProps = new ArrayList<SettableBeanProperty>();
    while (it.hasNext()) {
        SettableBeanProperty prop = it.next();
        String newName = transformer.transform(prop.getName());
        prop = prop.withName(newName);
        JsonDeserializer<?> deser = prop.getValueDeserializer();
        if (deser != null) {
            @SuppressWarnings("unchecked") JsonDeserializer<Object> newDeser = (JsonDeserializer<Object>) deser.unwrappingDeserializer(transformer);
            if (newDeser != deser) {
                prop = prop.withValueDeserializer(newDeser);
            }
        }
        newProps.add(prop);
    }
    // should we try to re-index? Ordering probably changed but called probably doesn't want changes...
    return new BeanPropertyMap(newProps);
}

/*
    /**********************************************************
    /* Initialization
    /**********************************************************
     */
/**
     * We need to implement this method to properly find things to delegate
     * to: it can not be done earlier since delegated deserializers almost
     * certainly require access to this instance (at least "List" and "Map" ones)
     */
@SuppressWarnings("unchecked")
@Override
public void resolve(DeserializationContext ctxt) throws JsonMappingException {
    JavaType obType = ctxt.constructType(Object.class);
    JavaType stringType = ctxt.constructType(String.class);
    TypeFactory tf = ctxt.getTypeFactory();
    // So: first find possible custom instances
    if (_listType == null) {
        _listDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructCollectionType(List.class, obType)));
    } else {
        // NOTE: if non-default List type, always consider to be non-standard deser
        _listDeserializer = _findCustomDeser(ctxt, _listType);
    }
    if (_mapType == null) {
        _mapDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructMapType(Map.class, stringType, obType)));
    } else {
        // NOTE: if non-default Map type, always consider to be non-standard deser
        _mapDeserializer = _findCustomDeser(ctxt, _mapType);
    }
    _stringDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, stringType));
    _numberDeserializer = _clearIfStdImpl(_findCustomDeser(ctxt, tf.constructType(Number.class)));
    // and then do bogus contextualization, in case custom ones need to resolve dependencies of
    // their own
    JavaType unknown = TypeFactory.unknownType();
    _mapDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_mapDeserializer, null, unknown);
    _listDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_listDeserializer, null, unknown);
    _stringDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_stringDeserializer, null, unknown);
    _numberDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_numberDeserializer, null, unknown);
}

/**
     * We need to use this method to properly handle possible contextual variants of key and value
     * deserializers, as well as type deserializers.
     */
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    KeyDeserializer kd = keyDeserializer;
    if (kd == null) {
        kd = ctxt.findKeyDeserializer(type.getKeyType(), property);
    }
    JsonDeserializer<?> ed = elementDeserializer;
    if (ed == null) {
        ed = ctxt.findContextualValueDeserializer(type.getContentType(), property);
    }
    // Type deserializer is slightly different; must be passed, but needs to become contextual:
    TypeDeserializer etd = elementTypeDeserializer;
    if (etd != null && property != null) {
        etd = etd.forProperty(property);
    }
    return (_createContextual(type, kd, etd, ed, creatorMethod));
}

@SuppressWarnings("unchecked")
@Override
public JsonDeserializer<T> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    InstantDeserializer<T> deserializer = (InstantDeserializer<T>) super.createContextual(ctxt, property);
    if (deserializer != this) {
        JsonFormat.Value val = findFormatOverrides(ctxt, property, handledType());
        if (val != null) {
            return new InstantDeserializer<>(deserializer, val.getFeature(JsonFormat.Feature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE));
        }
    }
    return this;
}

public ObjectMapper getDefaulObjectMapper() {
    SimpleModule module = new SimpleModule();
    module.addDeserializer(ZfDate.class, new JsonDeserializer<ZfDate>() {

        @Override
        public ZfDate deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
            Long timestamp = jp.readValueAs(Long.class);
            return new ZfDateDay(timestamp);
        }
    });
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    objectMapper.registerModule(module);
    return objectMapper;
}

private ObjectMapper createObjectMapper() {
    SimpleModule module = new SimpleModule("MySimpleModule", new Version(1, 0, 0, null, "", ""));
    module.addDeserializer(Custom.class, new JsonDeserializer<Custom>() {

        @Override
        public Custom deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
            JsonNode node = jp.readValueAsTree();
            return new Custom(node.get("v1").asText(), node.get("v2").asText());
        }
    });
    module.addSerializer(Custom.class, new JsonSerializer<Custom>() {

        @Override
        public void serialize(Custom value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
            jgen.writeStartObject();
            jgen.writeFieldName("v1");
            jgen.writeString(value.value1);
            jgen.writeFieldName("v2");
            jgen.writeString(value.value2);
            jgen.writeEndObject();
        }
    });
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(module);
    MongoJackModule.configure(objectMapper);
    return objectMapper;
}

@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    if (ConditionalEnabledHelper.isEnabled(ctxt, property)) {
        return new JSonMapEntryArrayDeSerializer(property.getType().getKeyType(), property.getType().getContentType());
    }
    BeanDescription beanDesc = ctxt.getConfig().introspect(property.getType());
    JsonDeserializer<?> deserializer = ctxt.getFactory().createMapDeserializer(ctxt, (MapType) property.getType(), beanDesc);
    if (deserializer instanceof ContextualDeserializer) {
        return ((ContextualDeserializer) deserializer).createContextual(ctxt, property);
    }
    return deserializer;
}

@Override
public boolean handleUnknownProperty(DeserializationContext ctxt, com.fasterxml.jackson.core.JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException {
    if (beanOrClass instanceof Asset && "inactive".equals(propertyName)) {
        logger.info("inactive asset is deprecated since 1.0.1");
        return true;
    }
    if (beanOrClass instanceof Property && "bidirectional".equals(propertyName)) {
        logger.info("bidirectional property is deprecated since 1.0.2");
        return true;
    }
    //By default return false
    return super.handleUnknownProperty(ctxt, jp, deserializer, beanOrClass, propertyName);
}

public JsonDeserializer<?> findTypedValueDeserializer(FieldType fieldType) {
    if (fieldType == null) {
        return null;
    }
    if (fieldType.equals(STRING)) {
        return new StringDeserializer();
    } else if (fieldType.equals(TINYINT)) {
        return new ByteDeserializer(Byte.class, null);
    } else if (fieldType.equals(SMALLINT)) {
        return new ShortDeserializer(Short.class, null);
    } else if (fieldType.equals(INT)) {
        return new IntegerDeserializer(Integer.class, null);
    } else if (fieldType.equals(BIGINT)) {
        return new LongDeserializer(Long.class, null);
    } else if (fieldType.equals(FLOAT)) {
        return new FloatDeserializer(Float.class, null);
    } else if (fieldType.equals(DOUBLE)) {
        return new DoubleDeserializer(Double.class, null);
    } else if (fieldType.equals(BOOLEAN)) {
        return new BooleanDeserializer(Boolean.class, null);
    } else if (fieldType instanceof TimestampType) {
        return new TimestampDeserializer((TimestampType) fieldType);
    } else if (fieldType instanceof ListType) {
        return new ListDeserializer((ListType) fieldType, this);
    } else if (fieldType instanceof MapType) {
        return new MapDeserializer((MapType) fieldType, this);
    } else if (fieldType instanceof StructType) {
        return new StructDeserializer((StructType) fieldType, this);
    }
    return null;
}

private Object readValue(Message.Builder builder, FieldDescriptor field, Message defaultInstance, JsonParser parser, DeserializationContext context) throws IOException {
    final Object value;
    if (parser.getCurrentToken() == JsonToken.START_ARRAY) {
        if (field.isRepeated()) {
            return readArray(builder, field, defaultInstance, parser, context);
        } else {
            throw mappingException(field, context);
        }
    }
    switch(field.getJavaType()) {
        case INT:
            value = _parseInteger(parser, context);
            if (value == null) {
                new NullProvider(SimpleType.construct(Integer.TYPE), 0).nullValue(context);
            }
            break;
        case LONG:
            value = _parseLong(parser, context);
            if (value == null) {
                new NullProvider(SimpleType.construct(Long.TYPE), 0L).nullValue(context);
            }
            break;
        case FLOAT:
            value = _parseFloat(parser, context);
            if (value == null) {
                new NullProvider(SimpleType.construct(Float.TYPE), 0.0f).nullValue(context);
            }
            break;
        case DOUBLE:
            value = _parseDouble(parser, context);
            if (value == null) {
                new NullProvider(SimpleType.construct(Double.TYPE), 0.0d).nullValue(context);
            }
            break;
        case BOOLEAN:
            value = _parseBoolean(parser, context);
            if (value == null) {
                new NullProvider(SimpleType.construct(Boolean.TYPE), false).nullValue(context);
            }
            break;
        case STRING:
            switch(parser.getCurrentToken()) {
                case VALUE_STRING:
                    value = parser.getText();
                    break;
                case VALUE_NULL:
                    value = null;
                    break;
                default:
                    value = _parseString(parser, context);
            }
            break;
        case BYTE_STRING:
            switch(parser.getCurrentToken()) {
                case VALUE_STRING:
                    value = ByteString.copyFrom(context.getBase64Variant().decode(parser.getText()));
                    break;
                case VALUE_NULL:
                    value = null;
                    break;
                default:
                    throw mappingException(field, context);
            }
            break;
        case ENUM:
            switch(parser.getCurrentToken()) {
                case VALUE_STRING:
                    value = field.getEnumType().findValueByName(parser.getText());
                    if (value == null && !ignorableEnum(parser.getText().trim(), context)) {
                        throw context.weirdStringException(parser.getText(), field.getEnumType().getClass(), "value not one of declared Enum instance names");
                    }
                    break;
                case VALUE_NUMBER_INT:
                    if (allowNumbersForEnums(context)) {
                        value = field.getEnumType().findValueByNumber(parser.getIntValue());
                        if (value == null && !ignoreUnknownEnums(context)) {
                            throw context.weirdNumberException(parser.getIntValue(), field.getEnumType().getClass(), "index value outside legal index range " + indexRange(field.getEnumType()));
                        }
                    } else {
                        throw context.mappingException("Not allowed to deserialize Enum value out of JSON number " + "(disable DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow)");
                    }
                    break;
                case VALUE_NULL:
                    value = null;
                    break;
                default:
                    throw mappingException(field, context);
            }
            break;
        case MESSAGE:
            switch(parser.getCurrentToken()) {
                case START_OBJECT:
                    JsonDeserializer<Object> deserializer = deserializerCache.get(field);
                    if (deserializer == null) {
                        final Class<?> subType;
                        if (defaultInstance == null) {
                            Message.Builder subBuilder = builder.newBuilderForField(field);
                            subType = subBuilder.getDefaultInstanceForType().getClass();
                        } else {
                            subType = defaultInstance.getClass();
                        }
                        JavaType type = SimpleType.construct(subType);
                        deserializer = context.findContextualValueDeserializer(type, null);
                        deserializerCache.put(field, deserializer);
                    }
                    value = deserializer.deserialize(parser, context);
                    break;
                case VALUE_NULL:
                    value = null;
                    break;
                default:
                    throw mappingException(field, context);
            }
            break;
        default:
            throw mappingException(field, context);
    }
    return value;
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
    if (beanDesc.getBeanClass() == Client.class) {
        return new Deserializer<Client>(deserializer);
    } else if (beanDesc.getBeanClass() == Fee.class) {
        return new Deserializer<Fee>(deserializer);
    } else if (beanDesc.getBeanClass() == Interval.class) {
        return new Deserializer<Interval>(deserializer);
    } else if (beanDesc.getBeanClass() == Offer.class) {
        return new Deserializer<Offer>(deserializer);
    } else if (beanDesc.getBeanClass() == Payment.class) {
        return new Deserializer<Payment>(deserializer);
    } else if (beanDesc.getBeanClass() == Preauthorization.class) {
        return new Deserializer<Preauthorization>(deserializer);
    } else if (beanDesc.getBeanClass() == Refund.class) {
        return new Deserializer<Refund>(deserializer);
    } else if (beanDesc.getBeanClass() == Subscription.class) {
        return new Deserializer<Subscription>(deserializer);
    } else if (beanDesc.getBeanClass() == Transaction.class) {
        return new Deserializer<Transaction>(deserializer);
    } else if (beanDesc.getBeanClass() == Webhook.class) {
        return new Deserializer<Webhook>(deserializer);
    } else {
        return deserializer;
    }
}

protected HttpMessageConvertingResponseWriter createResponseWriter() {
    ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
    factoryBean.afterPropertiesSet();
    ContentNegotiationManager contentNegotiationManager = factoryBean.getObject();
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
    List<JsonSerializer<?>> serializers = new ArrayList<>();
    serializers.add(new ObjectIdSerializer());
    Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<>();
    deserializers.put(ObjectId.class, new ObjectIdDeserializer());
    CustomSerializationObjectMapper objectMapper = new CustomSerializationObjectMapper();
    objectMapper.setSerializers(serializers);
    objectMapper.setDeserializers(deserializers);
    objectMapper.init();
    MappingJackson2HttpMessageConverter jsonMessageConverter = new MappingJackson2HttpMessageConverter();
    jsonMessageConverter.setObjectMapper(objectMapper);
    messageConverters.add(jsonMessageConverter);
    return new HttpMessageConvertingResponseWriter(contentNegotiationManager, messageConverters);
}

@Test
public void classesShouldExtendRapidoidThing() {
    for (String cls : Cls.getRapidoidClasses()) {
        Class<?> clazz = Cls.get(cls);
        if (!clazz.isInterface() && !clazz.isEnum() && !clazz.isAnnotation()) {
            U.must(RapidoidThing.class.isAssignableFrom(clazz) || clazz == TestCommons.class || cls.startsWith("org.rapidoid.fluent.") || cls.startsWith("org.rapidoid.benchmark.") || Exception.class.isAssignableFrom(clazz) || ClassLoader.class.isAssignableFrom(clazz) || HibernatePersistenceProvider.class.isAssignableFrom(clazz) || OutputStream.class.isAssignableFrom(clazz) || Map.class.isAssignableFrom(clazz) || AbstractMojo.class.isAssignableFrom(clazz) || EmbeddedMavenCli.class.isAssignableFrom(clazz) || JsonSerializer.class.isAssignableFrom(clazz) || JsonDeserializer.class.isAssignableFrom(clazz) || LogFactory.class.isAssignableFrom(clazz) || Thread.class.isAssignableFrom(clazz), "" + cls);
        }
    }
}

@Override
public ObjectMapper getObject() throws Exception {
    ObjectMapper mapper = getObjectMapper();
    if (mapper == null) {
        mapper = new ObjectMapper();
        setObjectMapper(mapper);
    }
    SimpleModule module = new SimpleModule(getModuleName(), getModuleVersion());
    if (getSerializers() != null) {
        for (JsonSerializer<?> serializer : getSerializers()) {
            module.addSerializer(serializer);
        }
    }
    if (getDeserializers() != null) {
        for (JsonDeserializer<?> deserializer : getDeserializers()) {
            registerDeserializer(module, deserializer);
        }
    }
    if (getKeyDeserializers() != null) {
        for (TypedKeyDeserializer deserializer : getKeyDeserializers()) {
            module.addKeyDeserializer(deserializer.getClass(), deserializer.getKeyDeserializer());
        }
    }
    if (getKeySerializers() != null) {
        for (JsonSerializer<?> serializer : getKeySerializers()) {
            registerKeySerializer(module, serializer);
        }
    }
    if (serializationInclusion != null) {
        mapper.setSerializationInclusion(serializationInclusion);
    }
    setupFeatures(mapper, featuresToEnable, true);
    setupFeatures(mapper, featuresToDisable, false);
    mapper.registerModule(module);
    return mapper;
}

@Override
public JsonDeserializer<?> createContextual(DeserializationContext context, BeanProperty property) throws JsonMappingException {
    final Class<?> rawClass = property.getType().getRawClass();
    final Class<?> componentType = rawClass.getComponentType();
    if (componentType == null || componentType != String.class) {
        throw new JsonMappingException(context.getParser(), "Pick list String array expected for " + rawClass);
    }
    return new StringMultiSelectPicklistDeserializer(rawClass);
}

@Override
public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser p, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException {
    boolean handled = false;
    if (beanOrClass instanceof CachingPrincipalAttributesRepository) {
        final CachingPrincipalAttributesRepository repo = CachingPrincipalAttributesRepository.class.cast(beanOrClass);
        switch(propertyName) {
            case "duration":
                p.nextToken();
                p.nextToken();
                p.nextToken();
                p.nextToken();
                p.nextToken();
                p.nextToken();
                final String timeUnit = p.getText();
                p.nextToken();
                p.nextToken();
                p.nextToken();
                final int expiration = p.getValueAsInt();
                repo.setTimeUnit(timeUnit);
                repo.setExpiration(expiration);
                LOGGER.warn("CAS has converted legacy JSON property [{}] for type [{}]. It parsed 'expiration' value [{}] with time unit of [{}]." + "It is STRONGLY recommended that you review the configuration and upgrade the legacy syntax.", propertyName, beanOrClass.getClass().getName(), expiration, timeUnit);
                handled = true;
                break;
            default:
                break;
        }
    }
    return handled;
}

@Override
@SuppressWarnings("unchecked")
public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription desc) throws JsonMappingException {
    // If the user configured to use `toString` method to deserialize enums
    if (config.hasDeserializationFeatures(DeserializationFeature.READ_ENUMS_USING_TO_STRING.getMask())) {
        return null;
    }
    // If there is a JsonCreator annotation we should use that instead of the PermissiveEnumDeserializer
    final Collection<AnnotatedMethod> factoryMethods = desc.getFactoryMethods();
    if (factoryMethods != null) {
        for (AnnotatedMethod am : factoryMethods) {
            if (am.hasAnnotation(JsonCreator.class)) {
                return null;
            }
        }
    }
    // Jackson to do the deserialization
    for (Field field : type.getFields()) {
        for (Annotation annotation : field.getAnnotations()) {
            final String packageName = annotation.annotationType().getPackage().getName();
            if (packageName.equals("com.fasterxml.jackson.annotation")) {
                return null;
            }
        }
    }
    return new PermissiveEnumDeserializer((Class<Enum<?>>) type);
}

@Test
public void testDeserializeReferenceAsStrings() throws JsonProcessingException {
    EMFModule module = new EMFModule();
    module.configure(EMFModule.Feature.OPTION_USE_ID, true);
    module.configure(EMFModule.Feature.OPTION_SERIALIZE_TYPE, false);
    module.setReferenceDeserializer(new JsonDeserializer<ReferenceEntry>() {

        @Override
        public ReferenceEntry deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            final EObject parent = EMFContext.getParent(ctxt);
            final EReference reference = EMFContext.getReference(ctxt);
            if (p.getCurrentToken() == JsonToken.FIELD_NAME) {
                p.nextToken();
            }
            return new ReferenceEntry.Base(parent, reference, p.getText());
        }
    });
    mapper.registerModule(module);
    JsonNode data = mapper.createArrayNode().add(mapper.createObjectNode().put("@id", "1").put("name", "Paul").put("uniqueFriend", "2")).add(mapper.createObjectNode().put("@id", "2").put("name", "Franck"));
    Resource resource = mapper.reader().withAttribute(RESOURCE_SET, resourceSet).withAttribute(ROOT_ELEMENT, ModelPackage.Literals.USER).treeToValue(data, Resource.class);
    assertEquals(2, resource.getContents().size());
    User u1 = (User) resource.getContents().get(0);
    User u2 = (User) resource.getContents().get(1);
    assertSame(u2, u1.getUniqueFriend());
}

@Test
public void shouldThrowOnNullTree() throws Exception {
    exception.expect(JWTDecodeException.class);
    exception.expectMessage("Parsing the Header's JSON resulted on a Null map");
    JsonDeserializer deserializer = new HeaderDeserializer();
    JsonParser parser = mock(JsonParser.class);
    ObjectCodec codec = mock(ObjectCodec.class);
    DeserializationContext context = mock(DeserializationContext.class);
    when(codec.readValue(eq(parser), any(TypeReference.class))).thenReturn(null);
    when(parser.getCodec()).thenReturn(codec);
    deserializer.deserialize(parser, context);
}

public RTM startRTM(String slackToken) {
    try {
        restTemplate = new RestTemplate();
        rtm = new RTM();
        // Custom Deserializers
        List<HttpMessageConverter<?>> httpMessageConverters = new ArrayList<>();
        MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
        Jackson2ObjectMapperBuilder mapperBuilder = new Jackson2ObjectMapperBuilder();
        mapperBuilder.deserializerByType(RTM.class, new JsonDeserializer<RTM>() {

            @Override
            public RTM deserialize(JsonParser p, DeserializationContext ctxt) {
                try {
                    final ObjectMapper objectMapper = new ObjectMapper();
                    JsonNode node = p.readValueAsTree();
                    RTM rtm = new RTM();
                    rtm.setWebSocketUrl(node.get("url").asText());
                    rtm.setUser(objectMapper.treeToValue(node.get("self"), User.class));
                    List<String> dmChannels = new ArrayList<>();
                    Iterator<JsonNode> iterator = node.get("ims").iterator();
                    while (iterator.hasNext()) {
                        dmChannels.add(iterator.next().get("id").asText());
                    }
                    rtm.setDmChannels(dmChannels);
                    List<User> users = new ArrayList<>();
                    Iterator<JsonNode> userIterator = node.get("users").iterator();
                    while (userIterator.hasNext()) {
                        users.add(objectMapper.treeToValue(userIterator.next(), User.class));
                    }
                    rtm.setUsers(users);
                    return rtm;
                } catch (Exception e) {
                    logger.error("Error de-serializing RTM.start(): ", e);
                    return null;
                }
            }
        });
        jsonConverter.setObjectMapper(mapperBuilder.build());
        httpMessageConverters.add(jsonConverter);
        restTemplate.setMessageConverters(httpMessageConverters);
        ResponseEntity<RTM> response = restTemplate.getForEntity(rtmUrl, RTM.class, slackToken);
        if (response.getBody() != null) {
            rtm.setWebSocketUrl(response.getBody().getWebSocketUrl());
            rtm.setDmChannels(response.getBody().getDmChannels());
            rtm.setUser(response.getBody().getUser());
            rtm.setUsers(response.getBody().getUsers());
            logger.debug("RTM connection successful. WebSocket URL: {}", rtm.getWebSocketUrl());
        } else {
            logger.debug("RTM response invalid. Response: {}", response);
        }
    } catch (RestClientException e) {
        logger.error("RTM connection error. Exception: {}", e.getMessage());
    }
    return rtm;
}

@Override
@SuppressWarnings("unchecked")
public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription desc) throws JsonMappingException {
    // If there is a JsonCreator annotation we should use that instead of the PermissiveEnumDeserializer
    final Collection<AnnotatedMethod> factoryMethods = desc.getFactoryMethods();
    if (factoryMethods != null) {
        for (AnnotatedMethod am : factoryMethods) {
            final JsonCreator creator = am.getAnnotation(JsonCreator.class);
            if (creator != null) {
                return EnumDeserializer.deserializerForCreator(config, type, am);
            }
        }
    }
    return new PermissiveEnumDeserializer((Class<Enum<?>>) type);
}

private ObjectMapper getObjectMapper() {
    ObjectMapperFactoryBean factory = new ObjectMapperFactoryBean();
    factory.setDeserializers(Arrays.asList(new JsonDeserializer<?>[] { new BatteryDataDeserializer() }));
    try {
        return factory.getObject();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

private void addJsonBean(Object bean) {
    if (bean instanceof JsonSerializer) {
        addSerializerWithDeducedType((JsonSerializer<?>) bean);
    }
    if (bean instanceof JsonDeserializer) {
        addDeserializerWithDeducedType((JsonDeserializer<?>) bean);
    }
    for (Class<?> innerClass : bean.getClass().getDeclaredClasses()) {
        if (JsonSerializer.class.isAssignableFrom(innerClass) || JsonDeserializer.class.isAssignableFrom(innerClass)) {
            try {
                addJsonBean(innerClass.newInstance());
            } catch (Exception ex) {
                throw new IllegalStateException(ex);
            }
        }
    }
}

@Override
@SuppressWarnings("unchecked")
public JsonDeserializer<?> findEnumDeserializer(Class<?> type, DeserializationConfig config, BeanDescription desc) throws JsonMappingException {
    // If the user configured to use `toString` method to deserialize enums
    if (config.hasDeserializationFeatures(DeserializationFeature.READ_ENUMS_USING_TO_STRING.getMask())) {
        return null;
    }
    // If there is a JsonCreator annotation we should use that instead of the PermissiveEnumDeserializer
    final Collection<AnnotatedMethod> factoryMethods = desc.getFactoryMethods();
    if (factoryMethods != null) {
        for (AnnotatedMethod am : factoryMethods) {
            if (am.hasAnnotation(JsonCreator.class)) {
                return null;
            }
        }
    }
    // Jackson to do the deserialization
    for (Field field : type.getFields()) {
        for (Annotation annotation : field.getAnnotations()) {
            final String packageName = annotation.annotationType().getPackage().getName();
            if (packageName.equals("com.fasterxml.jackson.annotation")) {
                return null;
            }
        }
    }
    return new PermissiveEnumDeserializer((Class<Enum<?>>) type);
}

@Override
public JsonDeserializer<?> deserializerInstance(DeserializationConfig deserializerConfig, Annotated annotated, Class<?> jsonDeserializerClass) {
    logger.debug("deserializerInstance " + deserializerConfig + " " + jsonDeserializerClass);
    try {
        if (jsonDeserializerClass.equals(TaxonDeserializer.class)) {
            TaxonDeserializer taxonDeserializer = TaxonDeserializer.class.newInstance();
            taxonDeserializer.setService(taxonService);
            return taxonDeserializer;
        } else if (jsonDeserializerClass.equals(ReferenceDeserializer.class)) {
            ReferenceDeserializer referenceDeserializer = ReferenceDeserializer.class.newInstance();
            referenceDeserializer.setService(referenceService);
            return referenceDeserializer;
        } else if (jsonDeserializerClass.equals(ImageDeserializer.class)) {
            ImageDeserializer imageDeserializer = ImageDeserializer.class.newInstance();
            imageDeserializer.setService(imageService);
            return imageDeserializer;
        } else if (jsonDeserializerClass.equals(UserDeserializer.class)) {
            UserDeserializer userDeserializer = UserDeserializer.class.newInstance();
            userDeserializer.setService(userService);
            return userDeserializer;
        } else if (jsonDeserializerClass.equals(GroupDeserializer.class)) {
            GroupDeserializer groupDeserializer = GroupDeserializer.class.newInstance();
            groupDeserializer.setService(groupService);
            return groupDeserializer;
        } else if (jsonDeserializerClass.equals(OrganisationDeserialiser.class)) {
            OrganisationDeserialiser sourceDeserializer = OrganisationDeserialiser.class.newInstance();
            sourceDeserializer.setService(organisationService);
            return sourceDeserializer;
        } else if (jsonDeserializerClass.equals(IdentificationKeyDeserializer.class)) {
            IdentificationKeyDeserializer identificationKeyDeserializer = IdentificationKeyDeserializer.class.newInstance();
            identificationKeyDeserializer.setService(identificationKeyService);
            return identificationKeyDeserializer;
        } else if (jsonDeserializerClass.equals(PhylogeneticTreeDeserializer.class)) {
            PhylogeneticTreeDeserializer phylogeneticTreeDeserializer = PhylogeneticTreeDeserializer.class.newInstance();
            phylogeneticTreeDeserializer.setService(phylogeneticTreeService);
            return phylogeneticTreeDeserializer;
        } else if (jsonDeserializerClass.equals(ConceptDeserializer.class)) {
            ConceptDeserializer conceptDeserializer = ConceptDeserializer.class.newInstance();
            conceptDeserializer.setService(conceptService);
            return conceptDeserializer;
        } else if (jsonDeserializerClass.equals(PrincipalDeserializer.class)) {
            PrincipalDeserializer principalDeserializer = PrincipalDeserializer.class.newInstance();
            principalDeserializer.setUserService(userService);
            principalDeserializer.setGroupService(groupService);
            return principalDeserializer;
        } else if (jsonDeserializerClass.equals(AnnotatableObjectDeserializer.class)) {
            AnnotatableObjectDeserializer annotatableObjectDeserializer = AnnotatableObjectDeserializer.class.newInstance();
            annotatableObjectDeserializer.addService(taxonService);
            annotatableObjectDeserializer.addService(imageService);
            annotatableObjectDeserializer.addService(referenceService);
            annotatableObjectDeserializer.addService(organisationService);
            return annotatableObjectDeserializer;
        }
    } catch (IllegalAccessException iae) {
        return null;
    } catch (InstantiationException ie) {
        return null;
    }
    return null;
}

@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config, final JavaType type, BeanDescription beanDesc, final JsonDeserializer<?> deserializer) {
    return new JsonDeserializer<Enum>() {

        @Override
        public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
            Class<? extends Enum> rawClass = (Class<Enum>) type.getRawClass();
            return Enum.valueOf(rawClass, jp.getValueAsString().replace('-', '_').toUpperCase(Locale.ENGLISH));
        }
    };
}

protected XmlMapper getXmlMapper() {
    final XmlMapper xmlMapper = new XmlMapper(new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());
    xmlMapper.setInjectableValues(new InjectableValues.Std().addValue(Boolean.class, Boolean.FALSE));
    xmlMapper.addHandler(new DeserializationProblemHandler() {

        @Override
        public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final com.fasterxml.jackson.databind.JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException, JsonProcessingException {
            // skip any unknown property
            ctxt.getParser().skipChildren();
            return true;
        }
    });
    return xmlMapper;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
protected void registerSerializer(ObjectMapper result, SimpleModule module, Versions versions) {
    // Default serializer
    module.addSerializer(new DateSerializer());
    module.addDeserializer(Date.class, new DateDeserializer());
    module.addSerializer(new ZonedDateTimeSerializer());
    module.addDeserializer(ZonedDateTime.class, new ZonedDateTimeDeserializer());
    // Serializer
    for (JsonSerializer<?> serializer : versions.getSerializer()) {
        module.addSerializer(serializer);
    }
    // Deserializer
    for (JsonDeserializer deserializer : versions.getDeserializer()) {
        Method method = null;
        try {
            method = deserializer.getClass().getMethod("deserialize", JsonParser.class, DeserializationContext.class);
            module.addDeserializer(method.getReturnType(), deserializer);
        } catch (NullPointerExceptionNoSuchMethodException | SecurityException |  ex) {
            String methodName = (method == null) ? "null" : method.getName();
            String returnTypeName = (method == null || method.getReturnType() == null) ? "null" : method.getReturnType().toString();
            LOG.error("Unable to register deserializer for Class<" + returnTypeName + ">." + methodName + "(..)", ex);
        }
    }
}

@Override
public ObjectMapper get() {
    ObjectMapper objectMapper = new ObjectMapper();
    // ignore unknown fields (for backwards compatibility)
    objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    // do not allow converting a float to an integer
    objectMapper.disable(DeserializationFeature.ACCEPT_FLOAT_AS_INT);
    // use ISO dates
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    // skip fields that are null instead of writing an explicit json null value
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_ABSENT);
    // disable auto detection of json properties... all properties must be explicit
    objectMapper.disable(MapperFeature.AUTO_DETECT_CREATORS);
    objectMapper.disable(MapperFeature.AUTO_DETECT_FIELDS);
    objectMapper.disable(MapperFeature.AUTO_DETECT_SETTERS);
    objectMapper.disable(MapperFeature.AUTO_DETECT_GETTERS);
    objectMapper.disable(MapperFeature.AUTO_DETECT_IS_GETTERS);
    objectMapper.disable(MapperFeature.USE_GETTERS_AS_SETTERS);
    objectMapper.disable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS);
    objectMapper.disable(MapperFeature.INFER_PROPERTY_MUTATORS);
    objectMapper.disable(MapperFeature.ALLOW_FINAL_FIELDS_AS_MUTATORS);
    if (jsonSerializers != null || jsonDeserializers != null || keySerializers != null || keyDeserializers != null) {
        SimpleModule module = new SimpleModule(getClass().getName(), new Version(1, 0, 0, null, null, null));
        if (jsonSerializers != null) {
            for (Entry<Class<?>, JsonSerializer<?>> entry : jsonSerializers.entrySet()) {
                addSerializer(module, entry.getKey(), entry.getValue());
            }
        }
        if (jsonDeserializers != null) {
            for (Entry<Class<?>, JsonDeserializer<?>> entry : jsonDeserializers.entrySet()) {
                addDeserializer(module, entry.getKey(), entry.getValue());
            }
        }
        if (keySerializers != null) {
            for (Entry<Class<?>, JsonSerializer<?>> entry : keySerializers.entrySet()) {
                addKeySerializer(module, entry.getKey(), entry.getValue());
            }
        }
        if (keyDeserializers != null) {
            for (Entry<Class<?>, KeyDeserializer> entry : keyDeserializers.entrySet()) {
                module.addKeyDeserializer(entry.getKey(), entry.getValue());
            }
        }
        modules.add(module);
    }
    for (Module module : modules) {
        objectMapper.registerModule(module);
    }
    return objectMapper;
}

@Override
public LogicalOperator deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ObjectIdGenerator<Integer> idGenerator = new ObjectIdGenerators.IntSequenceGenerator();
    JsonLocation start = jp.getCurrentLocation();
    JsonToken t = jp.getCurrentToken();
    LogicalOperator parent = null;
    LogicalOperator first = null;
    LogicalOperator prev = null;
    Integer id = null;
    while (true) {
        String fieldName = jp.getText();
        t = jp.nextToken();
        switch(// switch on field names.
        fieldName) {
            case "@id":
                id = _parseIntPrimitive(jp, ctxt);
                break;
            case "input":
                JavaType tp = ctxt.constructType(LogicalOperator.class);
                JsonDeserializer<Object> d = ctxt.findRootValueDeserializer(tp);
                parent = (LogicalOperator) d.deserialize(jp, ctxt);
                break;
            case "do":
                if (!jp.isExpectedStartArrayToken()) {
                    throwE(jp, "The do parameter of sequence should be an array of SimpleOperators.  Expected a JsonToken.START_ARRAY token but received a " + t.name() + "token.");
                }
                int pos = 0;
                while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
                    // logger.debug("Reading sequence child {}.", pos);
                    // get current location
                    JsonLocation l = jp.getCurrentLocation();
                    // first so we can
                    // correctly reference the
                    // start of the object in
                    // the case that the type
                    // is wrong.
                    LogicalOperator o = jp.readValueAs(LogicalOperator.class);
                    if (pos == 0) {
                        if (!(o instanceof SingleInputOperator) && !(o instanceof SourceOperator)) {
                            throwE(l, "The first operator in a sequence must be either a ZeroInput or SingleInput operator.  The provided first operator was not. It was of type " + o.getClass().getName());
                        }
                        first = o;
                    } else {
                        if (!(o instanceof SingleInputOperator)) {
                            throwE(l, "All operators after the first must be single input operators.  The operator at position " + pos + " was not. It was of type " + o.getClass().getName());
                        }
                        SingleInputOperator now = (SingleInputOperator) o;
                        now.setInput(prev);
                    }
                    prev = o;
                    pos++;
                }
                break;
            default:
                throwE(jp, "Unknown field name provided for Sequence: " + jp.getText());
        }
        t = jp.nextToken();
        if (t == JsonToken.END_OBJECT) {
            break;
        }
    }
    if (first == null) {
        throwE(start, "A sequence must include at least one operator.");
    }
    if ((parent == null && first instanceof SingleInputOperator) || (parent != null && first instanceof SourceOperator)) {
        throwE(start, "A sequence must either start with a ZeroInputOperator or have a provided input. It cannot have both or neither.");
    }
    if (parent != null && first instanceof SingleInputOperator) {
        ((SingleInputOperator) first).setInput(parent);
    }
    // set input reference.
    if (id != null) {
        ReadableObjectId rid = ctxt.findObjectId(id, idGenerator);
        rid.bindItem(prev);
    // logger.debug("Binding id {} to item {}.", rid.id, rid.item);
    }
    return first;
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
    if (deserializer instanceof BeanDeserializer) {
        List<ConstructibleAnnotatedCollection> fields = collectFields(config, beanDesc);
        if (!fields.isEmpty()) {
            return new BackReferencedBeanDeserializer((BeanDeserializer) deserializer, fields, db, beanDesc.getType().getRawClass());
        }
    }
    return super.modifyDeserializer(config, beanDesc, deserializer);
}

@Override
public void setupModule(SetupContext context) {
    context.addDeserializers(new Deserializers.Base() {

        @Override
        public JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
            Class<?> raw = type.getRawClass();
            if (Task.class.isAssignableFrom(raw)) {
                return newTaskDeserializer(raw);
            }
            return super.findBeanDeserializer(type, config, beanDesc);
        }
    });
}

@Override
public void setupModule(SetupContext context) {
    context.addDeserializers(new Deserializers.Base() {

        @Override
        public JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
            Class<?> raw = type.getRawClass();
            if (Task.class.isAssignableFrom(raw)) {
                return newTaskDeserializer(raw);
            }
            return super.findBeanDeserializer(type, config, beanDesc);
        }
    });
}

static void configureCustomSerializersAndDeserializers(final ObjectMapper objectMapper, final String customSerializers, final String customDeserializers, final String customDataTypeModules, final ClassLoader classLoader) throws Exception {
    if (customDeserializers != null || customSerializers != null) {
        final SimpleModule simpleModule = new SimpleModule("custom-serializer-deserializer-module");
        if (customSerializers != null) {
            final StringTokenizer st = new StringTokenizer(customSerializers, ", ");
            while (st.hasMoreTokens()) {
                final Class<?> aClass = classLoader.loadClass(st.nextToken());
                simpleModule.addSerializer(aClass, (JsonSerializer) aClass.newInstance());
            }
        }
        if (customDeserializers != null) {
            final StringTokenizer st = new StringTokenizer(customDeserializers, ", ");
            while (st.hasMoreTokens()) {
                final Class<?> aClass = classLoader.loadClass(st.nextToken());
                simpleModule.addDeserializer(aClass, (JsonDeserializer) aClass.newInstance());
            }
        }
        objectMapper.registerModule(simpleModule);
    }
    if (customDataTypeModules != null) {
        final StringTokenizer st = new StringTokenizer(customDataTypeModules, ", ");
        while (st.hasMoreTokens()) {
            final Class<?> aClass = classLoader.loadClass(st.nextToken());
            objectMapper.registerModule((Module) aClass.newInstance());
        }
    }
}

@Override
@SuppressWarnings({ "unchecked", "rawtypes" })
public OProcess deserialize() throws SerializaionRtException {
    mapper = new ObjectMapper(factory);
    mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    mapper.setSerializerFactory(TypeBeanSerializerFactory.instance);
    SimpleModule simpleModule = new SimpleModule("SimpleModule");
    for (Class<?> d : deserializers.keySet()) {
        simpleModule.addDeserializer((Class) d, (JsonDeserializer) deserializers.get(d));
    }
    simpleModule.setDeserializerModifier(new WsdlElementDeserModifier());
    simpleModule.addKeyDeserializer(Object.class, new KeyAsJsonDeserializer());
    simpleModule.addKeyDeserializer(String.class, new KeyAsJsonDeserializer());
    mapper.registerModule(simpleModule);
    try {
        process = mapper.readValue(is, OProcess.class);
    } catch (Exception e1) {
        SerializaionRtException e = new SerializaionRtException("Error when deseriaze process during deseriazation");
        e.initCause(e1);
        throw e;
    }
    return process;
}

private JsonObjectMapper createMapper() {
    JsonObjectMapper mapper = new JsonObjectMapper();
    Map<Class<?>, JsonSerializer<?>> serializers = new HashMap<Class<?>, JsonSerializer<?>>();
    serializers.put(Point.class, new PointSerializerWithTypeInfo());
    mapper.setSerializers(serializers);
    Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<Class<?>, JsonDeserializer<?>>();
    deserializers.put(Point.class, new PointDeserializer());
    mapper.setDeserializers(deserializers);
    return mapper;
}

/**
	 * Metodo que se ejecuta despues de finalizar el contructor. Se inicializa
	 * el modulo configurando los serializadores y deserializadores indicados.
	 * Se anyade por defecto el deserializador MultiBeanDeserializer para
	 * permitir la deserializacion de multiples entidades no anidadas en la
	 * misma peticion.
	 */
@PostConstruct
public void initialize() {
    // Se registran los serializadores indicados.
    if (this.serializers != null) {
        Set<Entry<Class<? extends Object>, JsonSerializer<Object>>> serializerEntrySet = this.serializers.entrySet();
        for (Iterator<Entry<Class<? extends Object>, JsonSerializer<Object>>> iterator = serializerEntrySet.iterator(); iterator.hasNext(); ) {
            Entry<Class<? extends Object>, JsonSerializer<Object>> entry = (Entry<Class<? extends Object>, JsonSerializer<Object>>) iterator.next();
            this.addSerializer(entry.getKey(), entry.getValue());
        }
    }
    // Se registran los deserializadores indicados.
    if (this.deserializers != null) {
        Set<Entry<Class<Object>, JsonDeserializer<? extends Object>>> deserializerEntrySet = this.deserializers.entrySet();
        for (Iterator<Entry<Class<Object>, JsonDeserializer<? extends Object>>> iterator = deserializerEntrySet.iterator(); iterator.hasNext(); ) {
            Entry<Class<Object>, JsonDeserializer<? extends Object>> entry = (Entry<Class<Object>, JsonDeserializer<? extends Object>>) iterator.next();
            this.addDeserializer(entry.getKey(), entry.getValue());
        }
    }
    // Se registra el deserializador MultiBeanDeserializer. Este bean
    // permite la deserializacion de multiples entidades no anidadas en la
    // misma peticion.
    this.addDeserializer(Map.class, new MultiModelDeserializer());
}

@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    checkNotNull(ctxt, "Null DeserializationContext.");
    JavaType type = checkNotNull(ctxt.getContextualType(), "Invalid type: %s", getClass());
    JavaType[] params = type.findTypeParameters(ValueProvider.class);
    if (params.length != 1) {
        throw new RuntimeException("Unable to derive type for ValueProvider: " + type.toString());
    }
    JavaType param = params[0];
    return new Deserializer(param);
}

@Override
public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException, JsonProcessingException {
    // 1. special handling of AbstractAnnotatedEdm's fields
    if (beanOrClass instanceof AbstractAnnotatedEdm && AbstractAnnotatedEdmUtils.isAbstractAnnotatedProperty(propertyName)) {
        AbstractAnnotatedEdmUtils.parseAnnotatedEdm((AbstractAnnotatedEdm) beanOrClass, jp);
    } else // 2. skip any other unknown property
    {
        ctxt.getParser().skipChildren();
    }
    return true;
}

protected Object _deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    if (jp.canReadTypeId()) {
        Object typeId = jp.getTypeId();
        if (typeId != null) {
            return _deserializeWithNativeTypeId(jp, ctxt, typeId);
        }
    }
    String typeId = _locateTypeId(jp, ctxt);
    JsonDeserializer<Object> deser = _findDeserializer(ctxt, typeId);
    if (_typeIdVisible && !_usesExternalId() && jp.getCurrentToken() == JsonToken.START_OBJECT) {
        TokenBuffer tb = new TokenBuffer(null, false);
        tb.writeStartObject();
        tb.writeFieldName(_typePropertyName);
        tb.writeString(typeId);
        jp = JsonParserSequence.createFlattened(tb.asParser(jp), jp);
        jp.nextToken();
    }
    Object value = deser.deserialize(jp, ctxt);
    return value;
}

protected Object _deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    if (jp.canReadTypeId()) {
        Object typeId = jp.getTypeId();
        if (typeId != null) {
            return _deserializeWithNativeTypeId(jp, ctxt, typeId);
        }
    }
    String typeId = _locateTypeId(jp, ctxt);
    JsonDeserializer<Object> deser = _findDeserializer(ctxt, typeId);
    if (_typeIdVisible && !_usesExternalId() && jp.getCurrentToken() == JsonToken.START_OBJECT) {
        TokenBuffer tb = new TokenBuffer(null, false);
        tb.writeStartObject();
        tb.writeFieldName(_typePropertyName);
        tb.writeString(typeId);
        jp = JsonParserSequence.createFlattened(tb.asParser(jp), jp);
        jp.nextToken();
    }
    Object value = deser.deserialize(jp, ctxt);
    return value;
}

/* 
		 * (non-Javadoc)
		 * @see com.fasterxml.jackson.databind.deser.BeanDeserializerModifier#updateBuilder(com.fasterxml.jackson.databind.DeserializationConfig, com.fasterxml.jackson.databind.BeanDescription, com.fasterxml.jackson.databind.deser.BeanDeserializerBuilder)
		 */
@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
    Iterator<SettableBeanProperty> properties = builder.getProperties();
    entities.getPersistentEntity(beanDesc.getBeanClass()).ifPresent( entity -> {
        while (properties.hasNext()) {
            SettableBeanProperty property = properties.next();
            entity.getPersistentProperty(property.getName()).ifPresent( persistentProperty -> {
                if (associationLinks.isLookupType(persistentProperty)) {
                    RepositoryInvokingDeserializer repositoryInvokingDeserializer = new RepositoryInvokingDeserializer(factory, persistentProperty);
                    JsonDeserializer<?> deserializer = wrapIfCollection(persistentProperty, repositoryInvokingDeserializer, config);
                    builder.addOrReplaceProperty(property.withValueDeserializer(deserializer), false);
                    return;
                }
                if (!associationLinks.isLinkableAssociation(persistentProperty)) {
                    return;
                }
                UriStringDeserializer uriStringDeserializer = new UriStringDeserializer(persistentProperty, converter);
                JsonDeserializer<?> deserializer = wrapIfCollection(persistentProperty, uriStringDeserializer, config);
                builder.addOrReplaceProperty(property.withValueDeserializer(deserializer), false);
            });
        }
    });
    return builder;
}

/*
		 * (non-Javadoc)
		 * @see com.fasterxml.jackson.databind.JsonDeserializer#deserialize(com.fasterxml.jackson.core.JsonParser, com.fasterxml.jackson.databind.DeserializationContext)
		 */
@Override
public List<Object> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    List<Object> result = new ArrayList<Object>();
    JsonDeserializer<Object> deser = ctxt.findRootValueDeserializer(contentType);
    Object object;
    // links is an object, so we parse till we find its end.
    while (!JsonToken.END_OBJECT.equals(jp.nextToken())) {
        if (!JsonToken.FIELD_NAME.equals(jp.getCurrentToken())) {
            throw new JsonParseException("Expected relation name", jp.getCurrentLocation());
        }
        if (JsonToken.START_ARRAY.equals(jp.nextToken())) {
            while (!JsonToken.END_ARRAY.equals(jp.nextToken())) {
                object = deser.deserialize(jp, ctxt);
                result.add(object);
            }
        } else {
            object = deser.deserialize(jp, ctxt);
            result.add(object);
        }
    }
    return result;
}

/**
     * Internal method used to init main ObjectMapper for JSON parsing
     *
     * @return initialized ObjectMapper ready for JSON parsing
     */
private static ObjectMapper initObjectMapper() {
    if (mapper == null) {
        /**
             * We don't have a reference to an ObjectMapper, so we need to read
             * from cache or instantiate a new one
             */
        if (usingCache) {
            mapper = (ObjectMapper) readFromCache(OBJECT_MAPPER);
            if (mapper != null) {
                // Successful read from the cache
                return mapper;
            }
        }
        // Jackson configuration
        mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
        mapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
        mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // AlertHeaderText class is out of date and will throw an error if we try to deserialize
        // from latest OTP. Simply ignore for now.
        SimpleModule module = new SimpleModule();
        module.addDeserializer(AlertHeaderText.class, new JsonDeserializer<AlertHeaderText>() {

            @Override
            public AlertHeaderText deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
                Log.d(TAG, "Ignoring AlertHeaderText object.");
                return null;
            }
        });
        mapper.registerModule(module);
    }
    return mapper;
}

/**
	 * Configure custom deserializers. Each deserializer is registered for the type
	 * returned by {@link JsonDeserializer#handledType()}, which must not be {@code null}.
	 * @since 4.3
	 * @see #deserializersByType(Map)
	 */
public Jackson2ObjectMapperBuilder deserializers(JsonDeserializer<?>... deserializers) {
    if (deserializers != null) {
        for (JsonDeserializer<?> deserializer : deserializers) {
            Class<?> handledType = deserializer.handledType();
            if (handledType == null || handledType == Object.class) {
                throw new IllegalArgumentException("Unknown handled type in " + deserializer.getClass().getName());
            }
            this.deserializers.put(deserializer.handledType(), deserializer);
        }
    }
    return this;
}

/**
     * Internal method used to init main ObjectMapper for JSON parsing
     *
     * @return initialized ObjectMapper ready for JSON parsing
     */
private static ObjectMapper initObjectMapper() {
    if (mapper == null) {
        /**
             * We don't have a reference to an ObjectMapper, so we need to read
             * from cache or instantiate a new one
             */
        if (usingCache) {
            mapper = (ObjectMapper) readFromCache(OBJECT_MAPPER);
            if (mapper != null) {
                // Successful read from the cache
                return mapper;
            }
        }
        // Jackson configuration
        mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
        mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
        mapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
        mapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // AlertHeaderText class is out of date and will throw an error if we try to deserialize
        // from latest OTP. Simply ignore for now.
        SimpleModule module = new SimpleModule();
        module.addDeserializer(AlertHeaderText.class, new JsonDeserializer<AlertHeaderText>() {

            @Override
            public AlertHeaderText deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
                Log.d(TAG, "Ignoring AlertHeaderText object.");
                return null;
            }
        });
        mapper.registerModule(module);
    }
    return mapper;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
private void applyMarshallersToModule(SimpleModule module, List<IMarshaller> marshallers) throws InstantiationException, IllegalAccessException {
    for (IMarshaller marshaller : marshallers) {
        Class<?> objectClass = marshaller.getObjectClass();
        if (objectClass != null) {
            module.addSerializer(objectClass, (JsonSerializer) marshaller.getSerializerClass().newInstance());
            module.addDeserializer(objectClass, (JsonDeserializer) marshaller.getDeserializerClass().newInstance());
        }
        Class<?> mixInType = marshaller.getMixinAnnotationType();
        Class<?> mixInClass = marshaller.getMixinAnnotationClass();
        if (mixInClass != null && mixInType != null) {
            module.setMixInAnnotation(mixInType, mixInClass);
        }
    }
}

@Test
public void testJsonSerialization() throws Exception {
    TestingTypeManager typeManager = new TestingTypeManager();
    TestingBlockEncodingSerde blockEncodingSerde = new TestingBlockEncodingSerde(typeManager);
    ObjectMapper mapper = new ObjectMapperProvider().get().registerModule(new SimpleModule().addDeserializer(ColumnHandle.class, new JsonDeserializer<ColumnHandle>() {

        @Override
        public ColumnHandle deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
            return new ObjectMapperProvider().get().readValue(jsonParser, TestingColumnHandle.class);
        }
    }).addDeserializer(Type.class, new TestingTypeDeserializer(typeManager)).addSerializer(Block.class, new TestingBlockJsonSerde.Serializer(blockEncodingSerde)).addDeserializer(Block.class, new TestingBlockJsonSerde.Deserializer(blockEncodingSerde)));
    TupleDomain<ColumnHandle> tupleDomain = TupleDomain.all();
    assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {
    }));
    tupleDomain = TupleDomain.none();
    assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {
    }));
    tupleDomain = TupleDomain.fromFixedValues(ImmutableMap.of(A, NullableValue.of(BIGINT, 1L), B, NullableValue.asNull(VARCHAR)));
    assertEquals(tupleDomain, mapper.readValue(mapper.writeValueAsString(tupleDomain), new TypeReference<TupleDomain<ColumnHandle>>() {
    }));
}

@Override
public Object deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    ClassLoader current = Thread.currentThread().getContextClassLoader();
    try {
        Thread.currentThread().setContextClassLoader(_baseType.getRawClass().getClassLoader());
        JsonDeserializer<Object> deser = _findDeserializer(ctxt, baseTypeName());
        Object value = deser.deserialize(jp, ctxt);
        return value;
    } finally {
        Thread.currentThread().setContextClassLoader(current);
    }
}

/**
	 * Creates a mapper with specific binding for Roboconf types.
	 * @return a non-null, configured mapper
	 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static ObjectMapper createObjectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    SimpleModule module = new SimpleModule("RoboconfModule", new Version(1, 0, 0, null, null, null));
    for (Map.Entry<Class<?>, ? super JsonSerializer<?>> entry : SERIALIZERS.entrySet()) module.addSerializer((Class) entry.getKey(), (JsonSerializer) entry.getValue());
    for (Map.Entry<Class<?>, ? super JsonDeserializer<?>> entry : DESERIALIZERS.entrySet()) module.addDeserializer((Class) entry.getKey(), (JsonDeserializer) entry.getValue());
    mapper.registerModule(module);
    return mapper;
}

default JsonDeserializer<ShimDataResponse> getNormalizer() {
    return null;
}

public void addDeserializer(Class<Class> clazz, JsonDeserializer<Class> deserializer) {
    happyModules.addDeserializer(clazz, deserializer);
    registerModule(happyModules);
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
    return deserializer instanceof BeanDeserializer ? new ExtensibleObjectDeserializer((BeanDeserializer) deserializer) : deserializer;
}

@SuppressWarnings("unchecked")
@Override
public MetaData deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonDeserializer<Object> deserializer = ctxt.findRootValueDeserializer(ctxt.getTypeFactory().constructMapType(Map.class, String.class, Object.class));
    return MetaData.from((Map) deserializer.deserialize(jp, ctxt, new HashMap<>()));
}

@Override
public JsonDeserializer<?> deserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> deserClass) {
    return (JsonDeserializer<?>) this.beanFactory.createBean(deserClass);
}

@Override
@SuppressWarnings("unchecked")
public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp, final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName) throws IOException {
    if (beanOrClass != null && type.isAssignableFrom(beanOrClass.getClass())) {
        configure((T) beanOrClass, propertyName, jp.getValueAsString());
        return true;
    }
    return false;
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
    if (deserializer instanceof BeanDeserializerBase) {
        return new DataBinderDeserializer((BeanDeserializerBase) deserializer);
    }
    // default jackson deserializer
    return deserializer;
}

@Override
public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) throws IOException, JsonProcessingException {
    Log.error("Ignoring unknown property [{}] while deserializing [{}]", propertyName, beanOrClass);
    return true;
}

/**
     * Factory method for a JodaCustomDateTimeDeserializer.
     * @param cls The class to deserialize.
     * @param dateTimeFormatter The Joda Time formatter for DateTime objects.
     * @param <T> The type to deserialize.
     * @return A new JodaCustomDateTimeDeserializer.
     */
@SuppressWarnings("unchecked")
public static <T extends ReadableInstant> JsonDeserializer<T> forType(Class<T> cls, DateTimeFormatter dateTimeFormatter) {
    return (JsonDeserializer<T>) new JodaCustomDateTimeDeserializer(cls, dateTimeFormatter);
}

@Override
public JsonDeserializer<?> createContextual(final DeserializationContext deserializationContext, final BeanProperty property) throws JsonMappingException {
    final JavaType valueType = deserializationContext.getContextualType().containedType(0);
    final CloseableIterableDeserializer deserializer = new CloseableIterableDeserializer();
    deserializer.valueType = valueType;
    return deserializer;
}

@Override
public JsonDeserializer<?> findBeanDeserializer(JavaType type, DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException {
    Class<?> candidateTT = type.getRawClass();
    if (MetaTinyTypes.isTinyType(candidateTT)) {
        return new TinyTypesDeserializer(candidateTT);
    }
    return null;
}

private static JsonDeserializer<ObjectId> _idDeserializer() {
    return new JsonDeserializer<ObjectId>() {

        public ObjectId deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
            return new ObjectId(jp.readValueAs(String.class));
        }
    };
}

@Override
public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) {
    fail(String.format("Found unexpected property %s in payload for %s", propertyName, beanOrClass.getClass().getName()));
    return false;
}

@Override
public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser jp, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName) {
    fail(String.format("Found unexpected property %s in payload for %s", propertyName, beanOrClass.getClass().getName()));
    return false;
}

@Override
public JsonDeserializer<?> modifyDeserializer(DeserializationConfig deserializationConfig, BeanDescription beanDescription, JsonDeserializer<?> jsonDeserializer) {
    if (Case.class.isAssignableFrom(beanDescription.getBeanClass())) {
        return new CaseDeserializer(jsonDeserializer);
    }
    return jsonDeserializer;
}

/**
	 * Configure custom deserializers for the given types.
	 *
	 * @param deserializers deserializers
	 */
public void setDeserializersByType(Map<Class<?>, JsonDeserializer<?>> deserializers) {
    if (deserializers != null) {
        this.deserializers.putAll(deserializers);
    }
}