| Version: 1.9.13 |
| Release date: xx-xxx-2013 |
| |
| Another patch release for 1.9. |
| |
| Fixes: |
| |
| * [JACKSON-887]: StackOverflow with parameterized sub-class field |
| (reported by Alexander M) |
| |
| ------------------------------------------------------------------------ |
| === History: === |
| ------------------------------------------------------------------------ |
| |
| 1.9.12 (25-Jan-2013) |
| |
| Fixes: |
| |
| * One more case for [JACKSON-802] (class loading using Class.forName()) |
| * [JACKSON-875]: Enums are not properly serialized when |
| Feature.USE_ANNOTATIONS is disabled |
| (reported by Laurent P) |
| * [JACKSON-884]: JsonStringEncoder.quoteAsStringValue() fails to encode |
| ctrl chars correctly. |
| * [Issue#38]: Infinite loop in `JsonParser.nextFieldName()` with trailing |
| space after field name |
| (reported by matjazs@github) |
| * [Issue#42]: NPE in UTF-32 parser |
| (reported by James R) |
| |
| 1.9.11 (06-Nov-2012) |
| |
| Fixes: |
| |
| * [Issue#8]: Problem with 'SmileGenerator', addSeenName() |
| |
| 1.9.10 (23-Sep-2012) |
| |
| Fixes: |
| * [JACKSON-855]: add StackOverflowError as root cause |
| * [JACKSON-867]: missing Export-Package header for "org.codehaus.jackson.map.ext" |
| (reported by Duncan B) |
| * [Issue#57]: Allow serialization of JDK proxy types |
| * [Issue#71]: java.util.concurrent.ConcurrentNavigableMap support was failing |
| |
| 1.9.9 (28-Jul-2012) |
| |
| Fixes: |
| * [Issue-21]: Improve handling of String hash code collisions for |
| symbol tables; exception for degenerate cases (attacks), improvements |
| for calculation otherwise |
| * [Issue-24]: ArrayIndexOutOfBoundsException with TextBuffer.append() |
| * [JACKSON-853]: JsonStringEncoder.quoteAsString() problem with buffer boundary |
| |
| Other: |
| * Improved multi-threader handling of byte-based symbol table; should |
| reduce lock contention for heavily multi-threaded cases, esp. when |
| parsing short documents. |
| |
| |
| 1.9.8 (28-Jun-2012) |
| |
| Fixes: |
| |
| * [Issue-6]: element count for PrettyPrinter, endObject wrong |
| (reported by "thebluemountain") |
| * [JACKSON-838]: Utf8StreamParser._reportInvalidToken() skips letters |
| from reported token name |
| (reported by Lóránt Pintér) |
| * [JACKSON-841] Data is doubled in SegmentedStringWriter output |
| (reported by Scott S) |
| * [JACKSON-842] ArrayIndexOutOfBoundsException when skipping C-style comments |
| (reported by Sebastien R) |
| * [JACKSON-845] Problem with Object[][] deserialization, default typing |
| (reported by Pawel J) |
| |
| 1.9.7 (02-May-2012) |
| |
| 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) |
| * [Issue-13] Runtime error passing multiple injected values to a constructor |
| (reported by Stuart D) |
| * [Issue-14]: Annotations were not included from parent classes of |
| mix-in classes |
| (reported by @guillaup) |
| * [JACKSON-823] MissingNode does not return default value for 'asXxx()' |
| methods |
| (reported by Adam V) |
| * [JACKSON-829] Custom serializers not working for List<String> properties, |
| @JsonSerialize(contentUsing) |
| (reported by James R) |
| * [JACKSON-831] External type id, explicit property do not work well together |
| (reported by Laurent P) |
| * [JACKSON-832] (partial) Fix numeric range check for Longs (was not working) |
| (reported by Jan J) |
| * [JACKSON-834] Could not use @JsonFactory with non-String argument with Enums |
| (reported by Klaus R) |
| |
| 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 Glinas) |
| * [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) |
