Consider fate of `SerializationFeature.WRITE_EMPTY_JSON_ARRAYS`

[cowtowncoder]

(note: based on FasterXML/jackson-annotations#102)

Since existing but deprecated SerializationFeature.WRITE_EMPTY_JSON_ARRAYS does not have exact replacement as is, we need to figure out what to do: main choices being:

1. Figure out a replacement that is close enough to original one (if not exactly same), or
2. Un-deprecate it

In former case we could do something as simple as "move" it to be MapperFeature, so that it can not be (attempted to be) changed on ObjectWriter, since even thought it can nominally be changed, change will not take effect as is.
In latter case we could just let it be used as is, with caveat that its semantics (wrt changing) differ from other SerializationFeatures.

On replacement: one initial thought was to add a new JsonFormat.Feature option; which would work nicely if there was a way to set global default (similar to ObjectMapper.setDefaultPropertyInclusion()), but currently there isn't (there is only per-class facility to set JsonFormat.Value). It would be possible to add such default, but since its only function would be to be used for this one format feature it may not be a way to go since it could be confusing in other ways (since other JsonFormat.Value choices would not be used).

[jlous]

Glad to see the need for this functionality need is taken seriously.
What kind of config it ends up as does not matter to me, but here are a couple of thoughts for now:

• The Javadoc should be changed straight away so as not to send more people on a wild-goose-chase for the nonexistent config override
• There are two distinct use cases with important differences:
  • Providing a default config when POJOs are not annotated. This is covered pretty well.
  • Overriding annotations globally. It would be really great to have a general mechanism for this. Sometimes you don't control the POJOs, and sometimes you just need different behaviour in different contexts. The annotations are great, but they can only say one thing. Conversely you can easily have many different serialisers for varying requierments. Also, the POJOs are sometimes much more 'distant' from you feature code than your (de)serializer. It is not always pertinent to modify your core model to support a localised I/O need.

[cowtowncoder]

Some quick notes: there is a way to define global defaults for some annotatable things already using "config overrides" (added in 2.9), so that in case of inclusion (as an example):

1. There is a global base setting (ObjectMapper.setDefaultPropertyInclusion())
2. There is per-type (class) override (ObjectMapper.configOverride(MyType.class).setIncludeAsProperty())
3. Per-property annotation can further change setting

and I hope to extend coverage for more things; for now, @JsonInclude, @JsonFormat and couple of others are covered.

But as importantly, for 3.0 I hope to add step between 1 and 2 for "class categories" like "all scalars", "all collections" -- we'll see how that goes. This would in some form allow "all types that map to JSON Array" (or a small set of things you could use, things get hairy between JSON/Java mapping).

Documentation is a good point but... it is obviously quite tricky, if there is no clear replacement.
Obviously we are open to incremental improvements.

Not sure if above helps, but thought it worth sharing.