Java 类com.fasterxml.jackson.databind.jsontype.TypeDeserializer 实例源码

/**
 * Method called to finalize setup of this deserializer,
 * after deserializer itself has been registered. This
 * is needed to handle recursive and transitive dependencies.
 */
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
                                            BeanProperty property) throws JsonMappingException {
    JsonDeserializer<?> deser = _valueDeserializer;
    TypeDeserializer typeDeser = _typeDeserializerForValue;
    if (deser == null) {
        deser = ctxt.findContextualValueDeserializer(_containerType.getContentType(), property);
    }
    if (typeDeser != null) {
        typeDeser = typeDeser.forProperty(property);
    }
    if (deser == _valueDeserializer && typeDeser == _typeDeserializerForValue) {
        return this;
    }
    return withResolved(typeDeser, deser);
}

@Override
protected T _deserializeFromSingleValue(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonDeserializer<?> valueDes = _valueDeserializer;
    final TypeDeserializer typeDeser = _typeDeserializerForValue;
    JsonToken t = jp.getCurrentToken();

    Object value;

    if (t == JsonToken.VALUE_NULL) {
        value = null;
    } else if (typeDeser == null) {
        value = valueDes.deserialize(jp, ctxt);
    } else {
        value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
    }
    @SuppressWarnings("unchecked")
    T result = (T) Sequences.sequence(value);
    return result;
}

/**
 * Method called to finalize setup of this deserializer,
 * after deserializer itself has been registered. This
 * is needed to handle recursive and transitive dependencies.
 */
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
                                            BeanProperty property) throws JsonMappingException {
    JsonDeserializer<?> deser = _valueDeserializer;
    TypeDeserializer typeDeser = _typeDeserializerForValue;
    if (deser == null) {
        deser = ctxt.findContextualValueDeserializer(_containerType.getContentType(), property);
    }
    if (typeDeser != null) {
        typeDeser = typeDeser.forProperty(property);
    }
    if (deser == _valueDeserializer && typeDeser == _typeDeserializerForValue) {
        return this;
    }
    return withResolved(typeDeser, deser);
}

@Override
protected T _deserializeFromSingleValue(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonDeserializer<?> valueDes = _valueDeserializer;
    final TypeDeserializer typeDeser = _typeDeserializerForValue;
    JsonToken t = jp.getCurrentToken();

    Object value;

    if (t == JsonToken.VALUE_NULL) {
        value = null;
    } else if (typeDeser == null) {
        value = valueDes.deserialize(jp, ctxt);
    } else {
        value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
    }
    @SuppressWarnings("unchecked")
    T result = (T) Sequences.sequence(value);
    return result;
}

@Override
public JsonDeserializer<?> findCollectionLikeDeserializer(CollectionLikeType type,
                                                          DeserializationConfig config, BeanDescription beanDesc,
                                                          TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    if (raw == CharSeq.class) {
        return new CharSeqDeserializer(type);
    }
    if (Seq.class.isAssignableFrom(raw)) {
        return new SeqDeserializer(type, settings.deserializeNullAsEmptyCollection());
    }
    if (Set.class.isAssignableFrom(raw)) {
        return new SetDeserializer(type, settings.deserializeNullAsEmptyCollection());
    }
    if (PriorityQueue.class.isAssignableFrom(raw)) {
        return new PriorityQueueDeserializer(type, settings.deserializeNullAsEmptyCollection());
    }
    return super.findCollectionLikeDeserializer(type, config, beanDesc, elementTypeDeserializer, elementDeserializer);
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer,
                                                   TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    if (Map.class.isAssignableFrom(raw)) {
        return new MapDeserializer(type);
    }
    if (Multimap.class.isAssignableFrom(raw)) {
        return new MultimapDeserializer(type);
    }
    return super.findMapLikeDeserializer(type, config, beanDesc, keyDeserializer, elementTypeDeserializer, elementDeserializer);
}

public TypeDeserializer buildTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, Collection<NamedType> paramCollection)
{
  if (this._idType == JsonTypeInfo.Id.NONE)
    return null;
  TypeIdResolver localTypeIdResolver = idResolver(paramDeserializationConfig, paramJavaType, paramCollection, false, true);
  switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$As[this._includeAs.ordinal()])
  {
  default:
    break;
  case 1:
    return new AsArrayTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl);
  case 2:
    return new AsPropertyTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl);
  case 3:
    return new AsWrapperTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl);
  case 4:
    return new AsExternalTypeDeserializer(paramJavaType, localTypeIdResolver, this._typeProperty, this._typeIdVisible, this._defaultImpl);
  }
  throw new IllegalStateException("Do not know how to construct standard type serializer for inclusion type: " + this._includeAs);
}

@SuppressWarnings("unchecked")
protected T _deserializeEntries(JsonParser jp, DeserializationContext ctxt) throws IOException {
    final KeyDeserializer keyDes = keyDeserializer;
    final JsonDeserializer<?> valueDes = valueDeserializer;
    final TypeDeserializer typeDeser = typeDeserializerForValue;

    MapF<Object, Object> map = newInstance();

    for (; jp.getCurrentToken() == JsonToken.FIELD_NAME; jp.nextToken()) {
        String fieldName = jp.getCurrentName();
        Object key = (keyDes == null) ? fieldName : keyDes.deserializeKey(fieldName, ctxt);
        JsonToken t = jp.nextToken();
        Object value;
        if (t == JsonToken.VALUE_NULL) {
            value = null;
        } else if (typeDeser == null) {
            value = valueDes.deserialize(jp, ctxt);
        } else {
            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
        map.put(key, value);
    }
    return (T) map.unmodifiable();
}

public JsonDeserializer<?> createMapLikeDeserializer(DeserializationContext paramDeserializationContext, MapLikeType paramMapLikeType, BeanDescription paramBeanDescription)
{
  JavaType localJavaType1 = paramMapLikeType.getKeyType();
  JavaType localJavaType2 = paramMapLikeType.getContentType();
  DeserializationConfig localDeserializationConfig = paramDeserializationContext.getConfig();
  JsonDeserializer localJsonDeserializer1 = (JsonDeserializer)localJavaType2.getValueHandler();
  KeyDeserializer localKeyDeserializer = (KeyDeserializer)localJavaType1.getValueHandler();
  TypeDeserializer localTypeDeserializer1 = (TypeDeserializer)localJavaType2.getTypeHandler();
  TypeDeserializer localTypeDeserializer2 = localTypeDeserializer1;
  if (localTypeDeserializer1 == null)
    localTypeDeserializer2 = findTypeDeserializer(localDeserializationConfig, localJavaType2);
  JsonDeserializer localJsonDeserializer2 = _findCustomMapLikeDeserializer(paramMapLikeType, localDeserializationConfig, paramBeanDescription, localKeyDeserializer, localTypeDeserializer2, localJsonDeserializer1);
  JsonDeserializer localJsonDeserializer3 = localJsonDeserializer2;
  if ((localJsonDeserializer2 != null) && (this._factoryConfig.hasDeserializerModifiers()))
  {
    Iterator localIterator = this._factoryConfig.deserializerModifiers().iterator();
    while (localIterator.hasNext())
      localJsonDeserializer3 = ((BeanDeserializerModifier)localIterator.next()).modifyMapLikeDeserializer(localDeserializationConfig, paramMapLikeType, paramBeanDescription, localJsonDeserializer3);
  }
  return localJsonDeserializer3;
}

public TypeDeserializer findTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType)
{
  AnnotatedClass localAnnotatedClass = paramDeserializationConfig.introspectClassAnnotations(paramJavaType.getRawClass()).getClassInfo();
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationConfig.getAnnotationIntrospector();
  Object localObject = localAnnotationIntrospector.findTypeResolver(paramDeserializationConfig, localAnnotatedClass, paramJavaType);
  Collection localCollection;
  if (localObject == null)
  {
    TypeResolverBuilder localTypeResolverBuilder = paramDeserializationConfig.getDefaultTyper(paramJavaType);
    localObject = localTypeResolverBuilder;
    localCollection = null;
    if (localTypeResolverBuilder == null)
      return null;
  }
  else
  {
    localCollection = paramDeserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(localAnnotatedClass, paramDeserializationConfig, localAnnotationIntrospector);
  }
  if ((((TypeResolverBuilder)localObject).getDefaultImpl() == null) && (paramJavaType.isAbstract()))
  {
    JavaType localJavaType = mapAbstractType(paramDeserializationConfig, paramJavaType);
    if ((localJavaType != null) && (localJavaType.getRawClass() != paramJavaType.getRawClass()))
      localObject = ((TypeResolverBuilder)localObject).defaultImpl(localJavaType.getRawClass());
  }
  return ((TypeResolverBuilder)localObject).buildTypeDeserializer(paramDeserializationConfig, paramJavaType, localCollection);
}

@SuppressWarnings("unchecked")
protected T _deserializeSingle(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonDeserializer<?> valueDes = valueDeserializer;
    final TypeDeserializer typeDeser = typeDeserializerForValue;
    CollectionF<Object> collection = newInstance();

    Object value;

    if (jp.getCurrentToken() == JsonToken.VALUE_NULL) {
        value = valueDes.getNullValue();
    } else if (typeDeser == null) {
        value = valueDes.deserialize(jp, ctxt);
    } else {
        value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
    }
    collection.add(value);
    return (T) collection.unmodifiable();
}

public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException {
    KeyDeserializer keyDeser = keyDeserializer;
    JsonDeserializer<?> deser = valueDeserializer;
    TypeDeserializer typeDeser = typeDeserializerForValue;

    if ((keyDeser != null) && (deser != null) && (typeDeser == null)) {
        return this;
    }
    if (keyDeser == null) {
        keyDeser = ctxt.findKeyDeserializer(mapType.getKeyType(), property);
    }
    if (deser == null) {
        deser = ctxt.findContextualValueDeserializer(mapType.getContentType(), property);
    }
    if (typeDeser != null) {
        typeDeser = typeDeser.forProperty(property);
    }
    return withResolved(keyDeser, typeDeser, deser);
}

@Override
public JsonDeserializer<?> findCollectionDeserializer(CollectionType type, DeserializationConfig config, BeanDescription beanDesc,
        TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) throws JsonMappingException
{
    Class<?> raw = type.getRawClass();
    if (CollectionF.class.isAssignableFrom(raw)) {
        if (Option.class.isAssignableFrom(raw)) {
            return new OptionDeserializer(type, elementTypeDeserializer, elementDeserializer);
        }
        if (ListF.class.isAssignableFrom(raw)) {
            return new ListFDeserializer(type, elementTypeDeserializer, elementDeserializer);
        }
        if (SetF.class.isAssignableFrom(raw)) {
            return new SetFDeserializer(type, elementTypeDeserializer, elementDeserializer);
        }
        return new ListFDeserializer(type, elementTypeDeserializer, elementDeserializer);
    }
    return null;
}

public Collection<Object> deserialize(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Collection<Object> paramCollection)
{
  if (!paramJsonParser.isExpectedStartArrayToken())
    return handleNonArray(paramJsonParser, paramDeserializationContext, paramCollection);
  JsonDeserializer localJsonDeserializer = this._valueDeserializer;
  TypeDeserializer localTypeDeserializer = this._valueTypeDeserializer;
  while (true)
  {
    JsonToken localJsonToken = paramJsonParser.nextToken();
    if (localJsonToken == JsonToken.END_ARRAY)
      break;
    Object localObject;
    if (localJsonToken == JsonToken.VALUE_NULL)
      localObject = null;
    else if (localTypeDeserializer == null)
      localObject = localJsonDeserializer.deserialize(paramJsonParser, paramDeserializationContext);
    else
      localObject = localJsonDeserializer.deserializeWithType(paramJsonParser, paramDeserializationContext, localTypeDeserializer);
    paramCollection.add(localObject);
  }
  return paramCollection;
}

@SuppressWarnings("unchecked")
protected T _deserializeContents(JsonParser jp, DeserializationContext ctxt) throws IOException {
    JsonDeserializer<?> valueDes = valueDeserializer;
    JsonToken t;
    final TypeDeserializer typeDeser = typeDeserializerForValue;
    CollectionF<Object> collection = newInstance();

    while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
        Object value;

        if (t == JsonToken.VALUE_NULL) {
            value = valueDes.getNullValue();
        } else if (typeDeser == null) {
            value = valueDes.deserialize(jp, ctxt);
        } else {
            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
        collection.add(value);
    }
    return (T) collection.unmodifiable();
}

protected final Collection<Object> handleNonArray(JsonParser paramJsonParser, DeserializationContext paramDeserializationContext, Collection<Object> paramCollection)
{
  if (!paramDeserializationContext.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY))
    throw paramDeserializationContext.mappingException(this._collectionType.getRawClass());
  JsonDeserializer localJsonDeserializer = this._valueDeserializer;
  TypeDeserializer localTypeDeserializer = this._valueTypeDeserializer;
  Object localObject;
  if (paramJsonParser.getCurrentToken() == JsonToken.VALUE_NULL)
    localObject = null;
  else if (localTypeDeserializer == null)
    localObject = localJsonDeserializer.deserialize(paramJsonParser, paramDeserializationContext);
  else
    localObject = localJsonDeserializer.deserializeWithType(paramJsonParser, paramDeserializationContext, localTypeDeserializer);
  paramCollection.add(localObject);
  return paramCollection;
}

public SettableBeanProperty(String paramString, JavaType paramJavaType, PropertyName paramPropertyName, TypeDeserializer paramTypeDeserializer, Annotations paramAnnotations, boolean paramBoolean)
{
  if ((paramString == null) || (paramString.length() == 0))
    this._propName = "";
  else
    this._propName = InternCache.instance.intern(paramString);
  this._type = paramJavaType;
  this._wrapperName = paramPropertyName;
  this._isRequired = paramBoolean;
  this._contextAnnotations = paramAnnotations;
  this._viewMatcher = null;
  this._nullProvider = null;
  if (paramTypeDeserializer != null)
    paramTypeDeserializer = paramTypeDeserializer.forProperty(this);
  this._valueTypeDeserializer = paramTypeDeserializer;
  this._valueDeserializer = MISSING_VALUE_DESERIALIZER;
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type, DeserializationConfig config,
                                               BeanDescription beanDesc, KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer) {

    return forJavaType(type);
}

@Override
public Object deserializeWithType(JsonParser parser, DeserializationContext context,
        TypeDeserializer deserializer)
    throws IOException
{
    /* This is a nasty kludge right here, working around issues like
     * [datatype-jsr310#24]. But should work better than not having the work-around.
     */
    JsonToken t = parser.currentToken();
    if ((t != null) && t.isScalarValue()) {
        return deserialize(parser, context);
    }
    return deserializer.deserializeTypedFromAny(parser, context);
}

@Override
public Object deserializeWithType(JsonParser parser, DeserializationContext context,
        TypeDeserializer typeDeserializer)
    throws IOException
{
    return typeDeserializer.deserializeTypedFromAny(parser, context);
}

@Override
public TypeDeserializer buildTypeDeserializer(DeserializationConfig config, JavaType baseType, Collection<NamedType> subtypes) {
    final TypeNameIdResolver typeNameIdResolver = TypeNameIdResolver.construct(config, baseType, subtypes, false, true);
    return new MetadataTypeDeserializer(
            baseType,
            typeNameIdResolver,
            this.defaultImpl == null ? null : config.getTypeFactory().constructSpecializedType(baseType, this.defaultImpl));
}

public PairDeserial(JavaType type,
                    KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
                    TypeDeserializer valueTypeDeser) {
    super(type);
    this.javaType = type;
    this._keyDeserializer = keyDeser;
    this._valueDeserializer = valueDeser;
    this._valueTypeDeserializer = valueTypeDeser;
}

protected TotallylazyCollectionDeserializer(CollectionType type,
                                            TypeDeserializer typeDeser, JsonDeserializer<?> deser) {
    super(type);
    _containerType = type;
    _typeDeserializerForValue = typeDeser;
    _valueDeserializer = deser;
}

/**
 * Base implementation that does not assume specific type
 * inclusion mechanism. Sub-classes are expected to override
 * this method if they are to handle type information.
 */
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
                                  TypeDeserializer typeDeserializer)
        throws IOException, JsonProcessingException {
    return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
}

/**
 * We have plenty of collection types to support...
 */
@Override
public JsonDeserializer<?> findCollectionDeserializer(CollectionType type,
                                                      DeserializationConfig config, BeanDescription beanDesc,
                                                      TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return new SequenceDeserializer(type,
            elementTypeDeserializer, elementDeserializer);
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type,
                                               DeserializationConfig config, BeanDescription beanDesc,
                                               KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer,
                                                   JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
protected T _deserializeContents(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonDeserializer<?> valueDes = _valueDeserializer;
    JsonToken t;
    final TypeDeserializer typeDeser = _typeDeserializerForValue;
    // No way to pass actual type parameter; but does not matter, just
    // compiler-time fluff:
    Sequence<Object> sequence = Sequences.sequence();

    while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
        Object value;

        if (t == JsonToken.VALUE_NULL) {
            value = null;
        } else if (typeDeser == null) {
            value = valueDes.deserialize(jp, ctxt);
        } else {
            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
        sequence = sequence.append(value);
    }
    // No class outside of the package will be able to subclass us,
    // and we provide the proper builder for the subclasses we implement.
    @SuppressWarnings("unchecked")
    T collection = (T) sequence;
    return collection;
}

@Override
public Object deserializeWithType(JsonParser parser, DeserializationContext context, TypeDeserializer deserializer)
        throws IOException {
    /**
     * This is a nasty kludge right here, working around issues like
     * [datatype-jsr310#24]. But should work better than not having the work-around.
     */
    if (parser.getCurrentToken().isScalarValue()) {
        return deserialize(parser, context);
    }
    return deserializer.deserializeTypedFromAny(parser, context);
}

protected TotallylazyCollectionDeserializer(CollectionType type,
                                            TypeDeserializer typeDeser, JsonDeserializer<?> deser) {
    super(type);
    _containerType = type;
    _typeDeserializerForValue = typeDeser;
    _valueDeserializer = deser;
}

/**
 * Base implementation that does not assume specific type
 * inclusion mechanism. Sub-classes are expected to override
 * this method if they are to handle type information.
 */
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
                                  TypeDeserializer typeDeserializer)
        throws IOException, JsonProcessingException {
    return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
}

/**
 * We have plenty of collection types to support...
 */
@Override
public JsonDeserializer<?> findCollectionDeserializer(CollectionType type,
                                                      DeserializationConfig config, BeanDescription beanDesc,
                                                      TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return new SequenceDeserializer(type,
            elementTypeDeserializer, elementDeserializer);
}

@Override
public JsonDeserializer<?> findMapDeserializer(MapType type,
                                               DeserializationConfig config, BeanDescription beanDesc,
                                               KeyDeserializer keyDeserializer,
                                               TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
public JsonDeserializer<?> findMapLikeDeserializer(MapLikeType type,
                                                   DeserializationConfig config, BeanDescription beanDesc,
                                                   KeyDeserializer keyDeserializer, TypeDeserializer elementTypeDeserializer,
                                                   JsonDeserializer<?> elementDeserializer)
        throws JsonMappingException {
    return null;
}

@Override
protected T _deserializeContents(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonDeserializer<?> valueDes = _valueDeserializer;
    JsonToken t;
    final TypeDeserializer typeDeser = _typeDeserializerForValue;
    // No way to pass actual type parameter; but does not matter, just
    // compiler-time fluff:
    Sequence<Object> sequence = Sequences.sequence();

    while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
        Object value;

        if (t == JsonToken.VALUE_NULL) {
            value = null;
        } else if (typeDeser == null) {
            value = valueDes.deserialize(jp, ctxt);
        } else {
            value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
        }
        sequence = sequence.append(value);
    }
    // No class outside of the package will be able to subclass us,
    // and we provide the proper builder for the subclasses we implement.
    @SuppressWarnings("unchecked")
    T collection = (T) sequence;
    return collection;
}

@Override
public Object deserializeWithType(final JsonParser parser, final DeserializationContext context,
        final TypeDeserializer deserializer) throws IOException {

    // effectively assuming no type information at all
    return deserialize(parser, context);
}

@Override
public Object deserializeWithType(final JsonParser parser, final DeserializationContext context,
        final TypeDeserializer deserializer) throws IOException {

    // effectively assuming no type information at all
    return deserialize(parser, context);
}

@Override
public JsonDeserializer<?> findReferenceDeserializer(ReferenceType type,
                                                     DeserializationConfig config, BeanDescription beanDesc,
                                                     TypeDeserializer contentTypeDeserializer, JsonDeserializer<?> contentDeserializer)
        throws JsonMappingException {
    Class<?> raw = type.getRawClass();
    if (raw == Lazy.class) {
        return new LazyDeserializer(type);
    }
    if (raw == Option.class) {
        return new OptionDeserializer(type, settings.useOptionInPlainFormat());
    }
    return super.findReferenceDeserializer(type, config, beanDesc, contentTypeDeserializer, contentDeserializer);
}

@Override
public JsonDeserializer<?> createContextual(DeserializationContext context, BeanProperty property)
        throws JsonMappingException
{
    JsonDeserializer<?> firstDeserializer = this.firstDeserializer;
    JsonDeserializer<?> secondDeserializer = this.secondDeserializer;
    TypeDeserializer firstTypeDeserializer = this.firstTypeDeserializer;
    TypeDeserializer secondTypeDeserializer = this.secondTypeDeserializer;

    if (firstDeserializer == null) {
        firstDeserializer = context.findContextualValueDeserializer(firstType, property);
    }

    if (secondDeserializer == null) {
        secondDeserializer = context.findContextualValueDeserializer(secondType, property);
    }
    if (firstTypeDeserializer != null) {
        firstTypeDeserializer = firstTypeDeserializer.forProperty(property);
    }
    if (secondTypeDeserializer != null) {
        secondTypeDeserializer = secondTypeDeserializer.forProperty(property);
    }
    if (firstDeserializer != this.firstDeserializer
            || secondDeserializer != this.secondDeserializer
            || firstTypeDeserializer != this.firstTypeDeserializer
            || secondTypeDeserializer != this.secondTypeDeserializer)
    {
        return new Tuple2Deserializer(firstType, secondType, firstDeserializer, secondDeserializer,
                firstTypeDeserializer, secondTypeDeserializer);
    }
    return this;
}

public Tuple2Deserializer(JavaType firstType, JavaType secondType,
        JsonDeserializer<?> firstDeserializer, JsonDeserializer<?> secondDeserializer,
        TypeDeserializer firstTypeDeserializer, TypeDeserializer secondTypeDeserializer)
{
    super(Tuple2.class);
    this.firstType = firstType;
    this.secondType = secondType;
    this.firstDeserializer = firstDeserializer;
    this.secondDeserializer = secondDeserializer;
    this.firstTypeDeserializer = firstTypeDeserializer;
    this.secondTypeDeserializer = secondTypeDeserializer;
}