Module tools.jackson.databind
Package tools.jackson.databind.deser.bean

Class BeanDeserializerBase

java.lang.Object
tools.jackson.databind.ValueDeserializer<T>
tools.jackson.databind.deser.std.StdDeserializer<Object>
tools.jackson.databind.deser.bean.BeanDeserializerBase
All Implemented Interfaces:
NullValueProvider, ValueInstantiator.Gettable
Direct Known Subclasses:
BeanAsArrayBuilderDeserializer, BeanAsArrayDeserializer, BeanDeserializer, BuilderBasedDeserializer
public abstract class BeanDeserializerBase extends StdDeserializer<Object> implements ValueInstantiator.Gettable
Base class for BeanDeserializer.

  • Field Details

    • TEMP_PROPERTY_NAME

      protected static final PropertyName TEMP_PROPERTY_NAME

    • _beanType

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

    • _serializationShape

      protected final JsonFormat.Shape _serializationShape
      Requested shape from bean class annotations.

    • _valueInstantiator

      protected final ValueInstantiator _valueInstantiator
      Object that handles details of constructing initial bean value (to which bind data to), unless instance is passed (via updateValue())

    • _delegateDeserializer

      protected ValueDeserializer<Object> _delegateDeserializer
      Deserializer that is used iff delegate-based creator is to be used for deserializing from JSON Object.

      NOTE: cannot be final because we need to get it during resolve() method (and not contextualization).

    • _arrayDelegateDeserializer

      protected ValueDeserializer<Object> _arrayDelegateDeserializer
      Deserializer that is used iff array-delegate-based creator is to be used for deserializing from JSON Object.

      NOTE: cannot be final because we need to get it during resolve() method (and not contextualization).

    • _propertyBasedCreator

      protected PropertyBasedCreator _propertyBasedCreator
      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.

    • _nonStandardCreation

      protected boolean _nonStandardCreation
      Flag that is set to mark cases where deserialization from Object value using otherwise "standard" property binding will need to use non-default creation method: namely, either "full" delegation (array-delegation does not apply), or properties-based Creator method is used.

      Note that flag is somewhat mis-named as it is not affected by scalar-delegating creators; it only has effect on Object Value binding.

    • _vanillaProcessing

      protected boolean _vanillaProcessing
      Flag that indicates that no "special features" whatsoever are enabled, so the simplest processing is possible.

    • _beanProperties

      protected final BeanPropertyMap _beanProperties
      Mapping of property names to properties, built when all properties to use have been successfully resolved.

    • _injectables

      protected final ValueInjector[] _injectables
      List of 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.

    • _anySetter

      protected SettableAnyProperty _anySetter
      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.

    • _ignorableProps

      protected final Set<String> _ignorableProps
      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.

    • _includableProps

      protected final Set<String> _includableProps
      Keep track of the properties that need to be specifically included.

    • _ignoreAllUnknown

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

    • _needViewProcesing

      protected final boolean _needViewProcesing
      Flag that indicates that some aspect of deserialization depends on active view used (if any)

    • _backRefs

      protected final Map<String,SettableBeanProperty> _backRefs
      We may also have one or more back reference fields (usually zero or one).

    • _subDeserializers

      protected transient ConcurrentHashMap<ClassKey,ValueDeserializer<Object>> _subDeserializers
      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.

    • _unwrappedPropertyHandler

      protected UnwrappedPropertyHandler _unwrappedPropertyHandler
      If one of properties has "unwrapped" value, we need separate helper object

    • _externalTypeIdHandler

      protected ExternalTypeHandler _externalTypeIdHandler
      Handler that we need if any of properties uses external type id.

    • _objectIdReader

      protected final ObjectIdReader _objectIdReader
      If an Object Id is to be used for value handled by this deserializer, this reader is used for handling.

  • Constructor Details

  • Method Details

    • withObjectIdReader

      public abstract BeanDeserializerBase withObjectIdReader(ObjectIdReader oir)

    • withByNameInclusion

      public abstract BeanDeserializerBase withByNameInclusion(Set<String> ignorableProps, Set<String> includableProps)

    • withIgnoreAllUnknown

      public abstract BeanDeserializerBase withIgnoreAllUnknown(boolean ignoreUnknown)

    • withBeanProperties

      public BeanDeserializerBase withBeanProperties(BeanPropertyMap props)
      Mutant factory method that custom sub-classes must override; not left as abstract to prevent more drastic backwards compatibility problems.

    • unwrappingDeserializer

      public abstract ValueDeserializer<Object> unwrappingDeserializer(DeserializationContext ctxt, NameTransformer unwrapper)
      Description copied from class: ValueDeserializer
      Method that will return deserializer instance that is able to handle "unwrapped" value instances If no unwrapped instance can be constructed, will simply return this object as-is.

      Default implementation just returns 'this' indicating that no unwrapped variant exists

      Overrides:
      unwrappingDeserializer in class ValueDeserializer<Object>

    • asArrayDeserializer

      protected abstract BeanDeserializerBase asArrayDeserializer()
      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.

    • initNameMatcher

      protected abstract void initNameMatcher(DeserializationContext ctxt)

    • resolve

      public void resolve(DeserializationContext ctxt)
      Method called to finalize setup of this deserializer, after deserializer itself has been registered. This is needed to handle recursive and transitive dependencies.
      Overrides:
      resolve in class ValueDeserializer<Object>
      Parameters:
      ctxt - Context to use for accessing configuration, resolving secondary deserializers

    • _replaceProperty

      protected void _replaceProperty(BeanPropertyMap props, SettableBeanProperty[] creatorProps, SettableBeanProperty origProp, SettableBeanProperty newProp)

    • _getSetterInfo

      protected PropertyMetadata _getSetterInfo(DeserializationContext ctxt, AnnotatedMember accessor, JavaType type)
      Method essentially copied from BasicDeserializerFactory, needed to find PropertyMetadata for Delegating Creator, for access to annotation-derived info.

    • _findConvertingDeserializer

      protected ValueDeserializer<Object> _findConvertingDeserializer(DeserializationContext ctxt, SettableBeanProperty prop)
      Helper method that can be used to see if specified property is annotated to indicate use of a converter for property value (in case of container types, it is container type itself, not key or content type).

      NOTE: returned deserializer is NOT yet contextualized, caller needs to take care to do that.

    • createContextual

      public ValueDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
      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.
      Overrides:
      createContextual in class ValueDeserializer<Object>
      Parameters:
      ctxt - Deserialization context to access configuration, additional deserializers that may be needed by this deserializer
      property - Method, field or constructor parameter that represents the property (and is used to assign deserialized value). Should be available; but there may be cases where caller cannot provide it and null is passed instead (in which case impls usually pass 'this' deserializer as is)
      Returns:
      Deserializer to use for deserializing values of specified property; may be this instance or a new instance.

    • _handleByNameInclusion

      protected BeanDeserializerBase _handleByNameInclusion(DeserializationContext ctxt, AnnotationIntrospector intr, BeanDeserializerBase contextual, AnnotatedMember accessor)

    • _resolveManagedReferenceProperty

      protected SettableBeanProperty _resolveManagedReferenceProperty(DeserializationContext ctxt, SettableBeanProperty prop)
      Helper method called to see if given property is part of 'managed' property pair (managed + back reference), and if so, handle resolution details.

    • _resolvedObjectIdProperty

      protected SettableBeanProperty _resolvedObjectIdProperty(DeserializationContext ctxt, SettableBeanProperty prop)
      Method that wraps given property with ObjectIdReferenceProperty in case where object id resolution is required.

    • _findPropertyUnwrapper

      protected NameTransformer _findPropertyUnwrapper(DeserializationContext ctxt, SettableBeanProperty prop)
      Helper method called to see if given property might be so-called unwrapped property: these require special handling.

    • _resolveInnerClassValuedProperty

      protected SettableBeanProperty _resolveInnerClassValuedProperty(DeserializationContext ctxt, SettableBeanProperty prop)
      Helper method that will handle gruesome details of dealing with properties that have non-static inner class as value...

    • _resolveMergeAndNullSettings

      protected SettableBeanProperty _resolveMergeAndNullSettings(DeserializationContext ctxt, SettableBeanProperty prop, PropertyMetadata propMetadata)

    • getNullAccessPattern

      public AccessPattern getNullAccessPattern()
      Description copied from class: ValueDeserializer
      This method may be called in conjunction with calls to ValueDeserializer.getNullValue(DeserializationContext), to check whether it needs to be called just once (static values), or each time empty value is needed.

      Default implementation indicates that the "null value" to use for input null does not vary across uses so that ValueDeserializer.getNullValue(DeserializationContext) need not be called more than once per deserializer instance. This information may be used as optimization.

      Specified by:
      getNullAccessPattern in interface NullValueProvider
      Overrides:
      getNullAccessPattern in class ValueDeserializer<Object>

    • getEmptyAccessPattern

      public AccessPattern getEmptyAccessPattern()
      Description copied from class: ValueDeserializer
      This method may be called in conjunction with calls to ValueDeserializer.getEmptyValue(DeserializationContext), to check whether it needs to be called just once (static values), or each time empty value is needed.
      Overrides:
      getEmptyAccessPattern in class ValueDeserializer<Object>

    • getEmptyValue

      public Object getEmptyValue(DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Description copied from class: ValueDeserializer
      Method called to determine value to be used for "empty" values (most commonly when deserializing from empty JSON Strings). Usually this is same as ValueDeserializer.getNullValue(tools.jackson.databind.DeserializationContext) (which in turn is usually simply Java null), but it can be overridden for specific types. Or, if type should never be converted from empty String, method can also throw an exception.

      This method may be called once, or multiple times, depending on what ValueDeserializer.getEmptyAccessPattern() returns.

      Default implementation simply calls ValueDeserializer.getNullValue(tools.jackson.databind.DeserializationContext) and returns value.

      Overrides:
      getEmptyValue in class ValueDeserializer<Object>
      Throws:
      tools.jackson.core.JacksonException

    • isCachable

      public boolean isCachable()
      Description copied from class: ValueDeserializer
      Method called to see if deserializer instance is cachable and usable for other properties of same type (type for which instance was created).

      Note that cached instances are still contextualized on per-property basis (but note that ValueDeserializer.resolve(DeserializationContext)d just once!) This means that in most cases it is safe to cache instances; however, it only makes sense to cache instances if instantiation is expensive, or if instances are heavy-weight.

      Default implementation returns false, to indicate that no caching is done.

      Overrides:
      isCachable in class ValueDeserializer<Object>

    • isCaseInsensitive

      public boolean isCaseInsensitive()
      Accessor for checking whether this deserializer is operating in case-insensitive manner.
      Returns:
      True if this deserializer should match property names without considering casing; false if case has to match exactly.
      Since:
      2.12

    • supportsUpdate

      public Boolean supportsUpdate(DeserializationConfig config)
      Description copied from class: ValueDeserializer
      Introspection method that may be called to see whether deserializer supports update of an existing value (aka "merging") or not. Return value should either be Boolean.FALSE if update is not supported at all (immutable values); Boolean.TRUE if update should usually work (regular POJOs, for example), or null if this is either not known, or may sometimes work.

      Information gathered is typically used to either prevent merging update for property (either by skipping, if based on global defaults; or by exception during deserializer construction if explicit attempt made) if Boolean.FALSE returned, or inclusion if Boolean.TRUE is specified. If "unknown" case (null returned) behavior is to exclude property if global defaults used; or to allow if explicit per-type or property merging is defined.

      Default implementation returns null to allow explicit per-type or per-property attempts.

      Overrides:
      supportsUpdate in class ValueDeserializer<Object>

    • handledType

      public Class<?> handledType()
      Description copied from class: ValueDeserializer
      Method for accessing concrete physical type of values this deserializer produces. Note that this information is not guaranteed to be exact -- it may be a more generic (super-type) -- but it should not be incorrect (return a non-related type).

      Default implementation will return null, which means almost same same as returning Object.class would; that is, that nothing is known about handled type.

      Overrides:
      handledType in class StdDeserializer<Object>
      Returns:
      Physical type of values this deserializer produces, if known; null if not

    • getObjectIdReader

      public ObjectIdReader getObjectIdReader(DeserializationContext ctxt)
      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).
      Overrides:
      getObjectIdReader in class ValueDeserializer<Object>
      Returns:
      ObjectIdReader used for resolving possible Object Identifier value, instead of full value serialization, if deserializer can do that; null if no Object Id is expected.

    • hasProperty

      public boolean hasProperty(String propertyName)
      Accessor for checking if the POJO handled by this deserializer has given physical property (regular or unwrapped, not including "any properties".
      Parameters:
      propertyName - Property to check
      Returns:
      True if the POJO handled by this deserializer has given physical property (regular or unwrapped); not including "any properties"

    • hasViews

      public boolean hasViews()

    • hasAnySetter

      public boolean hasAnySetter()
      Since:
      3.1

    • getPropertyCount

      public int getPropertyCount()
      Accessor for checking number of deserialized properties.

    • getKnownPropertyNames

      public Collection<Object> getKnownPropertyNames()
      Description copied from class: ValueDeserializer
      Method that will either return null to indicate that type being deserializers has no concept of properties; or a collection of identifiers for which toString will give external property name. This is only to be used for error reporting and diagnostics purposes (most commonly, to accompany "unknown property" exception).
      Overrides:
      getKnownPropertyNames in class ValueDeserializer<Object>

    • collectAllPropertyNamesTo

      public void collectAllPropertyNamesTo(Set<String> names)
      Method to collect all property names including nested unwrapped properties
      Parameters:
      names - (not null) Set to add property names to; for both regular and "any" properties.
      Since:
      3.1

    • getValueType

      public JavaType getValueType()
      Description copied from class: StdDeserializer
      Exact structured type this deserializer handles, if known.
      Overrides:
      getValueType in class StdDeserializer<Object>

    • logicalType

      public LogicalType logicalType()
      Description copied from class: ValueDeserializer
      Method for accessing logical type of values this deserializer produces. Typically used for further configuring handling of values, for example, to find which coercions are legal.
      Overrides:
      logicalType in class ValueDeserializer<Object>
      Returns:
      Logical type of values this deserializer produces, if known; null if not

    • properties

      public Iterator<SettableBeanProperty> properties()
      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()

    • creatorProperties

      public Iterator<SettableBeanProperty> creatorProperties()
      Accessor for finding properties that represents values to pass through property-based creator method (constructor or factory method)

    • findProperty

      public SettableBeanProperty findProperty(PropertyName propertyName)

    • findProperty

      protected SettableBeanProperty findProperty(String propertyName)
      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).

      NOTE: does NOT match "unwrapped" properties POJO contains (if any).

    • findProperty

      public SettableBeanProperty findProperty(int propertyIndex)
      Alternate find method that tries to locate a property with given property index. Note that access by index is not necessarily faster than by name, since properties are not directly indexable; however, for most instances difference is not significant as number of properties is low.

    • findBackReference

      public SettableBeanProperty findBackReference(String logicalName)
      Method needed by BeanDeserializerFactory to properly link managed- and back-reference pairs.
      Overrides:
      findBackReference in class ValueDeserializer<Object>

    • getValueInstantiator

      public ValueInstantiator getValueInstantiator()
      Specified by:
      getValueInstantiator in interface ValueInstantiator.Gettable
      Overrides:
      getValueInstantiator in class StdDeserializer<Object>

    • deserializeFromObject

      public abstract Object deserializeFromObject(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      General version used when handling needs more advanced features.
      Throws:
      tools.jackson.core.JacksonException

    • deserializeWithType

      public Object deserializeWithType(tools.jackson.core.JsonParser p, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws tools.jackson.core.JacksonException
      Description copied from class: StdDeserializer
      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.
      Overrides:
      deserializeWithType in class StdDeserializer<Object>
      typeDeserializer - Deserializer to use for handling type information
      Throws:
      tools.jackson.core.JacksonException

    • _handleTypedObjectId

      protected Object _handleTypedObjectId(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object pojo, Object rawId) throws tools.jackson.core.JacksonException
      Off-lined method called to handle "native" Object Id that has been read and known to be associated with given deserialized POJO.
      Throws:
      tools.jackson.core.JacksonException

    • _convertObjectId

      protected Object _convertObjectId(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object rawId, ValueDeserializer<Object> idDeser) throws tools.jackson.core.JacksonException
      Helper method we need to do necessary conversion from whatever native object id type is, into declared type that Jackson internals expect. This may be simple cast (for String ids), or something more complicated; in latter case we may need to create bogus content buffer to allow use of id deserializer.
      Throws:
      tools.jackson.core.JacksonException

    • deserializeWithObjectId

      protected Object deserializeWithObjectId(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Alternative deserialization method used when we expect to see Object Id; if so, we will need to ensure that the Id is seen before anything else, to ensure that it is available for solving references, even if JSON itself is not ordered that way. This may require buffering in some cases, but usually just a simple lookup to ensure that ordering is correct.
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromObjectId

      protected Object deserializeFromObjectId(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Method called in cases where it looks like we got an Object Id to parse and use as a reference.
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromObjectUsingNonDefault

      protected Object deserializeFromObjectUsingNonDefault(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • _deserializeUsingPropertyBased

      protected abstract Object _deserializeUsingPropertyBased(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromNumber

      public Object deserializeFromNumber(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromString

      public Object deserializeFromString(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromDouble

      public Object deserializeFromDouble(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Method called to deserialize POJO value from a JSON floating-point number.
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromBoolean

      public Object deserializeFromBoolean(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Method called to deserialize POJO value from a JSON boolean value (true, false)
      Throws:
      tools.jackson.core.JacksonException

    • deserializeFromEmbedded

      public Object deserializeFromEmbedded(tools.jackson.core.JsonParser p, DeserializationContext ctxt) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • _delegateDeserializer

      protected final ValueDeserializer<Object> _delegateDeserializer()

    • _delegateDeserializer

      protected final ValueDeserializer<Object> _delegateDeserializer(tools.jackson.core.JsonParser p)
      Alternate to _delegateDeserializer() which will only consider _arrayDelegateDeserializer if given JsonParser points to JsonToken.START_ARRAY token.

    • injectValues

      protected void injectValues(DeserializationContext ctxt, Object bean) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException

    • handleUnknownProperties

      protected Object handleUnknownProperties(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws tools.jackson.core.JacksonException
      Method called to handle set of one or more unknown properties, stored in their entirety in given TokenBuffer (as field entries, name and value).
      Throws:
      tools.jackson.core.JacksonException

    • handleUnknownVanilla

      protected void handleUnknownVanilla(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object beanOrBuilder, String propName) throws tools.jackson.core.JacksonException
      Helper method called for an unknown property, when using "vanilla" processing.
      Parameters:
      beanOrBuilder - Either POJO instance (if constructed), or builder (in case of builder-based approach), that has property we haven't been able to handle yet.
      Throws:
      tools.jackson.core.JacksonException

    • handleUnknownProperty

      protected void handleUnknownProperty(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object beanOrClass, String propName) throws tools.jackson.core.JacksonException
      Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus cannot be assigned.
      Overrides:
      handleUnknownProperty in class StdDeserializer<Object>
      Parameters:
      p - Parser that points to value of the unknown property
      ctxt - Context for deserialization; allows access to the parser, error reporting functionality
      beanOrClass - Instance that is being populated by this deserializer, or if not known, Class that would be instantiated. If null, will assume type is what StdDeserializer.handledType() returns.
      propName - Name of the property that cannot be mapped
      Throws:
      tools.jackson.core.JacksonException

    • handleIgnoredProperty

      protected void handleIgnoredProperty(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object beanOrClass, String propName) throws tools.jackson.core.JacksonException
      Method called when an explicitly ignored property (one specified with a name to match, either by property annotation or class annotation) is encountered.
      Throws:
      tools.jackson.core.JacksonException

    • handlePolymorphic

      protected Object handlePolymorphic(tools.jackson.core.JsonParser p, DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws tools.jackson.core.JacksonException
      Method called in cases where we may have polymorphic deserialization case: that is, type of Creator-constructed bean is not the type of deserializer itself. It should be a sub-class or implementation class; either way, we may have more specific deserializer to use for handling it.
      Parameters:
      p - (optional) If not null, parser that has more properties to handle (in addition to buffered properties); if null, all properties are passed in buffer
      Throws:
      tools.jackson.core.JacksonException

    • _findSubclassDeserializer

      protected ValueDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens) throws tools.jackson.core.JacksonException
      Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
      Throws:
      tools.jackson.core.JacksonException

    • wrapAndThrow

      public DatabindException wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt)
      Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of DatabindException, or an unchecked exception.

      Rules for wrapping and unwrapping are bit complicated; essentially:

      • Errors are to be passed as is (if uncovered via unwrapping)
      • JacksonException are to be passed as is
      The method always throws but declares its return type as DatabindException in order to allow callers to invoke method as throw wrapAndThrow(...); thereby ensuring complete code coverage is possible. This also ensures that all call paths within this method throw an exception; otherwise they would be required to return.

    • wrapInstantiationProblem

      protected Object wrapInstantiationProblem(DeserializationContext ctxt, Throwable t) throws tools.jackson.core.JacksonException
      Throws:
      tools.jackson.core.JacksonException