Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package com.fasterxml.jackson.databind.deser;
   
   import java.io.IOException;
   import java.util.*;
   
  
Base class for BeanDeserializer.
  
  public abstract class BeanDeserializerBase
      extends StdDeserializer<Object>
          java.io.Serializable // since 2.1
  {
      private static final long serialVersionUID = -2038793552422727904L;
  
      /*
      /**********************************************************
      /* Information regarding type being deserialized
      /**********************************************************
       */

    
Annotations from the bean class: used for accessing annotations during resolution (see resolve(com.fasterxml.jackson.databind.DeserializationContext)) and contextualization (see createContextual(com.fasterxml.jackson.databind.DeserializationContext,com.fasterxml.jackson.databind.BeanProperty))

Transient since annotations only used during construction.

  
      final private transient Annotations _classAnnotations;

    
Declared type of the bean this deserializer handles.
  
      final protected JavaType _beanType;

    
Requested shape from bean class annotations.
  
      final protected JsonFormat.Shape _serializationShape;
      
      /*
      /**********************************************************
      /* Configuration for creating value instance
      /**********************************************************
       */

    
Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())
  
      protected final ValueInstantiator _valueInstantiator;
    
    
Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.
  
      protected JsonDeserializer<Object_delegateDeserializer;
    
    
If the bean needs to be instantiated using constructor or factory method that takes one or more named properties as argument(s), this creator is used for instantiation. This value gets resolved during general resolution.
  
      protected PropertyBasedCreator _propertyBasedCreator;

    
Flag that is set to mark "non-standard" cases; where either we use one of non-default creators, or there are unwrapped values to consider.
  
      protected boolean _nonStandardCreation;

    
Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.
  
     protected boolean _vanillaProcessing;
 
     /*
     /**********************************************************
     /* Property information, setters
     /**********************************************************
      */

    
Mapping of property names to properties, built when all properties to use have been successfully resolved.
 
     final protected BeanPropertyMap _beanProperties;
    
    
List of com.fasterxml.jackson.databind.deser.impl.ValueInjectors, if any injectable values are expected by the bean; otherwise null. This includes injectors used for injecting values via setters and fields, but not ones passed through constructor parameters.
 
     final protected ValueInjector[] _injectables;
    
    
Fallback setter used for handling any properties that are not mapped to regular setters. If setter is not null, it will be called once for each such property.
 
     protected SettableAnyProperty _anySetter;

    
In addition to properties that are set, we will also keep track of recognized but ignorable properties: these will be skipped without errors or warnings.
 
     final protected HashSet<String_ignorableProps;

    
Flag that can be set to ignore and skip unknown properties. If set, will not throw an exception for unknown properties.
 
     final protected boolean _ignoreAllUnknown;

    
Flag that indicates that some aspect of deserialization depends on active view used (if any)
 
     final protected boolean _needViewProcesing;
    
    
We may also have one or more back reference fields (usually zero or one).
 
     final protected Map<StringSettableBeanProperty_backRefs;
     
     /*
     /**********************************************************
     /* Related handlers
     /**********************************************************
      */

    
Lazily constructed map used to contain deserializers needed for polymorphic subtypes. Note that this is only needed for polymorphic types, that is, when the actual type is not statically known. For other types this remains null.
 
     protected transient HashMap<ClassKeyJsonDeserializer<Object>> _subDeserializers;

    
If one of properties has "unwrapped" value, we need separate helper object
 
Handler that we need iff any of properties uses external type id.
 
     protected ExternalTypeHandler _externalTypeIdHandler;

    
If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.
 
     protected final ObjectIdReader _objectIdReader;
 
     /*
     /**********************************************************
     /* Life-cycle, construction, initialization
     /**********************************************************
      */

    
Constructor used when initially building a deserializer instance, given a BeanDeserializerBuilder that contains configuration.
 
     protected BeanDeserializerBase(BeanDeserializerBuilder builder,
             BeanDescription beanDesc,
             BeanPropertyMap propertiesMap<StringSettableBeanPropertybackRefs,
             HashSet<StringignorablePropsboolean ignoreAllUnknown,
             boolean hasViews)
     {
         super(beanDesc.getType());
 
         AnnotatedClass ac = beanDesc.getClassInfo();
          = ac.getAnnotations();       
          = beanDesc.getType();
          = builder.getValueInstantiator();
         
          = properties;
          = backRefs;
          = ignorableProps;
          = ignoreAllUnknown;
 
          = builder.getAnySetter();
         List<ValueInjectorinjectables = builder.getInjectables();
          = (injectables == null || injectables.isEmpty()) ? null
                 : injectables.toArray(new ValueInjector[injectables.size()]);
          = builder.getObjectIdReader();
          = ( != null)
             || .canCreateUsingDelegate()
             || .canCreateFromObjectWith()
             || !.canCreateUsingDefault()
             ;
 
         // Any transformation we may need to apply?
         JsonFormat.Value format = beanDesc.findExpectedFormat(null);
          = (format == null) ? null : format.getShape();
 
          = hasViews;
                 && ( == null)
                 && !
                 // also, may need to reorder stuff if we expect Object Id:
                 && ( != null)
                 ;
     }
 
     {
         this(srcsrc._ignoreAllUnknown);
     }
 
     protected BeanDeserializerBase(BeanDeserializerBase srcboolean ignoreAllUnknown)
     {
         super(src._beanType);
         
          = src._classAnnotations;
          = src._beanType;
         
          = src._valueInstantiator;
          = src._delegateDeserializer;
          = src._propertyBasedCreator;
         
          = src._beanProperties;
          = src._backRefs;
          = src._ignorableProps;
          = ignoreAllUnknown;
          = src._anySetter;
          = src._injectables;
          = src._objectIdReader;
         
          = src._nonStandardCreation;
          = src._unwrappedPropertyHandler;
          = src._needViewProcesing;
          = src._serializationShape;
 
          = src._vanillaProcessing;
     }
  
     protected BeanDeserializerBase(BeanDeserializerBase srcNameTransformer unwrapper)
     {
         super(src._beanType);
 
          = src._classAnnotations;
          = src._beanType;
         
          = src._valueInstantiator;
          = src._delegateDeserializer;
          = src._propertyBasedCreator;
         
          = src._backRefs;
          = src._ignorableProps;
          = (unwrapper != null) || src._ignoreAllUnknown;
          = src._anySetter;
          = src._injectables;
          = src._objectIdReader;
 
          = src._nonStandardCreation;
          = src._unwrappedPropertyHandler;
 
         if (unwrapper != null) {
             // delegate further unwraps, if any
             if ( != null) { // got handler, delegate
                 .renameAll(unwrapper);
             }
             // and handle direct unwrapping as well:
              = src._beanProperties.renameAll(unwrapper);
         } else {
              = src._beanProperties;
         }
          = src._needViewProcesing;
          = src._serializationShape;
 
         // probably adds a twist, so:
          = false;
     }
 
     {
         super(src._beanType);
         
          = src._classAnnotations;
          = src._beanType;
         
          = src._valueInstantiator;
          = src._delegateDeserializer;
          = src._propertyBasedCreator;
         
          = src._backRefs;
          = src._ignorableProps;
          = src._ignoreAllUnknown;
          = src._anySetter;
          = src._injectables;
         
          = src._nonStandardCreation;
          = src._unwrappedPropertyHandler;
          = src._needViewProcesing;
          = src._serializationShape;
 
          = src._vanillaProcessing;
 
         // then actual changes:
          = oir;
 
         if (oir == null) {
              = src._beanProperties;
         } else {
              = src._beanProperties.withProperty(new ObjectIdValueProperty(oir));
         }
     }
 
     public BeanDeserializerBase(BeanDeserializerBase srcHashSet<StringignorableProps)
     {
         super(src._beanType);
         
          = src._classAnnotations;
          = src._beanType;
         
          = src._valueInstantiator;
          = src._delegateDeserializer;
          = src._propertyBasedCreator;
         
          = src._backRefs;
          = ignorableProps;
          = src._ignoreAllUnknown;
          = src._anySetter;
          = src._injectables;
         
          = src._nonStandardCreation;
          = src._unwrappedPropertyHandler;
          = src._needViewProcesing;
          = src._serializationShape;
 
          = src._vanillaProcessing;
          = src._objectIdReader;
          = src._beanProperties;
     }
     
     @Override
     public abstract JsonDeserializer<ObjectunwrappingDeserializer(NameTransformer unwrapper);
 
     public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir);
 
     public abstract BeanDeserializerBase withIgnorableProperties(HashSet<StringignorableProps);

    
Fluent factory for creating a variant that can handle POJO output as a JSON Array. Implementations may ignore this request if no such input is possible.

Since:
2.1
 
     protected abstract BeanDeserializerBase asArrayDeserializer();
     
     /*
     /**********************************************************
     /* Validation, post-processing
     /**********************************************************
      */

    
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 void resolve(DeserializationContext ctxt)
         throws JsonMappingException
     {
         ExternalTypeHandler.Builder extTypes = null;
         // if ValueInstantiator can use "creator" approach, need to resolve it here...
         if (.canCreateFromObjectWith()) {
             SettableBeanProperty[] creatorProps = .getFromObjectArguments(ctxt.getConfig());
              = PropertyBasedCreator.construct(ctxtcreatorProps);
             // also: need to try to resolve 'external' type ids...
             for (SettableBeanProperty prop : .properties()) {
                 if (prop.hasValueTypeDeserializer()) {
                     TypeDeserializer typeDeser = prop.getValueTypeDeserializer();
                     if (typeDeser.getTypeInclusion() == ..) {
                         if (extTypes == null) {
                             extTypes = new ExternalTypeHandler.Builder();
                         }
                         extTypes.addExternal(proptypeDeser.getPropertyName());
                     }
                 }
             }
         }
 
         UnwrappedPropertyHandler unwrapped = null;
 
         for (SettableBeanProperty origProp : ) {
             SettableBeanProperty prop = origProp;
             // May already have deserializer from annotations, if so, skip:
             if (!prop.hasValueDeserializer()) {
                 prop = prop.withValueDeserializer(findDeserializer(ctxtprop.getType(), prop));
             } else { // may need contextual version
                 JsonDeserializer<Objectdeser = prop.getValueDeserializer();
                 if (deser instanceof ContextualDeserializer) {
                     JsonDeserializer<?> cd = ((ContextualDeserializerdeser).createContextual(ctxtprop);
                     if (cd != deser) {
                         prop = prop.withValueDeserializer(cd);
                     }
                 }
             }
             // [JACKSON-235]: need to link managed references with matching back references
             prop = _resolveManagedReferenceProperty(ctxtprop);
             // [JACKSON-132]: support unwrapped values (via @JsonUnwrapped)
             SettableBeanProperty u = _resolveUnwrappedProperty(ctxtprop);
             if (u != null) {
                 prop = u;
                 if (unwrapped == null) {
                     unwrapped = new UnwrappedPropertyHandler();
                 }
                 unwrapped.addProperty(prop);
                 continue;
             }
             // [JACKSON-594]: non-static inner classes too:
             prop = _resolveInnerClassValuedProperty(ctxtprop);
             if (prop != origProp) {
                 .replace(prop);
             }
             
             /* one more thing: if this property uses "external property" type inclusion
              * (see [JACKSON-453]), it needs different handling altogether
              */
             if (prop.hasValueTypeDeserializer()) {
                 TypeDeserializer typeDeser = prop.getValueTypeDeserializer();
                 if (typeDeser.getTypeInclusion() == ..) {
                     if (extTypes == null) {
                         extTypes = new ExternalTypeHandler.Builder();
                     }
                     extTypes.addExternal(proptypeDeser.getPropertyName());
                     // In fact, remove from list of known properties to simplify later handling
                     .remove(prop);
                     continue;
                 }
             }
         }
 
         // "any setter" may also need to be resolved now
         if ( != null && !.hasValueDeserializer()) {
                     .getType(), .getProperty()));
         }
 
         // as well as delegate-based constructor:
         if (.canCreateUsingDelegate()) {
             JavaType delegateType = .getDelegateType(ctxt.getConfig());
             if (delegateType == null) {
                 throw new IllegalArgumentException("Invalid delegate-creator definition for "+
                         +": value instantiator ("+.getClass().getName()
                         +") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
             }
             AnnotatedWithParams delegateCreator = .getDelegateCreator();
             // Need to create a temporary property to allow contextual deserializers:
             BeanProperty.Std property = new BeanProperty.Std(null,
                     delegateTypedelegateCreator);
              = findDeserializer(ctxtdelegateTypeproperty);
         }
         
         if (extTypes != null) {
              = extTypes.build();
             // we consider this non-standard, to offline handling
              = true;
         }
         
          = unwrapped;
         if (unwrapped != null) { // we consider this non-standard, to offline handling
              = true;
         }
 
         // may need to disable vanilla processing, if unwrapped handling was enabled...
     }

    
Although most of post-processing is done in resolve(), we only get access to referring property's annotations here; and this is needed to support per-property ObjectIds. We will also consider Shape transformations (read from Array) at this point, since it may come from either Class definition or property.
 
 //  @Override
             BeanProperty propertythrows JsonMappingException
     {
         ObjectIdReader oir = ;
         String[] ignorals = null;
 
         // First: may have an override for Object Id:
         final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
         final AnnotatedMember accessor = (property == null || intr == null)
                 ? null : property.getMember();
         if (property != null && intr != null) {
             ignorals = intr.findPropertiesToIgnore(accessor);
             ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor);
             if (objectIdInfo != null) { // some code duplication here as well (from BeanDeserializerFactory)
                 // 2.1: allow modifications by "id ref" annotations as well:
                 objectIdInfo = intr.findObjectReferenceInfo(accessorobjectIdInfo);
                 
                 Class<?> implClass = objectIdInfo.getGeneratorType();
                 // Property-based generator is trickier
                 JavaType idType;
                 SettableBeanProperty idProp;
                 ObjectIdGenerator<?> idGen;
                 if (implClass == ObjectIdGenerators.PropertyGenerator.class) {
                     String propName = objectIdInfo.getPropertyName();
                     idProp = findProperty(propName);
                     if (idProp == null) {
                         throw new IllegalArgumentException("Invalid Object Id definition for "
                                 +getBeanClass().getName()+": can not find property with name '"+propName+"'");
                     }
                     idType = idProp.getType();
                     idGen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope());
                 } else { // other types need to be simpler
                     JavaType type = ctxt.constructType(implClass);
                     idType = ctxt.getTypeFactory().findTypeParameters(typeObjectIdGenerator.class)[0];
                     idProp = null;
                     idGen = ctxt.objectIdGeneratorInstance(accessorobjectIdInfo);
                 }
                 JsonDeserializer<?> deser = ctxt.findRootValueDeserializer(idType);
                 oir = ObjectIdReader.construct(idTypeobjectIdInfo.getPropertyName(),
                 		idGendeseridProp);
             }
         }
         // either way, need to resolve serializer:
         BeanDeserializerBase contextual = this;
         if (oir != null && oir != ) {
             contextual = contextual.withObjectIdReader(oir);
         }
         // And possibly add more properties to ignore
         if (ignorals != null && ignorals.length != 0) {
             HashSet<StringnewIgnored = ArrayBuilders.setAndArray(contextual._ignorablePropsignorals);
             contextual = contextual.withIgnorableProperties(newIgnored);
         }
 
         // One more thing: are we asked to serialize POJO as array?
         JsonFormat.Shape shape = null;
         if (accessor != null) {
             JsonFormat.Value format = intr.findFormat((Annotatedaccessor);
 
             if (format != null) {
                 shape = format.getShape();
             }
         }
         if (shape == null) {
             shape = ;
         }
         if (shape == ..) {
             contextual = contextual.asArrayDeserializer();
         }
         return contextual;
     }

    
    
Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.
 
             SettableBeanProperty prop)
     {
         String refName = prop.getManagedReferenceName();
         if (refName == null) {
             return prop;
         }
         JsonDeserializer<?> valueDeser = prop.getValueDeserializer();
         SettableBeanProperty backProp = null;
         boolean isContainer = false;
         if (valueDeser instanceof BeanDeserializerBase) {
             backProp = ((BeanDeserializerBasevalueDeser).findBackReference(refName);
         } else if (valueDeser instanceof ContainerDeserializerBase<?>) {
             JsonDeserializer<?> contentDeser = ((ContainerDeserializerBase<?>) valueDeser).getContentDeserializer();
             if (!(contentDeser instanceof BeanDeserializerBase)) {
                 String deserName = (contentDeser == null) ? "NULL" : contentDeser.getClass().getName();
                 throw new IllegalArgumentException("Can not handle managed/back reference '"+refName
                         +"': value deserializer is of type ContainerDeserializerBase, but content type is not handled by a BeanDeserializer "
                         +" (instead it's of type "+deserName+")");
             }
             backProp = ((BeanDeserializerBasecontentDeser).findBackReference(refName);
             isContainer = true;
         } else if (valueDeser instanceof AbstractDeserializer) {
             backProp = ((AbstractDeserializervalueDeser).findBackReference(refName);
         } else {
             throw new IllegalArgumentException("Can not handle managed/back reference '"+refName
                     +"': type for value deserializer is not BeanDeserializer or ContainerDeserializerBase, but "
                     +valueDeser.getClass().getName());
         }
         if (backProp == null) {
             throw new IllegalArgumentException("Can not handle managed/back reference '"+refName+"': no back reference property found from type "
                     +prop.getType());
         }
         // also: verify that type is compatible
         JavaType referredType = ;
         JavaType backRefType = backProp.getType();
         if (!backRefType.getRawClass().isAssignableFrom(referredType.getRawClass())) {
             throw new IllegalArgumentException("Can not handle managed/back reference '"+refName+"': back reference type ("
                     +backRefType.getRawClass().getName()+") not compatible with managed type ("
                     +referredType.getRawClass().getName()+")");
         }
         return new ManagedReferenceProperty(proprefNamebackProp,
                 isContainer);
     }

    
Helper method called to see if given property might be so-called unwrapped property: these require special handling.
 
             SettableBeanProperty prop)
     {
         AnnotatedMember am = prop.getMember();
         if (am != null) {
             NameTransformer unwrapper = ctxt.getAnnotationIntrospector().findUnwrappingNameTransformer(am);
             if (unwrapper != null) {
                 JsonDeserializer<Objectorig = prop.getValueDeserializer();
                 JsonDeserializer<Objectunwrapping = orig.unwrappingDeserializer(unwrapper);
                 if (unwrapping != orig && unwrapping != null) {
                     // might be cleaner to create new instance; but difficult to do reliably, so:
                     return prop.withValueDeserializer(unwrapping);
                 }
             }
         }
         return null;
     }
    
    
Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...
 
             SettableBeanProperty prop)
     {            
         /* Should we encounter a property that has non-static inner-class
          * as value, we need to add some more magic to find the "hidden" constructor...
          */
         JsonDeserializer<Objectdeser = prop.getValueDeserializer();
         // ideally wouldn't rely on it being BeanDeserializerBase; but for now it'll have to do
         if (deser instanceof BeanDeserializerBase) {
             BeanDeserializerBase bd = (BeanDeserializerBasedeser;
             ValueInstantiator vi = bd.getValueInstantiator();
             if (!vi.canCreateUsingDefault()) { // no default constructor
                 Class<?> valueClass = prop.getType().getRawClass();
                 Class<?> enclosing = ClassUtil.getOuterClass(valueClass);
                 // and is inner class of the bean class...
                 if (enclosing != null && enclosing == .getRawClass()) {
                     for (Constructor<?> ctor : valueClass.getConstructors()) {
                         Class<?>[] paramTypes = ctor.getParameterTypes();
                         if (paramTypes.length == 1 && paramTypes[0] == enclosing) {
                             if (ctxt.getConfig().canOverrideAccessModifiers()) {
                                 ClassUtil.checkAndFixAccess(ctor);
                             }
                             return new InnerClassProperty(propctor);
                         }
                     }
                 }
             }
         }
         return prop;
     }
 
     /*
     /**********************************************************
     /* Public accessors
     /**********************************************************
      */
 
     @Override
     public boolean isCachable() { return true; }

    
Overridden to return true for those instances that are handling value for which Object Identity handling is enabled (either via value type or referring property).
 
     @Override
     public ObjectIdReader getObjectIdReader() {
         return ;
     }
     
     public boolean hasProperty(String propertyName) {
         return .find(propertyName) != null;
     }
 
     public boolean hasViews() {
         return ;
     }
    
    
Accessor for checking number of deserialized properties.
 
     public int getPropertyCount() { 
         return .size();
     }
 
     @Override
     public Collection<ObjectgetKnownPropertyNames() {
         ArrayList<Objectnames = new ArrayList<Object>();
         for (SettableBeanProperty prop : ) {
             names.add(prop.getName());
         }
         return names;
     }
     
     public final Class<?> getBeanClass() { return .getRawClass(); }
 
     @Override public JavaType getValueType() { return ; }

    
Accessor for iterating over properties this deserializer uses; with the exception that properties passed via Creator methods (specifically, "property-based constructor") are not included, but can be accessed separate by calling creatorProperties()
 
     {
         if ( == null) {
             throw new IllegalStateException("Can only call after BeanDeserializer has been resolved");
         }
         return .iterator();
     }

    
Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)

Since:
2.0
 
     {
         if ( == null) {
             return Collections.<SettableBeanProperty>emptyList().iterator();
         }
         return .properties().iterator();
     }

    
Accessor for finding the property with given name, if POJO has one. Name used is the external name, i.e. name used in external data representation (JSON).

Since:
2.0
 
     public SettableBeanProperty findProperty(String propertyName)
     {
         SettableBeanProperty prop = ( == null) ?
                 null : .find(propertyName);
         if (prop == null &&  != null) {
             prop = .findCreatorProperty(propertyName);
         }
         return prop;
     }
    
    
Method needed by BeanDeserializerFactory to properly link managed- and back-reference pairs.
 
     public SettableBeanProperty findBackReference(String logicalName)
     {
         if ( == null) {
             return null;
         }
         return .get(logicalName);
     }
 
         return ;
     }
 
     /*
     /**********************************************************
     /* Mutators
     /**********************************************************
      */

    
Method that can be used to replace an existing property with a modified one.

NOTE: only ever use this method if you know what you are doing; incorrect usage can break deserializer.

Parameters:
original Property to replace
replacement Property to replace it with
Since:
2.1
 
     public void replaceProperty(SettableBeanProperty original,
             SettableBeanProperty replacement)
     {
         .replace(replacement);
     }
 
     /*
     /**********************************************************
     /* Partial deserializer implementation
     /**********************************************************
      */
     
     @Override
     public final Object deserializeWithType(JsonParser jpDeserializationContext ctxt,
             TypeDeserializer typeDeserializer)
         throws IOExceptionJsonProcessingException
     {
         /* 16-Feb-2012, tatu: ObjectId may be used as well... need to check
          *    that first
          */
         if ( != null) {
             JsonToken t = jp.getCurrentToken();
             // should be good enough check; we only care about Strings, integral numbers:
             if (t != null && t.isScalarValue()) {
                 return deserializeFromObjectId(jpctxt);
             }
         }
         // In future could check current token... for now this should be enough:
         return typeDeserializer.deserializeTypedFromObject(jpctxt);
     }

    
Method called in cases where it looks like we got an Object Id to parse and use as a reference.
 
         throws IOExceptionJsonProcessingException
     {
         Object id = ..deserialize(jpctxt);
         ReadableObjectId roid = ctxt.findObjectId(id.);
         // do we have it resolved?
         Object pojo = roid.item;
         if (pojo == null) { // not yet; should wait...
             throw new IllegalStateException("Could not resolve Object Id ["+id+"] -- unresolved forward-reference?");
         }
         return pojo;
     }
     
     /*
     /**********************************************************
     /* Overridable helper methods
     /**********************************************************
      */
 
     protected void injectValues(DeserializationContext ctxtObject bean)
             throws IOExceptionJsonProcessingException
     {
         for (ValueInjector injector : ) {
             injector.inject(ctxtbean);
         }
     }
    
    
Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.
 
     @Override
     protected void handleUnknownProperty(JsonParser jpDeserializationContext ctxt,
             Object beanOrClassString propName)
         throws IOExceptionJsonProcessingException
     {
         /* 22-Aug-2010, tatu: Caller now mostly checks for ignorable properties, so
          *    following should not be necessary. However, "handleUnknownProperties()" seems
          *    to still possibly need it so it is left for now.
          */
         // If registered as ignorable, skip
         if ( ||
             ( != null && .contains(propName))) {
             jp.skipChildren();
             return;
         }
         /* Otherwise use default handling (call handler(s); if not
          * handled, throw exception or skip depending on settings)
          */
         super.handleUnknownProperty(jpctxtbeanOrClasspropName);
     }

    
Method called to handle set of one or more unknown properties, stored in their entirety in given com.fasterxml.jackson.databind.util.TokenBuffer (as field entries, name and value).
 
     protected Object handleUnknownProperties(DeserializationContext ctxtObject beanTokenBuffer unknownTokens)
         throws IOExceptionJsonProcessingException
     {
         // First: add closing END_OBJECT as marker
         unknownTokens.writeEndObject();
         
         // note: buffer does NOT have starting START_OBJECT
         JsonParser bufferParser = unknownTokens.asParser();
         while (bufferParser.nextToken() != .) {
             String propName = bufferParser.getCurrentName();
             // Unknown: let's call handler method
             bufferParser.nextToken();
             handleUnknownProperty(bufferParserctxtbeanpropName);
         }
         return bean;
     }
    
    
Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
 
             Object beanTokenBuffer unknownTokens)
         throws IOExceptionJsonProcessingException
     {  
         JsonDeserializer<ObjectsubDeser;
 
         // First: maybe we have already created sub-type deserializer?
         synchronized (this) {
             subDeser = ( == null) ? null : .get(new ClassKey(bean.getClass()));
         }
         if (subDeser != null) {
             return subDeser;
         }
         // If not, maybe we can locate one. First, need provider
         JavaType type = ctxt.constructType(bean.getClass());
         /* 30-Jan-2012, tatu: Ideally we would be passing referring
          *   property; which in theory we could keep track of via
          *   ResolvableDeserializer (if we absolutely must...).
          *   But for now, let's not bother.
          */
 //        subDeser = ctxt.findValueDeserializer(type, _property);
         subDeser = ctxt.findRootValueDeserializer(type);
         // Also, need to cache it
         if (subDeser != null) {
             synchronized (this) {
                 if ( == null) {
                      = new HashMap<ClassKey,JsonDeserializer<Object>>();;
                 }
                 .put(new ClassKey(bean.getClass()), subDeser);
             }            
         }
         return subDeser;
     }
     
     /*
     /**********************************************************
     /* Helper methods for error reporting
     /**********************************************************
      */

    
Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of java.io.IOException, or an unchecked exception.

Rules for wrapping and unwrapping are bit complicated; essentially:

 
     public void wrapAndThrow(Throwable tObject beanString fieldName,
             DeserializationContext ctxt)
         throws IOException
     {
         /* 05-Mar-2009, tatu: But one nasty edge is when we get
          *   StackOverflow: usually due to infinite loop. But that
          *   usually gets hidden within an InvocationTargetException...
          */
         while (t instanceof InvocationTargetException && t.getCause() != null) {
             t = t.getCause();
         }
         // Errors and "plain" IOExceptions to be passed as is
         if (t instanceof Error) {
            throw (Errort;
        }
        boolean wrap = (ctxt == null) || ctxt.isEnabled(.);
        // Ditto for IOExceptions; except we may want to wrap mapping exceptions
        if (t instanceof IOException) {
            if (!wrap || !(t instanceof JsonMappingException)) {
                throw (IOExceptiont;
            }
        } else if (!wrap) { // [JACKSON-407] -- allow disabling wrapping for unchecked exceptions
            if (t instanceof RuntimeException) {
                throw (RuntimeExceptiont;
            }
        }
        // [JACKSON-55] Need to add reference information
        throw JsonMappingException.wrapWithPath(tbeanfieldName);
    }
    public void wrapAndThrow(Throwable tObject beanint indexDeserializationContext ctxt)
        throws IOException
    {
        while (t instanceof InvocationTargetException && t.getCause() != null) {
            t = t.getCause();
        }
        // Errors and "plain" IOExceptions to be passed as is
        if (t instanceof Error) {
            throw (Errort;
        }
        boolean wrap = (ctxt == null) || ctxt.isEnabled(.);
        // Ditto for IOExceptions; except we may want to wrap mapping exceptions
        if (t instanceof IOException) {
            if (!wrap || !(t instanceof JsonMappingException)) {
                throw (IOExceptiont;
            }
        } else if (!wrap) { // [JACKSON-407] -- allow disabling wrapping for unchecked exceptions
            if (t instanceof RuntimeException) {
                throw (RuntimeExceptiont;
            }
        }
        // [JACKSON-55] Need to add reference information
        throw JsonMappingException.wrapWithPath(tbeanindex);
    }
        throws IOException
    {
        while (t instanceof InvocationTargetException && t.getCause() != null) {
            t = t.getCause();
        }
        // Errors and "plain" IOExceptions to be passed as is
        if (t instanceof Error) {
            throw (Errort;
        }
        boolean wrap = (ctxt == null) || ctxt.isEnabled(.);
        if (t instanceof IOException) {
            // Since we have no more information to add, let's not actually wrap..
            throw (IOExceptiont;
        } else if (!wrap) { // [JACKSON-407] -- allow disabling wrapping for unchecked exceptions
            if (t instanceof RuntimeException) {
                throw (RuntimeExceptiont;
            }
        }
        throw ctxt.instantiationException(.getRawClass(), t);
    }