Version: 1.9.7

Release date:
  xx-May-2012

Description:
  Another patch release for 1.9.

  Fixes:

  * [Smile/Issue-2] SmileParser failed to decode surrogate-pair characters for
    long Strings
   (reported by Steven S)
  * [Issue-11] JsonParser.getValueAsLong() returning int, not long
   (reported by Daniel L)
  * [JACKSON-829] Custom serializers not working for List<String> properties,
    @JsonSerialize(contentUsing)
   (reported by James R)

------------------------------------------------------------------------
=== History: ===
------------------------------------------------------------------------

1.9.6 [26-Mar-2012]

  Fixes:

  * [JACKSON-763] State of base64/byte[] decoding not reset when
    using 'convertValue()' for list of byte[] values.
   (reported by Erik G)
  * [JACKSON-794]: JDK 7 has new property for Exceptions ("suppressable"),
    needs to be ignored during deserialization
  * [JACKSON-799]: JsonSerialize.as not working as class annotation, for root values
  * [JACKSON-802]: Improvements to class loading to use both contextual
    class loader and Class.forName, as necessary
  * [JACKSON-803]: Problems with Smile, parsing of long names
   (reported by D Lam)
  * [JACKSON-804]: Allow byte range up to 255, for interoperability with unsigned bytes
  * [JACKSON-806]: REQUIRE_SETTERS_FOR_GETTERS ignores explicitly annotated getters
   (reported by Harold M)
  * [JACKSON-812]: BigIntegerNode.equals(...) using '==' for equality
  * [JACKSON-820]: WriterBasedGenerator with CharacterEscapes produces unescaped output
    for strings > 2k in length
   (reported by Matt S)

1.9.5 [24-Feb-2012]

  Fixes:

  * [JACKSON-757]: further fixing (1.9.4 had partial fix)
  * [JACKSON-773]: Bug in SimpleFilterProvider constructor
   (reported by Kenny M)
  * [JACKSON-774]: PropertyBasedCreator was not using JsonDeserializer.getNullValue()
   (reported by Nathaniel B)
  * [JACKSON-775]: MissingNode.asText() should return "", not null
   (reported by Ittai Z)
  * [JACKSON-778]: Incorrect detection of generic types with TypeReference
   (reported by Vladimir P)
  * [JACKSON-779]: Problems with multi-byte UTF-8 chars in JSON comments
   (reported by Alexander K)
  * [JACKSON-789]: Add support for 'java.nio.charset.Charset'
  * [JACKSON-796]: Problems with byte[] conversion to/from JsonNode.
   (reported by Christopher B)

1.9.4 [20-Jan-2012]

  Fixes:

  * [JACKSON-712] Issue with @JsonCreator + DefaultImpl
   (suggested by Eric T)
  * [JACKSON-744] @JsonAnySetter problems with 1.9
  * [JACKSON-746] Problems with JsonTypeInfo.Id.NONE, default typing
   (reported by Steve L)
   (reported by Sebastian T)
  * [JACKSON-756] Problems with enums, @JsonCreator, when used as keys
    of EnumMap, regular Map, or contents of EnumSet
   (reported by Mika M)
  * [JACKSON-757] Problems with Enum values, annotations on constructors
     -- but note, some issues remained for 1.9.5 to tackle
   (reported by Stephan B)

  (all fixes up to 1.8.8)
  
1.9.3 [16-Dec-2011]

  Improvements:

  * [JACKSON-657] Add Date/Calendar key deserializers
   (contributed by Andreas K, Tobias S)
  * [JACKSON-717] ObjectReader.updateValues(): use configured 'valueToUpdate'
  * [JACKSON-726] Add java.util.UUID key deserializer
   (suggested by Steven S)
  * [JACKSON-729] Add 'ObjectMapper.readValues(byte[])' convenience method

  Fixes:

  (all fixes up to 1.8.7)

1.9.2 [04-Nov-2011]

  Improvements:
  
  * [JACKSON-706] Joda support: add support for "org.joda.time.Period"
    (suggested by Dain S)
  
  Fixes:

  * [JACKSON-700] Type problems with properties that have different types
    for constructor property, setter and/or field
   (reported by Ben H)
  * [JACKSON-703] 'SerializationConfig.isEnabled(...)',
    'DeserializationConfig.isEnabled(...)' incompatible due to signature change

1.9.1 [23-Oct-2011]

  Fixes:
  
  * [JACKSON-687] Problems with PropertyNamingStrategy, property merging
   (reported by Pascal G)  
  * [JACKSON-689] Deserialization of Iterable fails
   (reported by Pascal G)
  * [JACKSON-693] @JsonBackReference not used during deserialization if it's annotated
   on a getter method.
   (reported by Pascal G)

1.9.0 [04-Oct-2011]

  Fixes:
  
  * [JACKSON-539] Incorrect handling of combination of JAXB annotations
    (@XmlTransient with property renaming)
   (reported Ryan H)
  * [JACKSON-605] Handle deserialization of typed Class properties correctly
   (reported by Bruce P)

  Improvements:

  * [JACKSON-242] Rewrite property introspection part of framework to combine
    getter/setter/field annotations
  * [JACKSON-505] Handle missing type information gracefully by checking for
    abstract type mapping to find default implementation, if no valid type
    information found for @JsonTypeInfo
  * [JACKSON-531] Comparing actual and default value (for JsonSerialize.Inclusion.NON_DEFAULT)
    should check array contents
    (suggested by Christoph S)
  * [JACKSON-584] Serialize type info for non-static anonymous inner classes
    as that of declared (static) type
    (suggested by Earl B)
  * [JACKSON-593] Add ObjectMapper.readTree(byte[]), (URL) variants
   (suggested by Bruce P)
  * [JACKSON-594] Allow deserializing non-static inner class valued properties
   (suggested by Bruce P)
  * [JACKSON-595] Terse Visibility Config (ObjectMapper.setVisibility, related)
   (suggested by Bruce P)
  * [JACKSON-598] Add set of standard naming-strategy implementations
   (suggested by Bruce P)
  * [JACKSON-599] Expose Settability Of SimpleModule Serializers/Deserializers
   (suggested by Bruce P)
  * [JACKSON-606] Add Built-in Support for Date Map Keys as Timestamps
   (SerializationConfig.Feature#WRITE_DATE_KEYS_AS_TIMESTAMPS)
  * [JACKSON-612] Expose 'readValues()' methods via ObjectCodec, JsonParser
   (suggested by Bruce P)
  * [JACKSON-613] Add ArrayNode/ObjectNode methods for dealing with wrapper
    values, unboxing, nulls
   (suggested by Bruce P)
  * [JACKSON-615] Make JavaType serializable/deserializable
  * [JACKSON-616] Better handling of primitive deserializers, to avoid NPEs
   (suggested by Bruce P)
  * [JACKSON-619] SmileParser.getCurrentLocation(), getTokenLocation() did not
    report actual byte offsets.
   (reported by Ray R)
  * [JACKSON-620] Allow empty String to mean null Map, Collection, array,
    if 'DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT' enabled
  * [JACKSON-621] Add new fluent method, VisibilityChecker.with(Visibility)
   (suggested by Bruce P)
  * [JACKSON-638] TypeFactory methods for constructing "raw" map or collection types
   (suggested by Christopher C)
  * [JACKSON-639] Change BasicClassIntrospector.forClassAnnotations to take
    JavaType (not raw Class)
   (requested by Chris C)
  * [JACKSON-643] ObjectMapper.readValue() should check JsonDeserializer.getNullValue()
    when encountering root-level JsonToken.VALUE_NULL
  * [JACKSON-644] Add SimpleModule.setMixInAnnotations()
  * [JACKSON-648] ObjectWriter: allow changing default serialization DateFormat
    (ObjectMapper.writer(DateFormat), ObjectWriter.withDateFormat(DateFormat))
  * [JACKSON-650] Allow dealing with missing filter ids, by adding
    'SimpleFilterProvider.setFailOnUnknownId()' to specify if exception is thrown or not.
    (suggested by Kirill S)
  * [JACKSON-661] Add shorter 'JsonNode.asXxx' methods to replace 'JsonNode.getValueAsXxx'
  * [JACKSON-662] Add 'ObjectMapper.enable()' and 'ObjectMapper.disable()' to allow
    enabling/disabling multiple features with a single call.
  * [JACKSON-665] Add 'AnnotatedWithParams.getIndex()' for accessing index of a
    method or constructor parameter
   (requested by Chistropher C)
  * [JACKSON-671] Add convenience constructor for 'MinimalPrettyPrinter'
   (requested by David P)
  * [JACKSON-683] Mr Bean: Fail gracefully if attempt is made to materialize
    non-public type (since impl class on different package than base class)
  * [JACKSON-684] Add SerializationConfig.Feature.WRITE_ENUMS_USING_INDEX to serialize
    Enums as int (index)

  New features:

  * [JACKSON-132] Support "unwrapped" properties, using @JsonUnwrapped. 
  * [JACKSON-254] Add 'SerializationConfig.Feature.WRITE_EMPTY_JSON_ARRAYS',
    which can be used to suppress serialization of empty JSON arrays (unless
    overridden by per-property annotations).
   (suggested by Fabrice D)
  * [JACKSON-406] Allow injecting of values (with @JacksonInject) during deserialization
  * [JACKSON-453] Support "external type id" with new @JsonTypeInfo.As enum value,
    EXTERNAL_PROPERTY
  * [JACKSON-558] Add 'DeserializationConfig.Feature.UNWRAP_ROOT_VALUE' as
    matching counterpart for 'SerializationConfig.Feature.WRAP_ROOT_VALUE'
   (requested by Anand H)
  * [JACKSON-578] Allow use of @JsonView on JAX-RS resource, with JacksonJsonProvider
   (suggested by Matt G)
  * [JACKSON-580] Allow registering instantiators (ValueInstantiator) for types (classes)
  * [JACKSON-581] Add 'ObjectMapper.readTree(File)'
   (suggested by Pascal G)
  * [JACKSON-602] Add 'JsonSerialize.Inclusion.NON_EMPTY' option
   (suggested by Ed A)
  * [JACKSON-614] Add JsonTypeInfo.defaultImpl property to indicate type to use if type name missing
  * [JACKSON-630] Add @JsonRootName annotation for specifying name of root-level wrapper
   (requested by Lukasz Strzelecki)
  * [JACKSON-633] Add @JsonValueInstantiator to allow annotating which ValueInstantiator
   a type uses.
  * [JACKSON-652] Add 'DeserializationConfig.Feature.USE_JAVA_ARRAY_FOR_JSON_ARRAY' to
    allow mapping JSON Array to Object[]
   (suggested by Simone B)
  * [JACKSON-653] Add 'JsonParser.isNextTokenName()' for more efficient field name matching
  * [JACKSON-666] Add 'Add SerializationConfig.Feature.REQUIRE_SETTERS_FOR_GETTERS' to allow
    suppressing use of getters for which there is no matching mutator.
  
  Issues handled by new external projects:

  * [JACKSON-51]: Implement Just-In-Time code generation for serialization
    created "jackson-module-afterburner" at [https://github.com/FasterXML/jackson-module-afterburner]

  Potential backwards compatibility issues (compared to 1.8.x):

  * Removed 'org.codehaus.jackson.annotate.JsonClass, JsonKeyClass and
    JsonContentClass (deprecated since 1.1)
  * Move TokenBufferDeserializer to separate class (from inside StdDeserializer)

1.8.8 [20-Jan-2012]

  Fixes:

  * [JACKSON-701] ArrayIndexOutOfBoundsException when trying to serialize
    non-static inner classes with annotations on last ctor param
   (reported Lloyd S)
  * [JACKSON-741] Add missing linkage from ObjectMapper to JsonFactory
   by calling 'JsonFactory.setCodec()' from ObjectMapper constructor
  * [JACKSON-753] JsonParserDelegate missing delegation of getBooleanValue(),
    getEmbeddedObject()
   (reported by Sebastian T)
  * Partial fix for [JACSON-756]: EnumMap, EnumSet work with enums that use
   @JsonCreator; regular Maps only with 1.9
   (reported by Mika M)

1.8.7 [16-Dec-2011]

  Fixes:

  * [JACKSON-462] (REGRESSION?) Buffer overflow in Utf8Generator#writeFieldName(String)
   (reported by Ryan K)
  * [JACKSON-696] Problems accessing "any getter" that is not public
   (reported by Brian M)
  * [JACKSON-709] Problems converting base64-encoded Strings between
    JsonNode, POJOs
   (reported by Tom B)
  * [JACKSON-733] Smile-based mapper could not properly bind byte[] values
   (reported by Jacques-Olivier G)
  * [JACKSON-738] Parsing fails for Unicode 1Fxxx symbols when skipping
   (reported by Alex T)

1.8.6 [04-Oct-2011]

  Fixes:

  * [JACKSON-288] Problems (de)serializing values with JAXB adapters
  * [JACKSON-668] Problems with 'JsonParser.getDecimalValue' not
    clearing earlier state
   (reported by Ransom B)
  * [JACKSON-677] Inner generic type references not working properly
   (reported by William B)

1.8.5 [04-Aug-2011]

  Fixes:

  * [JACKSON-401] Further fixes to ensure FLUSH_PASSED_TO_STREAM works
  * [JACKSON-637] NumberSerializer was missing proper handling of Integer, Long
   (reported by Paul M)
  * [JACKSON-640] SmileParser.getTextCharacters() missing value in some
    cases (value back-references)
  * [JACKSON-647] ResolvableSerializer.resolve() not called after creating
    contextual instance

1.8.4 [25-Jul-2011]

  Fixes:

  * [JACKSON-605] Handle deserialization of Class<T> properties
  * [JACKSON-627] WriterBasedGenerator failure for long Strings,
    custom character escaping
    (reported by Lawrence C)
  * [JACKSON-629] Fix a	buffer boundary problem	with SmileParser, 5-7
    character names
    (reported by Maxxan)
  * [JACKSON-631] Problems decoding Base64Variants.MODIFIED_FOR_URL
    (reported by Tim B)
  * [JACKSON-632] Handling of UTF-8 BOM incorrect, causing "Internal Error"
    (reported by Edward A)

1.8.3 [08-Jul-2011]

  Fixes:

  * [JACKSON-587] TextNode.getValueAsLong() does not work properly
   (reported by Chris P)
  * [JACKSON-591] JodaDeserializers not throwing wrongTokenException
   (reported by Tom L)
  * [JACKSON-597] Make ClassDeserializer support primitive types
   (suggested by Bruce P)
  (plus all 1.7 fixes up to 1.7.8)

1.8.2 [15-Jun-2011]

  Fixes:

  * Problem with FilteredBeanPropertyWriter: was not delegating call
    to wrapped BeanPropertyWriter, causing problems with modules

1.8.1 [17-May-2011]

  Fixes:
  
  * [JACKSON-557] CollectionLikeType#equals() casts parameter to CollectionType
   (reported by Coda H)
  * [JACKSON-560] Mix-in annotations ignored when used with views
   (reported by Ruben E-G)
  * [JACKSON-568] Package 'org.codehaus.jackson.util' missing from
    core/lgpl jar
   (reported by Christoph S)
  * [JACKSON-570] Caching of MapSerializer not thread-safe
   (reported by Jamie R)
  * [JACKSON-573] Failure to serialize certain Unicode Strings
   (reported by Young J-P)
  (plus all 1.7 fixes up to 1.7.7)

1.8.0 [20-Apr-2011]

  Another minor release. Main improvements are:
  
  - Proper configurability for key serializers, deserializers
  - Ability to control details of low-level character escaping
  - Pluggable format auto-detection (for JSON and Smile in core packages)
  - Fully configurable type-defaulting (abstract-to-concrete) for deserialization
  - Pass-through FormatSchema abstraction to help support schema-based formats

  New features:
  
  * [JACKSON-43]: Add "ObjectMapper.readValues()", "ObjectReader.readValues()" for
    more convenient binding of arrays (and root-level sequences) of homogenous types
  * [JACKSON-102]: Ability to force escaping of non-ASCII characters; using
    JsonGenerator.Feature.ESCAPE_NON_ASCII and JsonGenerator.setHighestNonEscapedChar
  * [JACKSON-106]: Add 'org.codehaus.jackson.io.CharacterEscapes' which can be
    registered with JsonFactory, JsonGenerator, to add fully customized
    character escaping handling
    (suggested by Scott A)
  * [JACKSON-142]: Add 'JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS' to allow
    non-standard use of 'NaN', '+INF'/'+Infinite', '-INF'/'-Infinite' as numbers
  * [JACKSON-178]: Add support for custom property name strategies (with
    PropertyNamingStrategy)
  * [JACKSON-204]: Add DeserializationConfig.Feature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT
    to allow binding empty JSON String as null for POJOs
  * [JACKSON-358]: Add JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, to allow
    optional (and non-standard) support for numbers like 00006
    (suggested by Bryce M)
  * [JACKSON-427]: Added "JsonNode.with()" which is similar to "JsonNode.path()" but
    creates ObjectNode for property if no value exists (similar to "upsert" (update-or-insert))
  * [JACKSON-464]: Allow defining default mappings for abstract types, with
    SimpleAbstractTypeResolver
  * [JACKSON-494]: Add support for format auto-detection (via JsonFactory); add
    support for basic JSON, Smile (and as many modules as possible)
  * [JACKSON-512]: Allow wrapping InputStream/Reader, OutputStream/Writer when
    constructing JsonParser, JsonGenerator; JsonFactory allows registering
    InputDecorator, OutputDecorator instances.
  * [JACKSON-513]: Add methods for registering key serializers, deserializers,
    via Module API
  * [JACKSON-520]: Add minimal FormatSchema abstraction, passed through by ObjectMapper
    to JsonGenerator, JsonParser; needed for supporting schema-based formats.
  * [JACKSON-521]: Add support for new 'MapLikeType' and 'CollectionLikeType', to
    support Map/Collection types of languages like Scala
  * [JACKSON-523]: Allow passing actual type for TypeSerializer to use, to
    force specific super type to be used (instead of a concrete sub type)
  * [JACKSON-526]: Add DeserializationConfig.Feature.ACCEPT_SINGLE_VALUE_AS_ARRAY
    which allows implicit conversion from JSON scalars and Objects into single-element
    collections/arrays (for interoperability with XML-to-JSON converers like Jettison)
  * [JACKSON-527]: Add 'HandlerInstantiator' abstraction, which can be implemented and
    registered with ObjectMapper to get more control over how handlers (serializers,
    deserializers, type id resolver) are constructed.
    (requested by Sven J)
  * [JACKSON-555]: Add 'JsonParser.getInputSource()' and 'JsonGenerator.getOutputTarget()'
    to give direct access to low-level stream/reader/writer instances

  Improvements:

  * [JACKSON-480]: Added missing @JsonSerialize properties: keyAs, keyUsing,
    contentAs, contentUsing
  * [JACKSON-502]: Convert mr Bean functionality to be basic Module
  * [JACKSON-503]: Allow registering AbstractTypeResolvers via Module API
  * [JACKSON-519]: Add support for contextual key serializers, deserializers
  * [JACKSON-548]: enabling ALLOW_SINGLE_QUOTES should allow backslash-escaping
    of apostrophes
   (suggested by Tim W)
  * [JACKSON-551]: Add new methods to 'Serializers' and 'Deserializers' interfaces to
    support CollectionLikeType, MapLikeType.

  Fixes:

  * [JACKSON-459]: Add mapper-level configuration to set default serialization
    order be alphabetic (by property name).
   (suggested by Chris W)
  * [JACKSON-487]: Block all annotation access if SerializationConfig.Feature.USE_ANNOTATIONS
    (and ditto for DeserializationConfig) is disabled; to help with Android, missing JAXB annotations
  * [JACKSON-498]: Fix issues with type names, abstract types, collections
    (reported by John V)
  * [JACKSON-509] @JsonSubTypes was not allowed for fields/methods/ctor-parameters (although
    @JsonTypeInfo was, starting with 1.7)
  * [JACKSON-510] Registered subtypes not used for @JsonTypeInfo used with properties

  Potential backwards compatibility issues (compared to 1.7.x):

  * [JACKSON-523]: Added method "idFromValueAndType()" in TypeIdResolver interface,
    which is needed to properly handle types such as InetAddress, TimeZone -- unfortunately
    this would break custom TypeIdResolver instances.
  * [JACKSON-551]: Addition of new methods to 'Serializers' and 'Deserializers' interfaces
    means that existing code (1.7 only) that directly implements interfaces will not compile
    (i.e. source and binary incompatible change)

  Issues handled by new external projects:

  * [JACKSON-532]: Add support for org.json.JSONObject, org.json.JSONArray;
    created "jackson-module-json-org" at [https://github.com/FasterXML/jackson-module-json-org]

1.7.8 [08-Jul-2011]

  Fixes:

  * [JACKSON-586] Problems with @JsonValue, method access (failed on
    non-public methods, or public method of non-public class)
   (reported by Pierre-Alexander M)
  * [JACKSON-587] TextNode.getValueAsLong() does not work properly
    (reported by Chris P)
  * [JACKSON-591] JodaDeserializers not throwing wrongTokenException
   (reported by Tom L)
  * [JACKSON-597] Make ClassDeserializer support primitive types
   (suggested by Bruce P)

1.7.7 [17-May-2011]

  Fixes:

  * [JACKSON-542] Base64 decoder couldn't handle escaped characters
    (reported by Luis N)
  * [JACKSON-543] Root-level static type information incorrectly handled
    with Maps (losing parameterization)
   (reported by Steven S)
  * [JACKSON-553] SerializationConfig.Feature.DEFAULT_VIEW_INCLUSION
    did not work correctly
   (reported by Xun W)
  * [JACKSON-554] ObjectMapper.readValue(JsonNode) was not properly passing
    itself as ObjectCodec, making secondary conversions fail
   (reported by Pascal G)
  * [JACKSON-556] @XmlElement.name property ignored in some cases
   (reported by Alex P)
  * [JACKSON-562] Smile property name decoding issue
   (reported by Jeffrey Damick, Shay Banon)
  * [JACKSON-563] JSON Schema uses "required" (not "optional")
   (reported by Oleg E)
  * [JACKSON-569] ContextualSerializer not resolved for serializers
    defined with @JsonSerialize annotation
    (reported by Gregor O)
  * [JACKSON-572] Problems serializing generic non-static inner classes
   (reported by Steven S)

1.7.6 [12-Apr-2011]

  Fixes:

  * [JACKSON-547] Problems relaying exceptions from creator methods
    (reported by Gili)
  * [JACKSON-550] Registration of serializers was not completely working
    with SimpleModule (interfaces implemented by superclasses skipped)
   (reported by Andrei P)
  * [JACKSON-552] SmileParser not handling long field names properly,
    failed with "this code path should never get executed" exception
   (reported by Shay B)

1.7.5 [01-Apr-2011]

  Fixes:

  * [JACKSON-530] Default SerializationInclusion value not properly
    passed when "USE_ANNOTATION" set to false
    (Suchema O)
  * [JACKSON-533] Failed to serialize LinkedHashMap.value()
    (reported by Linghu C)
  * [JACKSON-540] Side-effects with ObjectMapper.canSerialize(),
    canDeserialize()
    (reported by Maik J)
  * [JACKSON-541] Remove the need for @JsonCreator on multi-arg constructor
    iff all parameters have @JsonProperty
    (suggested by Pascal Glinas)
  * [JACKSON-545] UTF8Writer.flush() should check against NPE
    (reported by Michel G)

1.7.4 [04-Mar-2011]

  Fixes:

  * [JACKSON-484]: improve serialization of InetAddress
   (reported by Brian H)
  * [JACKSON-506]: problems with type handling for java.util.Date
    when using @JsonTypeInfo on field/method
   (reported by Kirill S)
  * [JACKSON-504]: FilterProvider registration directly via SerializationConfig
    was not working
   (reported by Kirill S)
  * [JACKSON-508]: Type information lost when serializing List<List<X>>
   (reported by Christopher B)
  * [JACKSON-518]: Problems with JAX-RS, type variables 
   (reported by   Kirill S)
  * [JACKSON-522]: java.util.TimeZone was not correctly handled
  * [JACKSON-525]: Problem with SmileGenerator, shared-names buffer recycling
   (reported by Shay B)

1.7.3 [14-Feb-2011]

  Fixes:

  * [JACKSON-483]: allow deserializing CharSequence (also: support
    conversion from byte[] to char[], assuming base64 encoding)
  * [JACKSON-492]: problem encoding 1 byte length "raw" UTF8 Strings
    (reported by David Y)

  (plus all fixes up to and including 1.6.6)

1.7.2 [02-Feb-2011]

  Fixes:

  * [JACKSON-476] ContextualDeserializer handling not completely working
   (reported by Sean P)
  * [JACKSON-481] OSGi headers must include 1.5 AND 1.6
   (reported by drozzy@gmail.com)

  (plus all fixes up to and including 1.6.5)

  Improvements:

  * [JACKSON-474] Add ability to pass externally allocated buffer
    for Utf8Generator, SmileGenerator
   (suggested by David Y)

1.7.1 [12-Jan-2010]

  Fixes:
  
  * [JACKSON-456]: Type check issues with Jackson JAX-RS provider
   (reported by Kirill S)
  * [JACKSON-457]: Typo in Module method "getSeserializationConfig" ("bananana error"); renamed
    as "getSerializationConfig" (version with old spelling retained as deprecated for compatibility)
   (reported by Chris W)
  * [JACKSON-458]: Problems with ObjectMapper.convertValue(), TokenBuffer, SerializedString
   (reported by Larry Y)
  * [JACKSON-462]: Buffer overflow in Utf8Generator#writeFieldName(String)
   (reported by Coda H)

1.7.0 [06-Jan-2010]

  Fixes:

  * [JACKSON-356]: Type information not written for nested-generics root types
    (reported by Alex R on mailing list)
  * [JACKSON-450] JAXB annotations chosen incorrectly from interface method
    (instead of method definition in class), when serializing
    (reported by Sean P)

  Improvements:

  * [JACKSON-280]: Allow use of @JsonTypeInfo for properties (fields, methods)
  * [JACKSON-345]: Make BeanSerializer use SerializedString for even faster serialization
  * [JACKSON-393]: Allow deserializing UUIDs from VALUE_EMBEDDED_OBJECT
  * [JACKSON-399]: JAX-RS is not passing generic type information as root type
    (reported by Kirill S) 
  * [JACKSON-409] Add SmileGenerator.writeRaw(byte)
  * [JACKSON-414] Add 'JsonNode.getValueAsBoolean()' (and 'JsonParser.getValueAsBoolean()')
   (suggested by Tauren M)
  * [JACKSON-419]: Add explicit support for handling 'java.util.Locale'
    (suggested by Brian R)
  * [JACKSON-432]: Add 'ObjectMapper.enableDefaultTypingAsProperty()' to allow
    specifying inclusion type 'As.PROPERTY' and property name to use
    (suggested by Peter L)
  * [JACKSON-434]: Add 'JsonGenerator.writeString(SerializableString)'
  * [JACKSON-438]: Wrap exceptions thrown by Creator methods as JsonMappingException
    (suggested by Tim W)

  New features:

  * [JACKSON-163] Add 'SerializationConfig.Feature.WRAP_ROOT_VALUE' which
    allows wrapping of output within single-property JSON Object.
  * [JACKSON-297] Add simple Module abstraction to allow pluggable support
    tor third-party libraries, data types
  * [JACKSON-312] Add ability to dynamically filter out serialized properties
  * [JACKSON-351]: Add @JsonRawValue for injecting literal textual
    value into JSON
   (contributed by Ga�l Marziou)
  * [JACKSON-369]: Allow registering custom Collection and Map deserializers
   (implemented via 'org.codehaus.jackson.map.Deserializers')
  * [JACKSON-385]: Support contextual serializers, deserializers; works by
    implementing 'org.codehaus.jackson.map.ser.ContextualSerializer' or
    'org.codehaus.jackson.map.deser.ContextualDeserializer'
  * [JACKSON-401] Add features 'SerializationConfig.FLUSH_AFTER_WRITE_VALUE'
    and 'JsonGenerator.FLUSH_PASSED_TO_STREAM' to allow blocking of flush()
    calls to underlying output stream or writer
  * [JACKSON-405]: Add command-line tool for manual Smile encoding/decoding
  * [JACKSON-407]: Add features (SerializationConfig.Feature.WRAP_EXCEPTIONS,
    DeserializationConfig.Feature.WRAP_EXCEPTIONS) to disable exception wrapping
  * [JACKSON-412] Add 'DeserializationConfig.Feature.FAIL_ON_NUMBERS_FOR_ENUMS'
    to optionally prevent mapping JSON integers into Java Enum values
   (suggested by Patrick L)
  * [JACKSON-420] Add 'DeserializationConfig.Feature.FAIL_ON_NULL_FOR_PRIMITIVES'
    to optionally prevent JSON null from mapping to default value
   (suggested by Thomas D)
  * [JACKSON-421] Add ability to register multiple sets of serializers
    without extending SerializerFactory (related to [JACKSON-297])
  * [JACKSON-429] Add @JsonIgnoreType to allow ignoring any and all properties
    of specified type; useful to exclude well-known proxy/facade/handler types
  * [JACKSON-440] Add ability to process serializers, deserializers during their
    construction (to allow adding, removing, modifying properties to handle)
  * [JACKSON-448] Add 'JsonGenerator.writeString()' alternatives that accept
    pre-encoded UTF-8 byte sequences (writeUTF8String() and writeRawUTF8String())
   (requested by Shay B)

  Issues handled by new external projects:

  * [JACKSON-317] Add support for Guava (ex-Google-collections); implemented
    as a new module, see: https://github.com/FasterXML/jackson-module-guava
  * [JACKSON-394] Add support for using data binding to/from XML (Stax) sources;
    sort of "mini-JAXB".

  Potential backwards compatibility issues (compared to 1.6.x):

  * [JACKSON-419] (see above) 'java.util.Locale' now serialized as JSON String
    (using Locale.toString()), instead of as bean-like JSON Object
  * Added 'BeanProperty' argument for many methods in SerializerFactory /
    DeserializerFactory, SerializerProvider / DeserializerProvider implementations.
  * Related to [JACKSON-407], will wrap some previously unwrapped exceptions from
    deserializer (to have symmetric handling; serializer already wrapped); new
    features to allow disabling wrapping on serialization and/or deserialization.

1.6.5 [01-Feb-2011]

  Fixes:

  * [JACKSON-454] JSON Schema generator was adding bogus "items" property
    for JSON object types (only allowed for arrays)
  * [JACKSON-461] ArrayIndexOutOfBoundsException when property is subclass of
    Map with fewer type parameters
   (reported by Tim W)
  * [JACKSON-465] Deserialization with @JsonCreator that takes in a Map fails
   (reported by Tim W)
  * [JACKSON-468] Method-bound type variables (public <T> T getValue()) not handled
    (reported by Christian N)
  * [JACKSON-470] ArrayIndexOutOfBoundsException if @JsonCreator constructor
    has @JsonParameter parameters with same name
   (reported by Tim W)
  * [JACKSON-472] Custom bean deserializers are not cached when using
    JAXB annotation introspector
   (reported by Seam P)
  * [JACKSON-473] JsonMapping$Reference not Serializable
    (reported by Steven S)
  * [JACKSON-478] Improve support for 'java.sql.Timestamp' type by allowing
    deserializing textual representations
    (reported by John L)

1.6.4 [21-Dec-2010]

  Fixes:

  * [JACKSON-364] @JsonTypeInfo not included properly for Collection types
    when using JsonView functionality
  * [JACKSON-428] Type information, Map key deserializer definitions don't
    work together
    (reported by Patrick R)
  * [JACKSON-431] Deserialization fails with JSON array with beans with
    @JsonCreator, unmapped properties before and after creator properties
   (reported by Hannu L)
  * [JACKSON-436] @XmlElementType not working correctly with Collection type
    properties
   (reported by Sean P)

1.6.3 [04-Dec-2010]

  Fixes:

  * [JACKSON-228], [JACKSON-411] XmlJavaTypeAdapter, package-level annotations not
    working
   (reported by Claudio R, Raymond F)
  * [JACKSON-387]: Deserialization fails for certain objects serialized with
    enableDefaultTyping
   (reported by Peter L)
  * [JACKSON-415] XMLElement annotation ignored during schema generation
    (reported by Sean P)
  * [JACKSON-416] XmlElement.type() doesn't override type during serialization
    (reported by Sean P)
  * [JACKSON-417] Deserialization of "native" types (String, Integer, Boolean)
    failed with abstract types
   (reported by Joe J)
  * [JACKSON-423] Incorrect serialization of BigDecimal, BigInteger,
    when using TokenBuffer
   (reported by Sean P)
  * [JACKSON-424] ArrayIndexOutOfBounds with SmileGenerator, long Unicode
    Strings
   (reported by Shay B)

1.6.2 [02-Nov-2010]

  Fixes:

  * [JACKSON-288] Problems with JAXB annotation handling for combination of
   @XmlJavaTypeAdapter, @XmlElement
    (reported by Kent R)
  * [JACKSON-366] Type metadata not written for empty beans
   (reported by Patrick R)
  * [JACKSON-388] Deserialization of Throwable fails with Inclusion.NON_NULL
   (reported by Kirill S)
  * [JACKSON-391] ObjectReader.withValueUpdate() passing wrong object
   (reported by Kurtis)
  * [JACKSON-392] Beans with only @JsonAnyGetter fail on serialization
   (reported by Kirill S)
  * [JACKSON-395]: JsonParser.getCurrentName() not working with
    JsonParser.nextValue() for nested JSON Arrays, Objects
  * [JACKSON-397] Reverted most of [JACKSON-371] from 1.6 branch, since it caused
    externally visible change in exception handling; behavior now back to 1.6.0
    (will change to catch and rethrow in 1.7.0)
   (reported by Jon Berg)
  * [JACKSON-398]: Root type information not correctly passed by
    ObjectWriter when using JsonGenerator
    (reported by Kirill S)
  * [JACKSON-403]: XMLGregorianCalendar could not be deserialized from timestamp
    (reported by Manual F)
  * [JACKSON-404] Problem with XmlAdapter, generic types, deserialization
    (reported by Davide)

1.6.1 [06-Oct-2010]

  Fixes:

  * [JACKSON-359] TypeIdResolver.init() was not being called properly
    (reported by Peter L)
  * [JACKSON-372] handle missing primitive type values for @JsonCreator gracefully (with defaults)
  * [JACKSON-376] writing binary data as object field value with Smile failed
    (reported by Shay B)
  * [JACKSON-371] Provide path of type error in ObjectMapper.convertValue()
    (reported by Larry Y)
  * [JACKSON-383] @JsonAnySetter gets called for ignorable properties if
    FAIL_ON_UNKNOWN_PROPERTIES set to false (related to [JACKSON-313])
    (reported by Kirill S)
  * [JACKSON-384] @JsonAnyGetter values were duplicated if method name was valid as a regular
    getter name
    (reported by Bruce R)
  * all fixes from 1.5.x up to 1.5.7

  Improvements:

   * [JACKSON-360] Convert empty String to null values for Joda
     (suggested by Shilpa P)
   * [JACKSON-386] Improve registration for optional/external types (javax.xml, joda)

1.6.0 [06-Sep-2010]

  Fixes:

  * [JACKSON-265] Problems with generic wildcard type, type info
   (reported by Fabrice D)
  * [JACKSON-268] Property ordering for JAXB did not work with "raw" property
    names (but just with renamed names like with Jackson annotations)
   (reported by Valentin B)
  * [JACKSON-303] JAXB annotation @XmlAccessorType(XmlAccessType.NONE) seems
    to not work correctly during deserialisation process
    (reported by David M)
  * [JACKSON-313] Ignorable properties should not be passed to any-setter
  * [JACKSON-336] Generics handling: Map type not handled if intermediate types
    with just one generic parameter

  Improvements:

  * [JACKSON-193] @JsonCreator-annotated factory methods and @JsonValue annotated
    output methods now work with enums, allowing more customizable enum ser/deser.
    (requested by Paul B)
  * [JACKSON-253] Support combination of @XmlAnyElement + @XmlElementRefs
  * [JACKSON-261] @JsonView now implies that associated element (field,
    getter/setter) is to be considered a property; similar to how
    @JsonSerialize/@JsonDeserialize/@JsonProperty are used.
  * [JACKSON-274] Un-deprecated @JsonGetter and @JsonSetter.
  * [JACKSON-283] JDK atomic types (java.util.concurrent.atomic) supported
  * [JACKSON-289] Added "SerializationConfig.Feature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS"
    to allow serializing char[]s as JSON Arrays with single-char-String values
    (also fixed issues with deserializing the same on deserializer side)
    (requested by Brian O)
  * [JACKSON-290] @JsonWriteNullProperties can be used with fields too;
    annotation itself is now deprecated (use JsonSerialize#include instead).
  * [JACKSON-301] Allow JsonMappingException to return name of "bad" (unrecognized)
    field
    (requested by Rob O)
  * [JACKSON-302] Add JsonNode.has(String/int) to allow for more convenient checking
    of whether JSON Object/Array nodes have specified value.
  * [JACKSON-308] Configurable date formatting support for XMLGregorianCalendar:
    XMLGregorianCalendar now uses same Date/Calendar serialization as other date types.
    (suggested by Igor K)
  * [JACKSON-321] Allow passing JsonNodeFactory to use for ObjectMapper, ObjectReader,
    to allow use of custom JsonNode types.
  * [JACKSON-326] Add 'JsonParser.hasTextCharacters()' to make it easier to optimize
    text access (esp. when copying events)
  * [JACKSON-328] Precedence of "getters-as-setters" (for Maps, Collections) was
    accidentally higher than that of property fields (public, @JsonProperty)
    (reported by Thomas D)
  * [JACKSON-333] Add JsonNode.getValueAsInt()/.getValueAsDouble() for more convenient
     coercion; including parsing of JSON text values to numbers if necessary
  * [JACKSON-339] Support Joda ReadableDateTime, ReadableInstant out of the box
  * [JACKSON-349] Accept empty String as number (null for wrappers, 0 for primitives)

  New features:

  * [JACKSON-41] Add code generation to allow deserialization into arbitrary Bean interfaces.     
  * [JACKSON-210] Add method(s) in JsonNode for finding values of named property
  * [JACKSON-212] Allow serializer/deserializing Enums using toString() method
    instead name()
  * [JACKSON-235] Handle bi-directional (parent/child, double-linked lists) references
  * [JACKSON-257] Add ability to register sub-types for Polymetric Type Handling
  * [JACKSON-264] Ability to "update" values; to read and bind JSON
    content as properties of existing beans. This is done by using
    "ObjectMapper.updatingReader()" (and "reader.readValue(source)")
  * [JACKSON-267] Allow unquoted field names to start with '@' in
    (when unquoted name support is enabled, to support polymorphic
    typing (which defaults to property names like "@class").
   (requested by Michel G)
  * [JACKSON-278] Allow access to version information (via new Versioned interface)
   (requested by Andrei V)
  * [JACKSON-282] Added SerializationConfig.Feature.CLOSE_CLOSEABLE
    which when enabled forced a call to value.close() right after
    serialization of a (root-level) value.
  * [JACKSON-287] Add JsonParser.releaseBufferedContent() which can be called
    to "push back" content read but not (yet) consumed by JsonParser
  * [JACKSON-292] Add "any-getter" (using @JsonAnyGetter) to complement @JsonAnySetter,
    more convenient mapping of miscellaneous extra properties.
  * [JACKSON-295] Add 'jackson-all' jar
    (suggested by Ant E)
  * [JACKSON-299] Added 'org.codehaus.jackson.impl.MinimalPrettyPrinter'
    to make it easier to add simple output customizations
    (suggested by David P)
  * [JACKSON-300] Add 'JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER
    to allow non-standard character escapes like \'.
    (requested by Ketan G)
  * [JACKSON-314] (go Pi, go!) Add 'SerializationConfig.Feature.WRITE_NULL_MAP_VALUES'
    to suppress writing of Map entries with null values.
  * [JACKSON-316] Allow per-call enable/disable of pretty printing (added
    methods in ObjectWriter; .withPrettyPrinter())
  * [JACKSON-325] Add new Jackson "internal" annotation (@JacksonStdCodec?) to allow
    marking default/standard serializers, deserializers
  * [JACKSON-337] Add "ObjectMapper.valueToTree()"
  
  Backwards incompatible changes

  * [JACKSON-328] (see above) fixes precedence of "getter-as-setter" (for Maps, Collections)
    to be LOWER than that of fields; this is the original intended behavior. However,
    versions 1.1 - 1.5 accidentally had fields at lower precedence. This fix can
    change behavior of code.
  * [JACKSON-308] (see above) Configurable date formatting support for XMLGregorianCalendar:
    since default Date/Calendar formatting uses timestamp instead of textual serialization,
    default XMLGregorianCalendar serialization is changing.

1.5.7 [03-Oct-2010]

  Fixes:

  * [JACKSON-352] Polymorphic deserialization for Object always assumes
    array-wrapper style
   (reported by Henry L)
  * [JACKSON-355] Handling of BigInteger with JsonNode not correct
   (reported by Adam S)
  * [JACKSON-363] CustomDeserializerFactory did not work for custom
    array deserializers.
   (reported by Lubomir K)
  * [JACKSON-370] TreeTraversingParser.skipChildren() not working correctly
   (reported by Dmitry L)
  * [JACKSON-373] Interface inheritance not traversed when looking up
    custom serializers
   (reported by Lubomir K)
  * [JACKSON-377] ThrowableDeserializer was not properly using information from
    @JsonCreator or @JsonAnySetter
   (reported by Kirill S)
  * [JACKSON-380] Incorrect type information serialized for some Enums
  
1.5.6 [17-Aug-2010]

  Fixes:

  * [JACKSON-329] type information was not properly serialized for
    Iterator or Iterable serializers
   (reported by Yuanchen Z)
  * [JACKSON-330] ObjectMapper.convertValue(): base64 conversions
    do not work as expected
  * [JACKSON-334] Support ISO-8601 date without milliseconds
  * [JACKSON-340] Meta annotations missing for @JsonTypeResolver
   (reported by Yuanchen Z)
  * [JACKSON-341] Issue with static typing, array and subtyping
    (reported by Yuanchen Z)

1.5.5 [25-Jul-2010]

  Fixes:

  * [JACKSON-309] Serialization of null properties not working correctly
    when using JAXB annotation introspector
  * [JACKSON-318] Deserializer missing support for java.util.Currency
    (reported by Geoffrey A)
  * [JACKSON-319] Issues when trying to deserialize polymorphic type
    with no data (just type information)
    (reported by Chris C)
  * [JACKSON-324] JsonParserBase: call releaseBuffers() in finally
    block (within close())
    (suggested by Steve C)
  * [JACKSON-327] CustomSerializerFactory had a bug in handling of
    interface registrations
    (reported by Yuanchen Z)

  (and all fixes from 1.4.x branch up to 1.4.5)

1.5.4 [25-Jun-2010]

  Fixes:

  * [JACKSON-296]: Add support for JAXB/@XmlElementRef(s), fix related
    issues uncovered (wrt. handling of polymorphic collection fields)
   (reported by Ryan H)
  * [JACKSON-311]: Problems handling polymorphic type information for
    'untyped' (Object) bean properties, default typing
   (reported by Eric S)

1.5.3 [31-May-2010]

  Fixes:

  * [JACKSON-285]: Problem with @JsonCreator annotated constructor that
    also uses @JsonDeserialize annotations

  Improvements:

  * [JACKSON-284]: Reduce scope of sync block in
    SerializerCache.getReadOnlyLookupMap()
  * Partial fix for [JACKSON-289]: allow JSON Array with single-character
    Strings to be bound to char[] during deserialization
   (suggested by Brian O)

1.5.2 [25-Apr-2010]

  Fixes:

  * [JACKSON-273] Yet another OSGi issue, "org.codehaus.jackson.map.util"
    not exported by mapper module, needed by jax-rs module.
   (reported by Lukasz D)
  * [JACKSON-281] JsonGenerator.writeObject() only supports subset of
    wrapper types (when not specifying ObjectCodec)
   (reported by Aron A)

  (and all fixes from 1.4.x branch up to 1.4.4)

1.5.1 [09-Apr-2010]

  Fixes:

  * [JACKSON-265]: problems with generic type handling for serialization
    (reported by Fabrice D)
  * [JACKSON-269]: missing OSGi export by mapper (o.c.j.m.jsontype.impl),
    needed by jackson-xc module
    (reported by Raymond F)

  (and all fixes from 1.4.x branch up to 1.4.3)


1.5.0 [14-Mar-2010]

  Fixes:

  * [JACKSON-246] JAXB property name determination not working correctly.
    (reported by Lars C)

  Improvements:

  * [JACKSON-160] Factory Creator methods now handle polymorphic
    construction correctly, allowing manual polymorphic deserialization
  * [JACKSON-218] Extended support for Joda date/time types like
    LocalDate, LocalDateTime and DateMidnight
  * [JACKSON-220] @JsonSerialize.using() was not working properly for
    non-Bean types (Collections, Maps, wrappers)
  * [JACKSON-236] Allow deserialization of timestamps-as-Strings (not
    just timestamps as JSON integer numbers).
   (requested by Chris C)
  * [JACKSON-255] Allow setter override even with incompatible type
    (as long as only one setter per class, so there is no ambiguity)
  * [JACKSON-256] AnnotationIntrospector.findSerializationInclusion
    was not combining values correctly for JAXB annotations.
   (reported by John L)

  New features:

  * [JACKSON-91] Polymorphic Type Handling: automatic handling of
    polymorphic types, based on annotations (@JsonTypeInfo) and/or
    global settings (ObjectMapper.enableDefaultTyping()) 
  * [JACKSON-175] Add "org.codehaus.jackson.util.TokenBuffer", used for
    much more efficient type conversions (and other internal buffering)
  * [JACKSON-195] Add methods to ObjectMapper to allow specification of
    root object serialization type.
  * [JACKSON-221] Add 'ObjectMapper.writeValueAsBytes()' convenience
    method to simplify a common usage pattern
  * [JACKSON-229] TypeFactory should have methods to construct parametric
     types programmatically (TypeFactory.parametricType())
  * [JACKSON-232] Add 'SerializationConfig.Feature.DEFAULT_VIEW_INCLUSION'
    to disable inclusion of non-annotated properties with explicit views
    (suggested by Andrei V)
  * [JACKSON-234] Add support for JSONP, by adding JSONPObject wrapper
    that serializes as expected.
  * [JACKSON-241] Add a mechanism for adding new "untouchable" types for
    JAX-RS JSON provider, to allow excluding types from being handled
    (added method "JacksonJsonProvider.addUntouchable()")
  * [JACKSON-244] Allow specifying specific minimum visibility levels for
    auto-detecting getters, setters, fields and creators
    (requested by Pierre-Yves R)
  * [JACKSON-245] Add configuration setting in JAX-RS provider to allow
    automatic JSONP wrapping (provider.setJSONPFunctionName())
  * [JACKSON-259] Add JsonParser.Feature to allow disabling field name
    canonicalization (JsonParser.Feature.CANONICALIZE_FIELD_NAMES)

  Backwards incompatible changes:

  * Moved following serializers out of BasicSerializerFactory
    JdkSerializers: ClassSerializer (into JdkSerializers),
    NullSerializer (separate class)
  * Add one parameter to StdDeserializer.handleUnknownProperty:
    addition was required for handling polymorphic cases that
    can use nested JsonParser instances.
  * Fixed issues in generic type handling (was not resolving all named
    types completely)
  * Annotation changes:
     * Moved "NoClass" into "org.codehaus.jackson.map.annotate" package
     * Removed @JsonUseSerializer and @JsonUseDeserializer annotations
       (which has been deprecated for 1.1; replaced by
       @JsonSerialize.using and @JsonDeserialize.using, respectively)
     * @JsonGetter and @JsonSetter are marked as deprecated, since
       @JsonProperty can (and should) be used instead.

1.4.4 [25-Apr-2010]

  Fixes:

  * [JACKSON-263] BooleanNode.asToken() incorrectly returns 'true' token
    for all nodes (not just 'false' ones)
   (reported by Gennadiy S)
  * [JACKSON-266] Deserialization issues when binding data from JsonNode
   (reported by Martin T)

1.4.3 [18-Feb-2010]

  Fixes:

 * [JACKSON-237]: NPE in deserialization due to race condition
   (reported by Benjamin D)


1.4.2 [31-Jan-2010]

  Fixes:

  * [JACKSON-238]: Fix to ensure custom serializers can override
    default serializers (like DOM, Joda serializers)
   (reported by Pablo L)
  * other fixes from 1.3.4 release

1.4.1 [10-Jan-2010]

  Fixes:

   fixes from 1.3.x branch up to 1.3.3.

1.4.0 [19-Dec-2009]

  Improvements:

  * [JACKSON-38] Allow serializing/deserializing DOM trees (Node, Document)
    (suggested by Scott D)
  * [JACKSON-89] Make ignored field/creator-backed properties quietly
    skippable during deserialization (that is, without having to explicitly
    declare such properties as ignorable as per [JACKSON-77])
  * [JACKSON-161] Added basic support for Joda, ser/deser DateTime class
  * [JACKSON-170] Serialize Creator properties before other properties
  * [JACKSON-196] Schema generation does not respect the annotation
    configured serializer on a bean property
   (reported by Gil M)
  * [JACKSON-208] Add feature (JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS)
    to allow unquoted control characters (esp. tabs) in Strings and
    field names
   (requested by Mark S)
  * [JACKSON-216] Jackson JAXB annotation handler does not use @XmlElement.type
    property for figuring out actual type
   (reported by Mike R)

  New features:

  * [JACKSON-77] Add class annotation @JsonIgnoreProperties to allow
    for ignoring specific set of properties for serialization/deserialization
  * [JACKSON-90] Added @JsonPropertyOrder, which allows for specifying
    order in which properties are serialized.
  * [JACKSON-138] Implement JsonView; ability to suppress subsets of
    properties, based on view definition. Views are defined using @JsonView
    annotation.
  * [JACKSON-191] Add access to basic statistics on number of cached
    serializers, deserializers (and methods to flush these caches)
  * [JACKSON-192] Added basic delegate implementations (JsonParserDelegate,
    JsonGeneratorDelegate) to make it easier to override core parser and
    generate behavior
  * [JACKSON-201] Allow serialization of "empty beans" (classes without
    getters), if SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS is
    disabled; or if class has recognized Jackson annotation
   (suggested by Mike P)

  Other:

  * Removed "BasicSerializerFactory.StringLikeSerializer" that was
    deprecated for 1.0, replaced by public "ToStringSerializer"

1.3.4 [31-Jan-2010]

  Fixes:

  * [JACKSON-225], [JACKSON-227], missing null checks/conversions when
    adding entries to ArrayNode and ObjectNode
   (reported by Kenny M)
  * [JACKSON-230]: wrong NumberType reported for big ints, longs
   (reported by Henning S)
  * [JACKSON-231]: ArrayDeserializer for byte[] should be able to
    use VALUE_EMBEDDED_OBJECT (if Object is byte[])

1.3.3 [21-Dec-2009]

  Fixes:

  * [JACKSON-214] Enum types with sub-classes failed to serialize
    (reported by Elliot S)
  * [JACKSON-215] Add JAX-RS provider annotations on JacksonJaxbJsonProvider
    (suggested by Matthew R)
  * [JACKSON-220] JsonSerialize.using() not recognized for Collection and
    Map types (and similarly for JsonDeserialize)

1.3.2 [02-Dec-2009]

  Fixes:

  * [JACKSON-103] (additional work) Groovy setMetaClass() setter caused
    problems when deserializing (although serialization was fixed earlier)
   (reported by Stephen F)
  * [JACKSON-187] Issues with GAE security model, Class.getEnclosingMethod()
  * [JACKSON-188] Jackson not working on Google App Engine (GAE) due to
    unintended dependency from JacksonJsonProvider to JAXB API classes
   (reported by Jeff S)
  * [JACKSON-206] Support parsing dates of form "1984-11-13T00:00:00"

1.3.1 [23-Nov-2009]

  Fixes:

  * [JACKSON-190] Problems deserializing certain nested generic types
   (reported by Nathan C)
  * [JACKSON-194] ObjectMapper class loading issues on Android
   (reported by Martin L)
  * [JACKSON-197] Remove 2 debug messages that print out to System.err
   (reported by Edward T)
  * [JACKSON-200] java.sql.Date deserialization not working well
   (reported by Steve L)
  * [JACKSON-202] Non-public fields not deserialized properly with
    JAXB annotations
   (reported by Mike P)
  * [JACKSON-203] Date deserializers should map empty String to null
   (reported by Steve L)

1.3.0 [30-Oct-2009]

  Fixes:

  * [JACKSON-150] Some JAXB-required core types (XMLGregorianCalendar,
    Duration, QName, DataHandler) were not completely supported
  * [JACKSON-155] Failed to serialize java.io.File (with infinite
    recursion)
   (reported by Gabe S)
  * [JACKSON-167] Map and Collection sub-classes seem to lose generic
    information for deserialization
  * [JACKSON-177] Problems with Hibernate, repackaged cglib
    (reported by Ted B)
  * [JACKSON-179] Single-long-arg factory Creators were not working
   (reported by Brian M)
  * [JACKSON-183] Root-level 'JsonDeserialize' annotation was not handled
    completely; 'as' setting was not taking effect
   (reported by Nick P)

  Improvements:

  * [JACKSON-152] Add "ObjectMapper.writeValueAsString()" convenience
    method to simplify serializing JSON into String.
  * [JACKSON-153] Allow use of @JsonCreator with Map types too
  * [JACKSON-158] Bean serializer now checks for direct self-references
    (partial, trivial cycle detection)
  * [JACKSON-164] Improve null handling for JsonGenerator.writeStringValue
   (suggested by Benjamin Darfler)
  * [JACKSON-165] Add JsonParser.getBooleanValue() convenience method
    (suggested by Benjamin Darfler)
  * [JACKSON-166] Add ability to control auto-detection of
    "is getters" (boolean isXxx()) methods separate from regular getters
  * [JACKSON-168] Make JsonLocation serializable (and deserializable)
   (suggested by Shay B)
  * [JACKSON-182] Improved handling of SerializationConfig.AUTO_DETECT_GETTERS
    with JAXB annotations (uses Jackson-specified default, not JAXB defaults)

  New features:

  * [JACKSON-129] Allow constructing JsonParser to read from JsonNode
    (tree representation)
  * [JACKSON-154] Added JsonDeserialize.keyUsing and .contentUsing,
    to allow for overriding key and content/value deserializers for
    properties of structured (array, Collection, Map) types
  * [JACKSON-159] Added 'org.codehaus.jackson.jaxrs.JacksonJaxbJsonProvider'
    to improve use of Jackson as JSON converter for JAX-RS services.
  * [JACKSON-173] Add "JsonParser.Feature.ALLOW_SINGLE_QUOTES" to
    handle some more invalid JSON content
   (requested by Brian M)
  * [JACKSON-174] Add "ObjectMapper.convertValue()" convenience method
    for simple Object-to-Object conversions, using Jackson's data binding
    functionality
  * [JACKSON-176] Added 'JsonGenerator.Feature.WRITE_NUMBER_AS_STRINGS'
    as a work-around for Javascript problems with big longs (due to
    always representing numbers as 64-bit doubles internally)
    (requested by Doug D)
  * [JACKSON-180] Added 'JsonParser.Feature.INTERN_FIELD_NAMES' to allow
    disabling field name intern()ing.
   (suggested by Jeff Y)
  * [JACKSON-181] Added convenience methods in TypeFactory to allow
    dynamically constructed fully typed structured types (map, collection
    array types), similar to using TypeReference but without inner classes
  * Added method in AnnotationIntrospector to find declared namespace
    for JAXB annotations, needed for XML compatibility (future features)

  Other:

  * Removed obsolete class 'org.codehaus.jackson.map.type.TypeReference'
    (obsoleted by 'org.codehaus.jackson.type.TypeReference) -- was supposed
    to have been removed by 1.0 but had not been.
  * Added support to handle 'java.util.regex.Pattern'

1.2.1 [03-Oct-2009]

  Problems fixed:

  * [JACKSON-162] OSGi packaging problems for xc package.
   (reported by Troy Waldrep)
  * [JACKSON-171] Self-referential types cause infinite recursion when
    using only JAXB annotation introspector
    (reported by Randy L)

1.2.0 [02-Aug-2009]

  Improvements:

  * Added "-use" flag for generating javadocs
   (suggested by Dain S)
  * [JACKSON-136] JsonParser and JsonGenerator should implement
    java.io.Closeable (since they already have close() method)
   (suggested by Dain S)
  * [JACKSON-148] Changed configuration methods to allow chaining,
    by returning 'this' (instead of 'void')

  New features:

  * [JACKSON-33] Allow use of "non-default constructors" and
    multiple-argument factory methods for constructing beans to
    deserialize
  * [JACKSON-69] Support parsing non-standard JSON where Object keys are not quoted
  * [JACKSON-76] Mix-in annotations: allow dynamic attachment of
    annotations to existing classes, for purposes of configuring
    serialization/deserialization behavior
  * [JACKSON-92] Allow use of @JsonCreator for constructors and
    static methods that take a single deserializable type as argument
    (so-called delegating creators)
  * [JACKSON-114] Add feature and annotations to make serialization use
    static (declared) type over concrete (actual/runtime) type
  * [JACKSON-131] Allow constructing and passing of non-shared
    SerializationConfig/DeserializationConfig instances to ObjectMapper
  * [JACKSON-135] Add basic JsonNode construction support in ObjectMapper
  * [JACKSON-147] Add global deserialization feature for suppressing error
    reporting for unknown properties
  * [JACKSON-149] Add ser/deser features
    (DeserializationConfig.Feature.USE_ANNOTATIONS,
    SerializationConfig.Feature.USE_ANNOTATIONS) to allow disabling
    use of annotations for serialization and/or deserialization config

1.1.2 [31-Jul-2009]

  Fixes:

  * [JACKSON-143] NPE on ArrayNode.equals() when comparing empty array
    node to non-empty array node
   (reported by Gregory G)
  * [JACKSON-144] Static "getter-like" methods mistaken for getters (for
    serialization)
   (reported by Dan S)

1.1.1 [18-Jul-2009]

  Fixes:

  * [JACKSON-139] Non-numeric double values (NaN, Infinity) are serialized
    as invalid JSON tokens
    (reported by Peter H)
  * Core jar incorrectly included much of "mapper" classes (in addition
    to core classes)
  * Now compiles again using JDK 1.5 javac (1.1.0 didn't)

1.1.0 [22-Jun-2009]

  Fixes:

  * [JACKSON-109] Allow deserializing into generics Bean classes
    (like Wrapper<Bean>) not just generic Maps and Collections 
  * [JACKSON-121] Problems deserializing Date values of some ISO-8601
    variants (like one using 'Z' to indicate GMT timezone)
  * [JACKSON-122] Annotated serializers and deserializers had to
    be public classes with public default constructor; not any more.

  Improvements:

  * [JACKSON-111] Added "jackson-xc" jar to contains XML Compatibility
    extensions.

  New features:

  * [JACKSON-70] Add support for generating JSON Schema
  * [JACKSON-98] Allow serializing/deserializing field-accessible properties,
    in addition to method-accessible ones.
  * [JACKSON-105] Allow suppressing output of "default values"; which
    means value of a property when bean is constructed using the default
    no-arg constructor
   (requested by Christoph S)
  * [JACKSON-119] Add (optional) support for using JAXB annotations
    (by using JaxbAnnotationIntrospector)
   (requested by Ryan H)
  * [JACKSON-120] Add annotations @JsonSerialize, @JsonDeserialize,
    to streamline annotation by replacing host of existing annotations.
  * [JACKSON-123] Add "chaining" AnnotationIntrospector (implemented
    as inner class, AnnotationIntrospector.Pair) that allows combining
    functionality of 2 introspectors.

1.0.1 [04-Jun-2009]

  Fixes:

  * [JACKSON-104] Build fails on JDK 1.5, assorted other minor issues
   (reported by Oleksander A)
  * [JACKSON-121] Problems deserializing Date values of some ISO-8601
    variants (like one using 'Z' to indicate GMT timezone)

1.0.0 [09-May-2009]

  Fixes:

  * [JACKSON-103] Serializing Groovy objects; need to exclude getter method
    "getMetaClass" from serialization to prevent infinite recursion
   (reported by Ray T)

  Improvements:

  * Removed JAX-RS META-INF/services - based auto-registration for
    JAX-RS MessageBodyReader/MessageBodyWriter, because it could
    conflict with other application/json content handlers.

0.9.9-6 [27-Apr-2009]

  Improvements:

  * Improved jax-rs provider integration with jersey; now properly
    auto-registers as handler for json media type(s), and allows
    for defining custom ObjectMapper to be injected.

0.9.9-5 [20-Apr-2009]

  New features:

  * [JACKSON-88]: Support for "Setter-less" collection (and Map) types

  Improvements:

  * [JACKSON-100]: Allow specifying that BigInteger should be used instead
    of Integer or Long for "generic" integral numeric types (Object, Number)
    (DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS)
  * [JACKSON-101]: Allow disabling of access modifier overrides
    (SerializationgConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS)
    to support more security-constrainted running environments.

0.9.9-4 [14-Apr-2009]

  Fixes:

  * [JACKSON-94] Added missing "JsonParser.readValueAsTree()" method.
  * JacksonJsonProvider was using strict equality comparison against
    JSON type; instead needs to use "isCompatible". There were other
    similar problems
    (reported by Stephen D)
  * [JACKSON-97] Generic types (with bound wildcards) caused problems
    when Class introspector could not figure out that a concrete method
    was overriding/implementing generic method; as well as having
    problems with synthetic bridge methods.

  Improvements:

  * [JACKSON-95] Added support for deserializing simple exceptions
    (Throwable and its sub-classes): anything with a String constructor
    (assumed to take "message") should work to some degree.
  * [JACKSON-99] IOExceptions should not be wrapped during object
    mapping.
    (reported by Eldar A)

  New features:

  * [JACKSON-85]: Make Date deserialization (more) configurable (add
    DeserializationConfig.setDateFormat())
  * [JACKSON-93]: Allow overriding the default ClassIntrospector.
  * [JACKSON-96]: Allow enabling pretty-printing with data binding,
    through SerializationConfig object.

0.9.9-3 [03-Apr-2009]

  Fixes:

  * [JACKSON-79]: Primitive value deserialization fragile wrt nulls
  * [JACKSON-81]: Data binding code could lead to unnecessary blocking
    because it tried to advance parser (and stream) after binding
    (reported by Eldar A)

  New features:

  * [JACKSON-61]: Allow suppressing writing of bean properties with null values
   (requested by Justin F)
  * [JACKSON-63]: Create CustomDeserializerFactory to allow for adding
    custom deserializers for non-structured/generic types.
  * [JACKSON-75]: Add "any setter" method; ability to catch otherwise
    unknown (unmapped) properties and call a method with name+value.
  * [JACKSON-80]: Add @JsonValue annotation, to specify that a Bean value
    is to be serialized as value returned by annotated method: can for
    example annotate "toString()" method.
  * [JACKSON-84]: Added JsonGenerator.writeRawValue methods to augment
    existing JsonGenerator.writeRaw() method
    (requested by Scott A)
  * [JACKSON-86]: Added JsonParser.isClosed() and JsonGenerator.isClosed()
    methods.
  * [JACKSON-87]: Added ability to customized Date/Calendar serialization,
    both by toggling between timestamp (number) and textual (ISO-8601),
    and by specifying alternate DateFormat to use.

0.9.9-2 [19-Mar-2009]:

  Fixes:

  * [JACKSON-75]: Didn't have Deserializer for Number.class.

  Improvements:

  * [JACKSON-68]: Add DeserializationProblemListener, and
    DeserializationConfig.addHandler to add instances to ObjectMapper.
  * [JACKSON-71]: Add support ser/deser of Class.class.
  * [JACKSON-72]: Allow specifying that BigDecimal should be used instead
    of Double for "generic" numeric types (Object, Number)
    (DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS)
  * [JACKSON-73]: Refactored ser/deser configuration settings into
    separate configuration classes.
  * [JACKSON-78]: Should be able to deserialize ints into Booleans (0 == false)

  New features:

  * [JACKSON-45]: Add convenience methods to help writing custom
    serializers
    (requested by Scott A)

0.9.9 [02-Mar-2009]:

  Fixes:

  * [JACKSON-59]: NPE with String[] serializer
    (reported by Kevin G)
  * [JACKSON-62]: NPE with JsonMappingException if source exception used
    null message.
    (reported by Justin F)
  * [JACKSON-64]: Handling of property name (with @JsonGetter, @JsonSetter)
    made bit more intuitive; uses bean naming convention if no explicit
    name given.

  Improvements:

  * [JACKSON-60]: Method annotations did not follow intuitive expectations
    of inheritability; now do.
  * [JACKSON-65]: Need to support typing using "java.lang.reflect.Type", to
    help integration with frameworks.
  * [JACKSON-66]: ObjectMapper now has "canSerialize" and "canDeserialize"
    methods to help frameworks figure out what is supported.

  New features:

  * [JACKSON-52]: Allow disabling name-based auto-detection of
    getter methods
    (requested by Justin F)
  * [JACKSON-58]: Allow defining custom global Enum serializer
    (to, for example, make Enums be serialized using Enum.toString(),
     or lower-case name or such)
  * [JACKSON-67]: Add JAX-RS provider based on Jackson that can handle
    JSON content type; initially as a separate jar.

  Other:

  * [JACKSON-22]: all contributors now have submitted contributor
    agreement, stored under 'DEV/agreements-received' in svn trunk.

0.9.8 [18-Feb-2009]:

  Fixes:

  * [JACKSON-49]: Incorrect bounds check for Float values resulted in
    exception when trying to serializer 0.0f.

  New features:

  * [JACKSON-32]: add annotations to configure serialization process
    (@JsonClass/@JsonContentClass/@JsonKeyClass; @JsonUseSerializer,
     @JsonUseDeserializer, @JsonIgnore)
  * [JACKSON-36]: add annotations to define property names that differ
    from bean naming convention (@JsonGetter/@JsonSetter)

  Improvements:

  * [JACKSON-47]: Change DeserializerProvider.findValueDeserializer to
    take "referrer" information. This is needed to be able to give
    contextual mappings where a given type may be deserialized differently
    (by different deserializer, and possibly to a different java class)
    depending on where the reference is from.
  * [JACKSON-48]: Integrate ObjectMapper with JsonGenerator, JsonParser;
    add MappingJsonFactory.
    (suggested by Scott A)
  * [JACKSON-50]: JsonNode.getElements() and .iterator() now work for
    ObjectNodes too, not just ArrayNodes. Also added convenience factory
    methods to allow constructing child nodes directly from container 
    nodes.
  * [JACKSON-53]: iBatis proxied value classes didn't work; fixed by
    prevent CGLib-generated "getCallbacks" from getting called.
    (reportd by Justin F)
  * [JACKSON-55]: Added support for reference-path-tracking in
    JsonMappingException, made serializers populate it: this to make
    it easier to trouble-shoot nested serialization problems
  * [JACKSON-56]: Added support for RFC-1123 date format, along with
    simpler "standard" format; and can add more as need be.

0.9.7 [04-Feb-2009]:

  Improvements:

  * [JACKSON-34]: Improved packaging by adding an intermediate directory
    in source tarball, to not mess up the current directory (and to indicate
    version number as well)
  * [JACKSON-37]: Make Jackson run on Android, by ensuring that there are
    no hard linkages to classes that Android SDK doesn't have (the only
    reference that was there, to XMLGregorianCalendar, was changed to
    soft linkage)
  * [JACKSON-42]: Add new JsonNode sub-class, BinaryNode, to represent
    base64 encoded binary content.

  New features:

  * [JACKSON-6]: Implement JsonParser.getBinaryValue() so that one can
    now also read Base64-encoded binary, not just write.
  * [JACKSON-40]: Add JsonParser.nextValue() for more convenient
    iteration.
  * [JACKSON-46]: Allow disabling quoting of field names by disabling
    feature 'JsonGenerator.feature.QUOTE_FIELD_NAMES'
   (requested by Scott Anderson)

0.9.6 [14-Jan-2009]:

  Bug fixes:

  * Serialization of some core types (boolean/java.lang.Boolean,
    long/java.lang.Long) was not working due to incorrectly mapped
    serializers.

  New features:

  * [JACKSON-31]: Complete rewrite of ObjectMapper's deserialization:
    now supports Beans, typed (generics-aware) Lists/Maps/arrays.

  Improvements:

  * [JACKSON-24]: Add efficient byte-array - based parser factory
    method to JsonFactory (has maybe 5% improvement over wrapping
    in ByteArrayInputStream).
  * [JACKSON-29]: Split classes in 2 jars: core that has parser and
    generator APIs and implementations; and mapper jar that has object
    and tree mapper code.
  * [JACKSON-30]: Renamed "JavaTypeMapper" as "ObjectMapper", and
    "JsonTypeMapper" as "TreeMapper"; new names should be more intuitive
    to indicate their purpose. Will leave simple implementations of
    old classes to allow for gradual migration of existing code.

0.9.5 [10-Dec-2008]:

  Bug fixes:

  * [JACKSON-25]: Problems with Maven pom for lgpl version
    (report by Ray R)
    note: backported to 0.9.4 Codehaus Maven repo

  Improvements:

  * [JACKSON-13]: JavaTypeMapper can now take JsonFactory argument, and
    thus is able to construct JsonParser/JsonGenerator instances as necessary
  * [JACKSON-17]: Handling of unknown types now configurable with
    JavaTypeMapper serialization (see JsonSerializerProvider for methods)
  * [JACKSON-20]: Handling of nulls (key, value) configurable with
    JavaTypeMapper serialization (see JsonSerializerProvider for methods)
  * [JACKSON-26]: Add convenience JsonGenerator.writeXxxField() methods
    to simplify json generation.

  New features:

  * [JACKSON-27]: Allow automatic closing of incomplete START_ARRAY and
    START_OBJECT events, when JsonGenerator.close() is called.

0.9.4 [26-Nov-2008]:

  Bug fixes:

  * [JACKSON-16]: JavaDocs regarding whether Jackson is to close underlying
    streams, readers and writers, were incorrect. Additionally added
    parser/generator features to allow specifying whether automatic closing
    is to be done by Jackson: feature is enabled by default, both for
    backwards compatibility, and because it seems like the right setting.
  * [JACKSON-18]: ArrayIndexOutOfBounds on IntNode, due to off-by-one
    problem with comparisons
   (reported by Michael D)
  * Fixed a problem with CR (\r) handling; was sometimes skipping
    characters (problematic if there's no indentation).
  * Multiple UTF-8 decoding fixes: was specifically not working for
    names.

  Improvements:

  * More complete JavaDoc comments for core public classes.
  * Internal cleanup of core parsing, to unify handling of Object and
    Array entries

0.8.0 - 0.9.3 [between 17-Oct-2007 and 05-Sep-2008]:

  Changes:

  * [JACKSON-5]: Symbol table construction was not thread-safe for
    utf-8 encoded content (new bug with 0.9.2, not present with earlier)
   (reported by Tudor B)
  * [JACKSON-8]: Serialization of BigDecimal broken with JavaTypeMapper
   (reported by Johannes L)
  * [JACKSON-9]: Add support for (non-standard) Json comments.
    (requested by Mike G)
  * [JACKSON-11]: Implement base64/binary methods for json generator.
  * [JACKSON-14]: Problems with generic collections, serializer
    method signatures (due to lack of covariance wrt collection types)
  * [JACKSON-15]: Add copy-through methods to JsonGenerator for
    pass-through copying of content (copyCurrentEvent, copyCurrentStructure)
  * [JACKSON-23]: Add OSGi manifest headers for jars (to run on OSGi container).
  * Added generic "feature" mechanism to parsers, writers; features are
    togglable (on/off) things with well-defined default values, implemented
    as Enums.

  * [JACKSON-1]: JsonNode now implements Iterable<JsonNode> so that
    it is possible use Java 5 foreach loop over array/object nodes.
   (suggested by Michael M)
  * [JACKSON-4] Added JsonParser.skipChildren() method.
  * UTF-16/32 handling was not completely correct, was erroneously
    skipping first 2/4 bytes in some cases (even when no BOM included).
    Also, related unit tests added/fixed.
  * JsonGenerator.useDefaultPrettyPrinter()/.setPrettyPrinter()
    allow for pretty printing (indentation).
   (thanks to Ziad M for suggestion, sample code)

  * Implicit conversions for numbers could sometimes lose accuracy,
    if floating-point number was first accessed as int/long, and then
    as a BigDecimal.
  * One Nasty NPE fixed from NameCanonicalizer (which was added in 0.9.2)

  * Java type mapper had a bug in Collection mapping (mismatched
    calls between writeStartArray and writeEndObject!)
   (reported by Mike E)
  * Java type mapper had a bug which prevented custom mappers (as
    well as slower interface-based introspection) from working.
   (reported by Mike E)
  * Numeric value parsing had some problems
  * JavaTypeMapper and JsonTypeMapper had a bug which resulted
    in NullPointerException when stream ends, instead of returning
    null to indicate it.
   (reported by Augusto C)
  * JavaTypeMapper did not implicitly flush generator after mapping
    objects: it should, and now will (note: JsonTypeMapper not directly
    affected, flushing still needed)
   (suggested by Maciej P)