## Uses of Class
org.codehaus.jackson.JsonProcessingException

- Packages that use JsonProcessingException
  Package | Description
  --- | ---
  org.codehaus.jackson | Main public API classes of the core streaming JSON processor: most importantly `JsonFactory` used for constructing JSON parser (`JsonParser`) and generator (`JsonParser`) instances.
  org.codehaus.jackson.impl | Parser and generator implementation classes that Jackson defines and uses.
  org.codehaus.jackson.map | Contains basic mapper (conversion) functionality that allows for converting between regular streaming json content and Java objects (beans or Tree Model: support for both is via `ObjectMapper` class, as well as convenience methods included in `JsonParser`
  org.codehaus.jackson.map.deser | Contains implementation classes of deserialization part of data binding.
  org.codehaus.jackson.map.deser.impl | Contains those implementation classes of deserialization part of data binding that are not considered part of public or semi-public interfaces.
  org.codehaus.jackson.map.deser.std | Contains public standard implementations of abstraction that Jackson uses.
  org.codehaus.jackson.map.exc |
  org.codehaus.jackson.map.ext | Contains extended support for "external" packages: things that may or may not be present in runtime environment, but that are commonly enough used so that explicit support can be added.
  org.codehaus.jackson.map.jsontype.impl | Package that contains standard implementations for `TypeResolverBuilder` and `TypeIdResolver`.
  org.codehaus.jackson.map.ser | Contains implementation classes of serialization part of data binding.
  org.codehaus.jackson.map.ser.std |
  org.codehaus.jackson.map.type | Package that contains concrete implementations of `JavaType`, as well as the factory (`TypeFactory`) for constructing instances from various input data types (like `Class`, `Type`) and programmatically (for structured types, arrays, `List`s and `Map`s).
  org.codehaus.jackson.map.util | Utility classes for Mapper package.
  org.codehaus.jackson.node | Contains concrete `JsonNode` implementations Jackson uses for the Tree model.
  org.codehaus.jackson.util | Utility classes used by Jackson Core functionality.
  org.codehaus.jackson.xc | Package that contains XML Compatibility functionality for Jackson, such as handlers for JAXB annotations

- - ### Uses of JsonProcessingException in org.codehaus.jackson

    Subclasses of JsonProcessingException in org.codehaus.jackson
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JsonGenerationException` Exception type for exceptions during JSON writing, such as trying to output content in wrong context (non-matching end-array or end-object, for example).
    `class` | `JsonParseException` Exception type for parsing problems, used when non-well-formed content (content that does not conform to JSON syntax as per specification) is encountered.

    Methods in org.codehaus.jackson that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `abstract void` | JsonGenerator.`copyCurrentEvent(JsonParser jp)` Method for copying contents of the current event that the given parser instance points to.
    `abstract void` | JsonGenerator.`copyCurrentStructure(JsonParser jp)` Method for copying contents of the current event and following events that it encloses the given parser instance points to.
    `abstract JsonNode` | ObjectCodec.`readTree(JsonParser jp)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `abstract <T> T` | ObjectCodec.`readValue(JsonParser jp, Class<T> valueType)` Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).
    `abstract <T> T` | ObjectCodec.`readValue(JsonParser jp, JavaType valueType)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `abstract <T> T` | ObjectCodec.`readValue(JsonParser jp, TypeReference<?> valueTypeRef)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `<T> T` | JsonParser.`readValueAs(Class<T> valueType)` Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like `Boolean`).
    `<T> T` | JsonParser.`readValueAs(TypeReference<?> valueTypeRef)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
    `JsonNode` | JsonParser.`readValueAsTree()` Method to deserialize JSON content into equivalent "tree model", represented by root `JsonNode` of resulting model.
    `abstract <T> Iterator<T>` | ObjectCodec.`readValues(JsonParser jp, Class<T> valueType)` Method for reading sequence of Objects from parser stream, all with same specified value type.
    `abstract <T> Iterator<T>` | ObjectCodec.`readValues(JsonParser jp, JavaType valueType)` Method for reading sequence of Objects from parser stream, all with same specified value type.
    `abstract <T> Iterator<T>` | ObjectCodec.`readValues(JsonParser jp, TypeReference<?> valueTypeRef)` Method for reading sequence of Objects from parser stream, all with same specified value type.
    `<T> Iterator<T>` | JsonParser.`readValuesAs(Class<T> valueType)` Method for reading sequence of Objects from parser stream, all with same specified value type.
    `<T> Iterator<T>` | JsonParser.`readValuesAs(TypeReference<?> valueTypeRef)` Method for reading sequence of Objects from parser stream, all with same specified value type.
    `abstract <T> T` | ObjectCodec.`treeToValue(JsonNode n, Class<T> valueType)` Convenience method for converting given JSON tree into instance of specified value type.
    `abstract void` | JsonGenerator.`writeObject(Object pojo)` Method for writing given Java object (POJO) as Json.
    `void` | JsonGenerator.`writeObjectField(String fieldName, Object pojo)` Convenience method for outputting a field entry ("member") that has contents of specific Java object as its value.
    `abstract void` | ObjectCodec.`writeTree(JsonGenerator jgen, JsonNode rootNode)` Method to serialize given Json Tree, using generator provided.
    `abstract void` | JsonGenerator.`writeTree(JsonNode rootNode)` Method for writing given JSON tree (expressed as a tree where given JsonNode is the root) using this generator.
    `abstract void` | ObjectCodec.`writeValue(JsonGenerator jgen, Object value)` Method to serialize given Java Object, using generator provided.

  - ### Uses of JsonProcessingException in org.codehaus.jackson.impl

    Methods in org.codehaus.jackson.impl that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected char` | JsonParserMinimalBase.`_handleUnrecognizedCharacterEscape(char ch)`
    `void` | JsonGeneratorBase.`copyCurrentEvent(JsonParser jp)`
    `void` | JsonGeneratorBase.`copyCurrentStructure(JsonParser jp)`
    `void` | JsonGeneratorBase.`writeObject(Object value)`
    `void` | JsonGeneratorBase.`writeTree(JsonNode rootNode)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map

    Subclasses of JsonProcessingException in org.codehaus.jackson.map
    Modifier and Type | Class and Description
    --- | ---
    `class` | `JsonMappingException` Checked exception used to signal fatal problems with mapping of content.

    Methods in org.codehaus.jackson.map that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `abstract void` | SerializerProvider.`defaultSerializeDateKey(Date date, JsonGenerator jgen)` Method that will handle serialization of Dates used as `Map` keys, based on `SerializationConfig.Feature.WRITE_DATE_KEYS_AS_TIMESTAMPS` value (and if using textual representation, configured date format)
    `abstract void` | SerializerProvider.`defaultSerializeDateKey(long timestamp, JsonGenerator jgen)` Method that will handle serialization of Dates used as `Map` keys, based on `SerializationConfig.Feature.WRITE_DATE_KEYS_AS_TIMESTAMPS` value (and if using textual representation, configured date format)
    `abstract void` | SerializerProvider.`defaultSerializeDateValue(Date date, JsonGenerator jgen)` Method that will handle serialization of Date(-like) values, using `SerializationConfig` settings to determine expected serialization behavior.
    `abstract void` | SerializerProvider.`defaultSerializeDateValue(long timestamp, JsonGenerator jgen)` Method that will handle serialization of Date(-like) values, using `SerializationConfig` settings to determine expected serialization behavior.
    `void` | SerializerProvider.`defaultSerializeField(String fieldName, Object value, JsonGenerator jgen)` Convenience method that will serialize given field with specified value.
    `void` | SerializerProvider.`defaultSerializeNull(JsonGenerator jgen)`
    `void` | SerializerProvider.`defaultSerializeValue(Object value, JsonGenerator jgen)` Convenience method that will serialize given value (which can be null) using standard serializer locating functionality.
    `abstract T` | JsonDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)` Method that can be called to ask implementation to deserialize JSON content into the value type this serializer handles.
    `T` | JsonDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, T intoValue)` Alternate deserialization method (compared to the most commonly used, `JsonDeserializer.deserialize(JsonParser, DeserializationContext)`), which takes in initialized value instance, to be configured and/or populated by deserializer.
    `abstract Object` | KeyDeserializer.`deserializeKey(String key, DeserializationContext ctxt)` Method called to deserialize a `Map` key from JSON property name.
    `abstract Object` | TypeDeserializer.`deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)` Method called to let this type deserializer handle deserialization of "typed" object, when value itself may have been serialized using any kind of JSON value (Array, Object, scalar).
    `abstract Object` | TypeDeserializer.`deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)` Method called to let this type deserializer handle deserialization of "typed" object, when value itself is serialized as JSON Array (regardless of Java type).
    `abstract Object` | TypeDeserializer.`deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)` Method called to let this type deserializer handle deserialization of "typed" object, when value itself is serialized as JSON Object (regardless of Java type).
    `abstract Object` | TypeDeserializer.`deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)` Method called to let this type deserializer handle deserialization of "typed" object, when value itself is serialized as a scalar JSON value (something other than Array or Object), regardless of Java type.
    `Object` | JsonDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Deserialization called when type being deserialized is defined to contain additional type identifier, to allow for correctly instantiating correct subtype.
    `boolean` | DeserializationProblemHandler.`handleUnknownProperty(DeserializationContext ctxt, JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName)` Method called when a Json Map ("Object") entry with an unrecognized name is encountered.
    `abstract boolean` | DeserializationContext.`handleUnknownProperty(JsonParser jp, JsonDeserializer<?> deser, Object instanceOrClass, String propName)` Method deserializers can call to inform configured `DeserializationProblemHandler`s of an unrecognized property.
    `JsonNode` | ObjectMapper.`readTree(byte[] content)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectMapper.`readTree(File file)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectReader.`readTree(InputStream in)` Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.
    `JsonNode` | ObjectMapper.`readTree(InputStream in)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectReader.`readTree(JsonParser jp)` Convenience method that binds content read using given parser, using configuration of this reader, except that content is bound as JSON tree instead of configured root value type.
    `JsonNode` | ObjectMapper.`readTree(JsonParser jp)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectMapper.`readTree(JsonParser jp, DeserializationConfig cfg)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectReader.`readTree(Reader r)` Method that reads content from given input source, using configuration of this reader, and binds it as JSON Tree.
    `JsonNode` | ObjectMapper.`readTree(Reader r)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectReader.`readTree(String content)` Method that reads content from given JSON input String, using configuration of this reader, and binds it as JSON Tree.
    `JsonNode` | ObjectMapper.`readTree(String content)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `JsonNode` | ObjectMapper.`readTree(URL source)` Method to deserialize JSON content as tree expressed using set of `JsonNode` instances.
    `<T> T` | ObjectReader.`readValue(byte[] src)` Method that binds content read from given byte array, using configuration of this reader.
    `<T> T` | ObjectReader.`readValue(byte[] src, int offset, int length)` Method that binds content read from given byte array, using configuration of this reader.
    `<T> T` | ObjectReader.`readValue(File src)`
    `<T> T` | ObjectReader.`readValue(InputStream src)` Method that binds content read from given input source, using configuration of this reader.
    `<T> T` | ObjectReader.`readValue(JsonNode src)` Convenience method for converting results from given JSON tree into given value type.
    `<T> T` | ObjectReader.`readValue(JsonParser jp)` Method that binds content read using given parser, using configuration of this reader, including expected result type.
    `<T> T` | ObjectReader.`readValue(JsonParser jp, Class<T> valueType)` Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).
    `<T> T` | ObjectReader.`readValue(JsonParser jp, JavaType valueType)` Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).
    `<T> T` | ObjectReader.`readValue(JsonParser jp, TypeReference<?> valueTypeRef)` Convenience method that binds content read using given parser, using configuration of this reader, except that expected value type is specified with the call (instead of currently configured root type).
    `<T> T` | ObjectReader.`readValue(Reader src)` Method that binds content read from given input source, using configuration of this reader.
    `<T> T` | ObjectReader.`readValue(String src)` Method that binds content read from given JSON string, using configuration of this reader.
    `<T> T` | ObjectReader.`readValue(URL src)` Method that binds content read from given input source, using configuration of this reader.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(byte[] src)` Since 1.9.3
    `<T> MappingIterator<T>` | ObjectReader.`readValues(byte[] src, int offset, int length)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(File src)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(InputStream src)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(JsonParser jp)` Method for reading sequence of Objects from parser stream.
    `<T> Iterator<T>` | ObjectReader.`readValues(JsonParser jp, Class<T> valueType)` Convenience method that is equivalent to:
    `<T> MappingIterator<T>` | ObjectMapper.`readValues(JsonParser jp, Class<T> valueType)` Method for reading sequence of Objects from parser stream.
    `<T> Iterator<T>` | ObjectReader.`readValues(JsonParser jp, JavaType valueType)` Convenience method that is equivalent to:
    `<T> MappingIterator<T>` | ObjectMapper.`readValues(JsonParser jp, JavaType valueType)` Method for reading sequence of Objects from parser stream.
    `<T> Iterator<T>` | ObjectReader.`readValues(JsonParser jp, TypeReference<?> valueTypeRef)` Convenience method that is equivalent to:
    `<T> MappingIterator<T>` | ObjectMapper.`readValues(JsonParser jp, TypeReference<?> valueTypeRef)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(Reader src)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(String json)` Method for reading sequence of Objects from parser stream.
    `<T> MappingIterator<T>` | ObjectReader.`readValues(URL src)` Method for reading sequence of Objects from parser stream.
    `void` | JsonSerializable.`serialize(JsonGenerator jgen, SerializerProvider provider)` Deprecated.
    `abstract void` | JsonSerializer.`serialize(T value, JsonGenerator jgen, SerializerProvider provider)` Method that can be called to ask implementation to serialize values of type this serializer handles.
    `void` | JsonSerializableWithType.`serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`
    `void` | JsonSerializer.`serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)` Method that can be called to ask implementation to serialize values of type this serializer handles, using specified type serializer for embedding necessary type information.
    `<T> T` | ObjectReader.`treeToValue(JsonNode n, Class<T> valueType)`
    `void` | ObjectReader.`writeTree(JsonGenerator jgen, JsonNode rootNode)` NOTE: NOT implemented for `ObjectReader`.
    `void` | ObjectMapper.`writeTree(JsonGenerator jgen, JsonNode rootNode)` Method to serialize given JSON Tree, using generator provided.
    `void` | ObjectMapper.`writeTree(JsonGenerator jgen, JsonNode rootNode, SerializationConfig cfg)` Method to serialize given Json Tree, using generator provided.
    `abstract void` | TypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen)` Method called to write initial part of type information for given value, when it will be output as JSON Array value (not as JSON Object or scalar).
    `void` | TypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)` Alternative version of the prefix-for-array method, which is given actual type to use (instead of using exact type of the value); typically a super type of actual value type
    `abstract void` | TypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen)` Method called to write initial part of type information for given value, when it will be output as JSON Object value (not as JSON Array or scalar).
    `void` | TypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)` Alternative version of the prefix-for-object method, which is given actual type to use (instead of using exact type of the value); typically a super type of actual value type
    `abstract void` | TypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen)` Method called to write initial part of type information for given value, when it will be output as scalar JSON value (not as JSON Object or Array).
    `void` | TypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)` Alternative version of the prefix-for-scalar method, which is given actual type to use (instead of using exact type of the value); typically a super type of actual value type
    `abstract void` | TypeSerializer.`writeTypeSuffixForArray(Object value, JsonGenerator jgen)` Method called after value has been serialized, to close any scopes opened by earlier matching call to `TypeSerializer.writeTypeSuffixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)`.
    `abstract void` | TypeSerializer.`writeTypeSuffixForObject(Object value, JsonGenerator jgen)` Method called after value has been serialized, to close any scopes opened by earlier matching call to `TypeSerializer.writeTypePrefixForObject(java.lang.Object, org.codehaus.jackson.JsonGenerator)`.
    `abstract void` | TypeSerializer.`writeTypeSuffixForScalar(Object value, JsonGenerator jgen)` Method called after value has been serialized, to close any scopes opened by earlier matching call to `TypeSerializer.writeTypePrefixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)`.
    `void` | ObjectReader.`writeValue(JsonGenerator jgen, Object value)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.deser

    Methods in org.codehaus.jackson.map.deser that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | AbstractDeserializer.`_deserializeIfNatural(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | BeanDeserializer.`_deserializeUsingPropertyBased(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize bean using "property-based creator": this means that a non-default constructor or factory method is called, and then possibly other setters.
    `protected JsonDeserializer<Object>` | BeanDeserializer.`_findSubclassDeserializer(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` Helper method called to (try to) locate deserializer for given sub-type of type that this deserializer handles.
    `Object` | ValueInstantiator.`createFromBoolean(boolean value)`
    `Object` | ValueInstantiator.`createFromDouble(double value)`
    `Object` | ValueInstantiator.`createFromInt(int value)`
    `Object` | ValueInstantiator.`createFromLong(long value)`
    `Object` | ValueInstantiator.`createFromObjectWith(Object[] args)` Method called to create value instance from JSON Object when instantiation arguments are passed; this is done, for example when passing information specified with "Creator" annotations.
    `Object` | ValueInstantiator.`createFromString(String value)`
    `Object` | ValueInstantiator.`createUsingDefault()` Method called to create value instance from a JSON value when no data needs to passed to creator (constructor, factory method); typically this will call the default constructor of the value object.
    `Object` | ValueInstantiator.`createUsingDelegate(Object delegate)` Method to called to create value instance from JSON Object using an intermediate "delegate" value to pass to createor method
    `Object` | StdDeserializerProvider.WrappedDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `String` | StdDeserializer.StringDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)` Deprecated.
    `Object` | SettableBeanProperty.`deserialize(JsonParser jp, DeserializationContext ctxt)` This method is needed by some specialized bean deserializers, and also called by some `SettableBeanProperty.deserializeAndSet(org.codehaus.jackson.JsonParser, org.codehaus.jackson.map.DeserializationContext, java.lang.Object)` implementations.
    `Object` | SettableAnyProperty.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Object` | BeanDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)` Main deserialization method for bean-based objects (POJOs).
    `Object` | AbstractDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Object` | StdDeserializerProvider.WrappedDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, Object intoValue)`
    `Object` | BeanDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, Object bean)` Secondary deserialization method, called in cases where POJO instance is created as part of deserialization, potentially after collecting some or all of the properties to set.
    `abstract void` | SettableBeanProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)` Method called to deserialize appropriate value, given parser (and context), and set it using appropriate mechanism.
    `void` | SettableBeanProperty.MethodProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)`
    `void` | SettableBeanProperty.SetterlessProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)`
    `void` | SettableBeanProperty.FieldProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)`
    `void` | SettableBeanProperty.ManagedReferenceProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)`
    `void` | SettableBeanProperty.InnerClassProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `void` | SettableAnyProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance, String propName)` Method called to deserialize appropriate value, given parser (and context), and set it using appropriate method (a setter method).
    `protected JsonNode` | JsonNodeDeserializer.`deserializeAny(JsonParser jp, DeserializationContext ctxt)` Deprecated. since 1.9.0
    `protected ArrayNode` | JsonNodeDeserializer.`deserializeArray(JsonParser jp, DeserializationContext ctxt)` Deprecated. since 1.9.0
    `Object` | BeanDeserializer.`deserializeFromArray(JsonParser jp, DeserializationContext ctxt)`
    `Object` | BeanDeserializer.`deserializeFromBoolean(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON boolean value (true, false)
    `Object` | BeanDeserializer.`deserializeFromDouble(JsonParser jp, DeserializationContext ctxt)` Method called to deserialize POJO value from a JSON floating-point number.
    `Object` | BeanDeserializer.`deserializeFromNumber(JsonParser jp, DeserializationContext ctxt)`
    `Object` | BeanDeserializer.`deserializeFromObject(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | BeanDeserializer.`deserializeFromObjectUsingNonDefault(JsonParser jp, DeserializationContext ctxt)`
    `Object` | BeanDeserializer.`deserializeFromString(JsonParser jp, DeserializationContext ctxt)`
    `protected ObjectNode` | JsonNodeDeserializer.`deserializeObject(JsonParser jp, DeserializationContext ctxt)` Deprecated. since 1.9.0
    `protected Object` | BeanDeserializer.`deserializeUsingPropertyBasedWithExternalTypeId(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | BeanDeserializer.`deserializeUsingPropertyBasedWithUnwrapped(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | BeanDeserializer.`deserializeWithExternalTypeId(JsonParser jp, DeserializationContext ctxt)`
    `protected Object` | BeanDeserializer.`deserializeWithExternalTypeId(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `Object` | StdDeserializerProvider.WrappedDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `String` | StdDeserializer.StringDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Deprecated.
    `Object` | BeanDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | AbstractDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `protected Object` | BeanDeserializer.`deserializeWithUnwrapped(JsonParser jp, DeserializationContext ctxt)` Method called when there are declared "unwrapped" properties which need special handling
    `protected Object` | BeanDeserializer.`deserializeWithUnwrapped(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `protected Object` | BeanDeserializer.`handlePolymorphic(JsonParser jp, DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` 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.
    `protected Object` | BeanDeserializer.`handleUnknownProperties(DeserializationContext ctxt, Object bean, TokenBuffer unknownTokens)` Method called to handle set of one or more unknown properties, stored in their entirety in given `TokenBuffer` (as field entries, name and value).
    `protected void` | BeanDeserializer.`handleUnknownProperty(JsonParser jp, DeserializationContext ctxt, Object beanOrClass, String propName)` Method called when a JSON property is encountered that has not matching setter, any-setter or field, and thus can not be assigned.
    `boolean` | StdDeserializationContext.`handleUnknownProperty(JsonParser jp, JsonDeserializer<?> deser, Object instanceOrClass, String propName)` Method deserializers can call to inform configured `DeserializationProblemHandler`s of an unrecognized property.
    `protected void` | BeanDeserializer.`injectValues(DeserializationContext ctxt, Object bean)`
    `Object` | SettableBeanProperty.NullProvider.`nullValue(DeserializationContext ctxt)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.deser.impl

    Methods in org.codehaus.jackson.map.deser.impl that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | ExternalTypeHandler.`_deserialize(JsonParser jp, DeserializationContext ctxt, Object bean, int index)`
    `abstract void` | PropertyValue.`assign(Object bean)` Method called to assign stored value of this property to specified bean instance
    `Object` | ExternalTypeHandler.`complete(JsonParser jp, DeserializationContext ctxt, Object bean)`
    `void` | CreatorProperty.`deserializeAndSet(JsonParser jp, DeserializationContext ctxt, Object instance)`
    `boolean` | ExternalTypeHandler.`handleToken(JsonParser jp, DeserializationContext ctxt, String propName, Object bean)` Method called to ask handler to handle
    `boolean` | ExternalTypeHandler.`handleTypePropertyValue(JsonParser jp, DeserializationContext ctxt, String propName, Object bean)` Method called to see if given property/value pair is an external type id; and if so handle it.
    `Object` | UnwrappedPropertyHandler.`processUnwrapped(JsonParser originalParser, DeserializationContext ctxt, Object bean, TokenBuffer buffered)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.deser.std

    Methods in org.codehaus.jackson.map.deser.std that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | StdValueInstantiator.`_createFromStringFallbacks(String value)`
    `protected abstract T` | FromStringDeserializer.`_deserialize(String value, DeserializationContext ctxt)`
    `protected UUID` | FromStringDeserializer.UUIDDeserializer.`_deserialize(String value, DeserializationContext ctxt)`
    `protected T` | FromStringDeserializer.`_deserializeEmbedded(Object ob, DeserializationContext ctxt)`
    `protected UUID` | FromStringDeserializer.UUIDDeserializer.`_deserializeEmbedded(Object ob, DeserializationContext ctxt)`
    `Map<Object,Object>` | MapDeserializer.`_deserializeUsingCreator(JsonParser jp, DeserializationContext ctxt)`
    `protected Boolean` | StdDeserializer.`_parseBoolean(JsonParser jp, DeserializationContext ctxt)`
    `protected boolean` | StdDeserializer.`_parseBooleanFromNumber(JsonParser jp, DeserializationContext ctxt)`
    `protected boolean` | StdDeserializer.`_parseBooleanPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Byte` | StdDeserializer.`_parseByte(JsonParser jp, DeserializationContext ctxt)`
    `protected Date` | StdDeserializer.`_parseDate(JsonParser jp, DeserializationContext ctxt)`
    `protected Double` | StdDeserializer.`_parseDouble(JsonParser jp, DeserializationContext ctxt)`
    `protected double` | StdDeserializer.`_parseDoublePrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Float` | StdDeserializer.`_parseFloat(JsonParser jp, DeserializationContext ctxt)`
    `protected float` | StdDeserializer.`_parseFloatPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Integer` | StdDeserializer.`_parseInteger(JsonParser jp, DeserializationContext ctxt)`
    `protected int` | StdDeserializer.`_parseIntPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Long` | StdDeserializer.`_parseLong(JsonParser jp, DeserializationContext ctxt)`
    `protected long` | StdDeserializer.`_parseLongPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected Short` | StdDeserializer.`_parseShort(JsonParser jp, DeserializationContext ctxt)`
    `protected short` | StdDeserializer.`_parseShortPrimitive(JsonParser jp, DeserializationContext ctxt)`
    `protected void` | MapDeserializer.`_readAndBind(JsonParser jp, DeserializationContext ctxt, Map<Object,Object> result)`
    `Object` | StdValueInstantiator.`createFromBoolean(boolean value)`
    `Object` | StdValueInstantiator.`createFromDouble(double value)`
    `Object` | StdValueInstantiator.`createFromInt(int value)`
    `Object` | StdValueInstantiator.`createFromLong(long value)`
    `Object` | StdValueInstantiator.`createFromObjectWith(Object[] args)`
    `Object` | StdValueInstantiator.`createFromString(String value)`
    `Object` | StdValueInstantiator.`createUsingDefault()`
    `Object` | StdValueInstantiator.`createUsingDelegate(Object delegate)`
    `Object` | UntypedObjectDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `TokenBuffer` | TokenBufferDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Timestamp` | TimestampDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `String` | StringDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Collection<String>` | StringCollectionDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Boolean` | StdDeserializer.BooleanDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Byte` | StdDeserializer.ByteDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Short` | StdDeserializer.ShortDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Character` | StdDeserializer.CharacterDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Integer` | StdDeserializer.IntegerDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Long` | StdDeserializer.LongDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Float` | StdDeserializer.FloatDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Double` | StdDeserializer.DoubleDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Number` | StdDeserializer.NumberDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `BigDecimal` | StdDeserializer.BigDecimalDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `BigInteger` | StdDeserializer.BigIntegerDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Date` | StdDeserializer.SqlDateDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `StackTraceElement` | StdDeserializer.StackTraceElementDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Object[]` | ObjectArrayDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Map<Object,Object>` | MapDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `JsonNode` | JsonNodeDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)` Implementation that will produce types of any JSON nodes; not just one deserializer is registered to handle (in case of more specialized handler).
    `JavaType` | JavaTypeDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `T` | FromStringDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `EnumSet<?>` | EnumSetDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `EnumMap<?,?>` | EnumMapDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Enum<?>` | EnumDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Object` | EnumDeserializer.FactoryBasedDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Date` | DateDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Collection<Object>` | CollectionDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Class<?>` | ClassDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Calendar` | CalendarDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `AtomicReference<?>` | AtomicReferenceDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `AtomicBoolean` | AtomicBooleanDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Collection<Object>` | CollectionDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, Collection<Object> result)`
    `Collection<String>` | StringCollectionDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, Collection<String> result)`
    `Map<Object,Object>` | MapDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt, Map<Object,Object> result)`
    `protected Byte[]` | ObjectArrayDeserializer.`deserializeFromBase64(JsonParser jp, DeserializationContext ctxt)`
    `Object` | ThrowableDeserializer.`deserializeFromObject(JsonParser jp, DeserializationContext ctxt)`
    `Object` | StdKeyDeserializer.`deserializeKey(String key, DeserializationContext ctxt)`
    `Object` | UntypedObjectDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `String` | StringDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | StringCollectionDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | StdScalarDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | StdDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` Base implementation that does not assume specific type inclusion mechanism.
    `Boolean` | StdDeserializer.BooleanDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Integer` | StdDeserializer.IntegerDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Double` | StdDeserializer.DoubleDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | StdDeserializer.NumberDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)` As mentioned in class Javadoc, there is additional complexity in handling potentially mixed type information here.
    `Object` | PrimitiveArrayDeserializers.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object[]` | ObjectArrayDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | MapDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | EnumSetDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | EnumMapDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `Object` | CollectionDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `protected void` | StdDeserializer.`handleUnknownProperty(JsonParser jp, DeserializationContext ctxt, Object instanceOrClass, String propName)` Method called to deal with a property that did not map to a known Bean property.
    `protected Object` | UntypedObjectDeserializer.`mapArray(JsonParser jp, DeserializationContext ctxt)` Method called to map a JSON Array into a Java value.
    `protected Object[]` | UntypedObjectDeserializer.`mapArrayToArray(JsonParser jp, DeserializationContext ctxt)` Method called to map a JSON Array into a Java Object array (Object[]).
    `protected Object` | UntypedObjectDeserializer.`mapObject(JsonParser jp, DeserializationContext ctxt)` Method called to map a JSON Object into a Java value.
    `protected void` | StdDeserializer.`reportUnknownProperty(DeserializationContext ctxt, Object instanceOrClass, String fieldName)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.exc

    Subclasses of JsonProcessingException in org.codehaus.jackson.map.exc
    Modifier and Type | Class and Description
    --- | ---
    `class` | `UnrecognizedPropertyException` Specialized `JsonMappingException` sub-class specifically used to indicate problems due to encountering a JSON property that could not be mapped to an Object property (via getter, constructor argument or field).

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.ext

    Methods in org.codehaus.jackson.map.ext that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `T` | JodaDeserializers.DateTimeDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `LocalDate` | JodaDeserializers.LocalDateDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `LocalDateTime` | JodaDeserializers.LocalDateTimeDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `DateMidnight` | JodaDeserializers.DateMidnightDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `ReadablePeriod` | JodaDeserializers.PeriodDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `XMLGregorianCalendar` | CoreXMLDeserializers.GregorianCalendarDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `protected String` | JodaSerializers.JodaSerializer.`printLocalDate(ReadableInstant dateValue)`
    `protected String` | JodaSerializers.JodaSerializer.`printLocalDate(ReadablePartial dateValue)`
    `protected String` | JodaSerializers.JodaSerializer.`printLocalDateTime(ReadablePartial dateValue)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.jsontype.impl

    Methods in org.codehaus.jackson.map.jsontype.impl that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | AsPropertyTypeDeserializer.`_deserializeIfNatural(JsonParser jp, DeserializationContext ctxt)` Helper method used to check if given parser might be pointing to a "natural" value, and one that would be acceptable as the result value (compatible with declared base type)
    `protected Object` | AsPropertyTypeDeserializer.`_deserializeTypedUsingDefaultImpl(JsonParser jp, DeserializationContext ctxt, TokenBuffer tb)`
    `protected JsonDeserializer<Object>` | TypeDeserializerBase.`_findDefaultImplDeserializer(DeserializationContext ctxt)`
    `protected JsonDeserializer<Object>` | TypeDeserializerBase.`_findDeserializer(DeserializationContext ctxt, String typeId)`
    `protected String` | AsArrayTypeDeserializer.`_locateTypeId(JsonParser jp, DeserializationContext ctxt)`
    `protected void` | AsExternalTypeSerializer.`_writePrefix(Object value, JsonGenerator jgen)`
    `protected void` | AsExternalTypeSerializer.`_writePrefix(Object value, JsonGenerator jgen, Class<?> type)`
    `protected void` | AsExternalTypeSerializer.`_writeSuffix(Object value, JsonGenerator jgen)`
    `Object` | AsWrapperTypeDeserializer.`deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)`
    `Object` | AsPropertyTypeDeserializer.`deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)`
    `Object` | AsArrayTypeDeserializer.`deserializeTypedFromAny(JsonParser jp, DeserializationContext ctxt)`
    `Object` | AsWrapperTypeDeserializer.`deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)`
    `Object` | AsArrayTypeDeserializer.`deserializeTypedFromArray(JsonParser jp, DeserializationContext ctxt)` Method called when actual object is serialized as JSON Array.
    `Object` | AsWrapperTypeDeserializer.`deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)` Deserializing type id enclosed using WRAPPER_OBJECT style is straightforward
    `Object` | AsPropertyTypeDeserializer.`deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)` This is the trickiest thing to handle, since property we are looking for may be anywhere...
    `Object` | AsArrayTypeDeserializer.`deserializeTypedFromObject(JsonParser jp, DeserializationContext ctxt)` Method called when actual object is serialized as JSON Object
    `Object` | AsWrapperTypeDeserializer.`deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)`
    `Object` | AsArrayTypeDeserializer.`deserializeTypedFromScalar(JsonParser jp, DeserializationContext ctxt)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForArray(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen)`
    `void` | AsPropertyTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsPropertyTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForObject(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen)`
    `void` | AsWrapperTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsExternalTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsArrayTypeSerializer.`writeTypePrefixForScalar(Object value, JsonGenerator jgen, Class<?> type)`
    `void` | AsWrapperTypeSerializer.`writeTypeSuffixForArray(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypeSuffixForArray(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypeSuffixForArray(Object value, JsonGenerator jgen)`
    `void` | AsWrapperTypeSerializer.`writeTypeSuffixForObject(Object value, JsonGenerator jgen)`
    `void` | AsPropertyTypeSerializer.`writeTypeSuffixForObject(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypeSuffixForObject(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypeSuffixForObject(Object value, JsonGenerator jgen)`
    `void` | AsWrapperTypeSerializer.`writeTypeSuffixForScalar(Object value, JsonGenerator jgen)`
    `void` | AsExternalTypeSerializer.`writeTypeSuffixForScalar(Object value, JsonGenerator jgen)`
    `void` | AsArrayTypeSerializer.`writeTypeSuffixForScalar(Object value, JsonGenerator jgen)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.ser

    Methods in org.codehaus.jackson.map.ser that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | StdSerializerProvider.`_reportIncompatibleRootType(Object value, JavaType rootType)`
    `protected void` | StdSerializerProvider.`_serializeValue(JsonGenerator jgen, Object value)` Method called on the actual non-blueprint provider instance object, to kick off the serialization.
    `protected void` | StdSerializerProvider.`_serializeValue(JsonGenerator jgen, Object value, JavaType rootType)` Method called on the actual non-blueprint provider instance object, to kick off the serialization, when root type is explicitly specified and not determined from value.
    `void` | StdSerializerProvider.`defaultSerializeDateKey(Date date, JsonGenerator jgen)`
    `void` | StdSerializerProvider.`defaultSerializeDateKey(long timestamp, JsonGenerator jgen)`
    `void` | StdSerializerProvider.`defaultSerializeDateValue(Date date, JsonGenerator jgen)`
    `void` | StdSerializerProvider.`defaultSerializeDateValue(long timestamp, JsonGenerator jgen)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.ser.std

    Methods in org.codehaus.jackson.map.ser.std that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `void` | JsonValueSerializer.`serializeWithType(Object bean, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`
    `void` | RawSerializer.`serializeWithType(T value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.type

    Methods in org.codehaus.jackson.map.type that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TypeBase.`serialize(JsonGenerator jgen, SerializerProvider provider)`
    `void` | TypeBase.`serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.map.util

    Methods in org.codehaus.jackson.map.util that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `void` | JSONWrappedObject.`serialize(JsonGenerator jgen, SerializerProvider provider)`
    `void` | JSONPObject.`serialize(JsonGenerator jgen, SerializerProvider provider)`
    `void` | JSONWrappedObject.`serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`
    `void` | JSONPObject.`serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.node

    Methods in org.codehaus.jackson.node that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TextNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | POJONode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | ObjectNode.`serialize(JsonGenerator jg, SerializerProvider provider)` Method that can be called to serialize this node and all of its descendants using specified JSON generator.
    `void` | NullNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | MissingNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | LongNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | IntNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | DoubleNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | DecimalNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | BooleanNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | BinaryNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | BigIntegerNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `abstract void` | BaseJsonNode.`serialize(JsonGenerator jgen, SerializerProvider provider)` Method called to serialize node instances using given generator.
    `void` | ArrayNode.`serialize(JsonGenerator jg, SerializerProvider provider)`
    `void` | ValueNode.`serializeWithType(JsonGenerator jg, SerializerProvider provider, TypeSerializer typeSer)`
    `void` | ObjectNode.`serializeWithType(JsonGenerator jg, SerializerProvider provider, TypeSerializer typeSer)`
    `void` | MissingNode.`serializeWithType(JsonGenerator jg, SerializerProvider provider, TypeSerializer typeSer)`
    `abstract void` | BaseJsonNode.`serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)` Type information is needed, even if JsonNode instances are "plain" JSON, since they may be mixed with other types.
    `void` | ArrayNode.`serializeWithType(JsonGenerator jg, SerializerProvider provider, TypeSerializer typeSer)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.util

    Methods in org.codehaus.jackson.util that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `void` | TokenBuffer.`copyCurrentEvent(JsonParser jp)`
    `void` | JsonGeneratorDelegate.`copyCurrentEvent(JsonParser jp)`
    `void` | TokenBuffer.`copyCurrentStructure(JsonParser jp)`
    `void` | JsonGeneratorDelegate.`copyCurrentStructure(JsonParser jp)`
    `void` | TokenBuffer.`writeObject(Object value)`
    `void` | JsonGeneratorDelegate.`writeObject(Object pojo)`
    `void` | TokenBuffer.`writeTree(JsonNode rootNode)`
    `void` | JsonGeneratorDelegate.`writeTree(JsonNode rootNode)`

  - ### Uses of JsonProcessingException in org.codehaus.jackson.xc

    Methods in org.codehaus.jackson.xc that throw JsonProcessingException
    Modifier and Type | Method and Description
    --- | ---
    `Object` | XmlAdapterJsonDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Element` | DomElementJsonDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `DataHandler` | DataHandlerJsonDeserializer.`deserialize(JsonParser jp, DeserializationContext ctxt)`
    `Object` | XmlAdapterJsonDeserializer.`deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer)`
    `void` | DataHandlerJsonSerializer.`serialize(DataHandler value, JsonGenerator jgen, SerializerProvider provider)`