How to use

DefaultDeserializationContext

in

com.fasterxml.jackson.databind.deser

/**
 * Internal helper method called to create an instance of {@link DeserializationContext}
 * for deserializing a single root value.
 * Can be overridden if a custom context is needed.
 */
protected DefaultDeserializationContext createDeserializationContext(JsonParser p) {
  return _context.createInstance(_config, p, _injectableValues);
}

/**
 * Method similar to {@link #canDeserialize(JavaType)} but that can return
 * actual {@link Throwable} that was thrown when trying to construct
 * serializer: this may be useful in figuring out what the actual problem is.
 * 
 * @since 2.3
 */
public boolean canDeserialize(JavaType type, AtomicReference<Throwable> cause)
{
  return createDeserializationContext(null,
      getDeserializationConfig()).hasValueDeserializerFor(type, cause);
}

@Override
public void addKeyDeserializers(KeyDeserializers d) {
  DeserializerFactory df = _deserializationContext._factory.withAdditionalKeyDeserializers(d);
  _deserializationContext = _deserializationContext.with(df);
}

if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
  return;
  if (tryToResolveUnresolvedObjectId(roid)) {
    continue;
    exception = new UnresolvedForwardReference(getParser(), "Unresolved forward references for: ");

@Override
public void addBeanDeserializerModifier(BeanDeserializerModifier modifier) {
  DeserializerFactory df = _deserializationContext._factory.withDeserializerModifier(modifier);
  _deserializationContext = _deserializationContext.with(df);
}

@Override
public void addAbstractTypeResolver(AbstractTypeResolver resolver) {
  DeserializerFactory df = _deserializationContext._factory.withAbstractTypeResolver(resolver);
  _deserializationContext = _deserializationContext.with(df);
}

@Override
public void addValueInstantiators(ValueInstantiators instantiators) {
  DeserializerFactory df = _deserializationContext._factory.withValueInstantiators(instantiators);
  _deserializationContext = _deserializationContext.with(df);
}

@Override
public void addDeserializers(Deserializers d) {
  DeserializerFactory df = _deserializationContext._factory.withAdditionalDeserializers(d);
  _deserializationContext = _deserializationContext.with(df);
}

    _mixIns, rootNames,  _configOverrides);
_serializerProvider = src._serializerProvider.copy();
_deserializationContext = src._deserializationContext.copy();

@Override
public void checkUnresolvedObjectId() throws UnresolvedForwardReference
{
  if (_objectIds == null) {
    return;
  }
  // 29-Dec-2014, tatu: As per [databind#299], may also just let unresolved refs be...
  if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
    return;
  }
  UnresolvedForwardReference exception = null;
  for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) {
    ReadableObjectId roid = entry.getValue();
    if (roid.hasReferringProperties()) {
      if (exception == null) {
        exception = new UnresolvedForwardReference("Unresolved forward references for: ");
      }
      for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) {
        Referring referring = iterator.next();
        exception.addUnresolvedId(roid.getKey().key, referring.getBeanType(), referring.getLocation());
      }
    }
  }
  if (exception != null) {
    throw exception;
  }
}

ReadableObjectId entry = createReadableObjectId(key);
entry.setResolver(resolver);
_objectIds.put(key, entry);

@Override
public void addBeanDeserializerModifier(BeanDeserializerModifier modifier) {
  DeserializerFactory df = mapper._deserializationContext._factory.withDeserializerModifier(modifier);
  mapper._deserializationContext = mapper._deserializationContext.with(df);
}

@Override
public void addAbstractTypeResolver(AbstractTypeResolver resolver) {
  DeserializerFactory df = mapper._deserializationContext._factory.withAbstractTypeResolver(resolver);
  mapper._deserializationContext = mapper._deserializationContext.with(df);
}

@Override
public void addValueInstantiators(ValueInstantiators instantiators) {
  DeserializerFactory df = _deserializationContext._factory.withValueInstantiators(instantiators);
  _deserializationContext = _deserializationContext.with(df);
}

@Override
public void addDeserializers(Deserializers d) {
  DeserializerFactory df = mapper._deserializationContext._factory.withAdditionalDeserializers(d);
  mapper._deserializationContext = mapper._deserializationContext.with(df);
}

if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
  return;
  if (tryToResolveUnresolvedObjectId(roid)) {
    continue;
    exception = new UnresolvedForwardReference(getParser(), "Unresolved forward references for: ");

@Override
public DefaultDeserializationContext copy() {
  if (getClass() != Impl.class) {
    return super.copy();
  }
  return new Impl(this);
}

@Override
public void checkUnresolvedObjectId() throws UnresolvedForwardReference
{
  if (_objectIds == null) {
    return;
  }
  // 29-Dec-2014, tatu: As per [databind#299], may also just let unresolved refs be...
  if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
    return;
  }
  UnresolvedForwardReference exception = null;
  for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) {
    ReadableObjectId roid = entry.getValue();
    if (roid.hasReferringProperties()) {
      if (exception == null) {
        exception = new UnresolvedForwardReference("Unresolved forward references for: ");
      }
      for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) {
        Referring referring = iterator.next();
        exception.addUnresolvedId(roid.getKey().key, referring.getBeanType(), referring.getLocation());
      }
    }
  }
  if (exception != null) {
    throw exception;
  }
}

ReadableObjectId entry = createReadableObjectId(key);
entry.setResolver(resolver);
_objectIds.put(key, entry);

/**
 * Method that can be called to check whether mapper thinks
 * it could deserialize an Object of given type.
 * Check is done by checking whether a registered deserializer can
 * be found or built for the type; if not (either by no mapping being
 * found, or through an <code>Exception</code> being thrown, false
 * is returned.
 *<p>
 * <b>NOTE</b>: in case an exception is thrown during course of trying
 * co construct matching deserializer, it will be effectively swallowed.
 * If you want access to that exception, call
 * {@link #canDeserialize(JavaType, AtomicReference)} instead.
 *
 * @return True if mapper can find a serializer for instances of
 *  given class (potentially serializable), false otherwise (not
 *  serializable)
 */
public boolean canDeserialize(JavaType type)
{
  return createDeserializationContext(null,
      getDeserializationConfig()).hasValueDeserializerFor(type, null);
}