| Version: 1.9.12 | |
| Release date: | |
| xx-Dec-2012 | |
| Description: | |
| Another patch release for 1.9. | |
| Fixes: | |
| * [JACKSON-875]: Enums are not properly serialized when | |
| Feature.USE_ANNOTATIONS is disabled | |
| (reported by Laurent P) | |
| * [Issue#38]: Infinite loop in `JsonParser.nextFieldName()` with trailing | |
| space after field name | |
| (reported by matjazs@github) | |
| ------------------------------------------------------------------------ | |
| === History: === | |
| ------------------------------------------------------------------------ | |
| 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) |