1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.type.WritableTypeId;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.*;
/**
* Intermediate base class for serializers used for various
* Java arrays.
*
* @param <T> Type of arrays serializer handles
*/
@SuppressWarnings("serial")
public abstract class ArraySerializerBase<T>
extends ContainerSerializer<T>
implements ContextualSerializer // for 'unwrapSingleElemArray'
{
protected final BeanProperty _property;
/**
* Setting for specific local override for "unwrap single element arrays":
* true for enable unwrapping, false for preventing it, `null` for using
* global configuration.
*
* @since 2.6
*/
protected final Boolean _unwrapSingle;
protected ArraySerializerBase(Class<T> cls)
{
super(cls);
_property = null;
_unwrapSingle = null;
}
/**
* Use either variant that just takes type (non-contextual), or,
* copy constructor that allows passing of property.
*
* @deprecated Since 2.6
*/
@Deprecated
protected ArraySerializerBase(Class<T> cls, BeanProperty property)
{
super(cls);
_property = property;
_unwrapSingle = null;
}
protected ArraySerializerBase(ArraySerializerBase<?> src)
{
super(src._handledType, false);
_property = src._property;
_unwrapSingle = src._unwrapSingle;
}
/**
* @since 2.6
*/
protected ArraySerializerBase(ArraySerializerBase<?> src, BeanProperty property,
Boolean unwrapSingle)
{
super(src._handledType, false);
_property = property;
_unwrapSingle = unwrapSingle;
}
/**
* @deprecated Since 2.6
*/
@Deprecated
protected ArraySerializerBase(ArraySerializerBase<?> src, BeanProperty property)
{
super(src._handledType, false);
_property = property;
_unwrapSingle = src._unwrapSingle;
}
/**
* @since 2.6
*/
public abstract JsonSerializer<?> _withResolved(BeanProperty prop,
Boolean unwrapSingle);
@Override
public JsonSerializer<?> createContextual(SerializerProvider serializers,
BeanProperty property) throws JsonMappingException
{
Boolean unwrapSingle = null;
// First: if we have a property, may have property-annotation overrides
if (property != null) {
JsonFormat.Value format = findFormatOverrides(serializers, property, handledType());
if (format != null) {
unwrapSingle = format.getFeature(JsonFormat.Feature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);
if (unwrapSingle != _unwrapSingle) {
return _withResolved(property, unwrapSingle);
}
}
}
return this;
}
// NOTE: as of 2.5, sub-classes SHOULD override (in 2.4 and before, was final),
// at least if they can provide access to actual size of value and use `writeStartArray()`
// variant that passes size of array to output, which is helpful with some data formats
@Override
public void serialize(T value, JsonGenerator gen, SerializerProvider provider) throws IOException
{
if (_shouldUnwrapSingle(provider)) {
if (hasSingleElement(value)) {
serializeContents(value, gen, provider);
return;
}
}
gen.writeStartArray();
gen.setCurrentValue(value);
// [databind#631]: Assign current value, to be accessible by custom serializers
serializeContents(value, gen, provider);
gen.writeEndArray();
}
@Override
public final void serializeWithType(T value, JsonGenerator g, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
WritableTypeId typeIdDef = new WritableTypeId(value, JsonToken.START_ARRAY);
// [databind#631]: Assign current value, to be accessible by custom serializers
g.setCurrentValue(value);
typeSer.writeTypePrefix(g, typeIdDef);
serializeContents(value, g, provider);
typeSer.writeTypeSuffix(g, typeIdDef);
}
protected abstract void serializeContents(T value, JsonGenerator jgen, SerializerProvider provider)
throws IOException;
/**
* @since 2.9
*/
protected final boolean _shouldUnwrapSingle(SerializerProvider provider) {
if (_unwrapSingle == null) {
return provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);
}
return _unwrapSingle.booleanValue();
}
}
|
